Last updated on 2022-01-09
by Stefan Theussl,
Florian Schwendinger, Hans W. Borchers
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
General Purpose Continuous
Programming Solvers, and
Specific Applications in
Optimization, or Multi
Packages are categorized according to 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
If you think that some package is missing from the list, please
let us know.
- The optimx package provides a replacement and extension of
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
optimr() in this package extends the
optim() function with the same syntax but more 'method'
opm() applies several solvers to a selected
optimization task and returns a dataframe of results for easy comparison.
- The R Optimization Infrastructure (ROI) package
provides a framework for handling optimization problems in R.
It uses an object-oriented approach to define and solve various
optimization tasks from different problem classes (e.g., linear, quadratic,
non-linear programming problems). This makes optimization transparent
for the user as the corresponding workflow is abstracted from the
underlying solver. The approach allows for easy switching between
solvers and thus enhances comparability. For more information see the
ROI home page.
- The package CVXR provides an object-oriented 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 one-dimensional unconstrained function optimization there is
optimize() which searches an interval for a minimum
optim() provides an implementation of the
Broyden-Fletcher-Goldfarb-Shanno (BFGS) method, bounded BFGS,
conjugate gradient (CG), Nelder-Mead, 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 box-constrained optimization.
Additionally, for minimizing a function subject to
linear inequality constraints, stats contains the routine
constrOptim(). Then there is
is used for solving nonlinear unconstrained minimization problems.
nlminb() offers box-constrained optimization using the
PORT routines. [RGA, QN]
- Package lbfgs wraps the libBFGS C library by Okazaki and
Morales (converted from Nocedal's L-BFGS-B 3.0 Fortran code), interfacing
both the L-BFGS and the OWL-QN algorithm, the latter being particularly
suited for higher-dimensional problems.
- lbfgsb3c interfaces J.Nocedal's L-BFGS-B 3.0 Fortran code,
a limited memory BFGS minimizer, allowing bound constraints and being
applicable to higher-dimensional problems.
It has an 'optim'-like interface based on 'Rcpp'.
- Package roptim provides a unified wrapper to call
C++ functions of the algorithms underlying the optim() solver;
and optimParallel provides a parallel version of the L-BFGS-B
method of optim(); using these packages can significantly reduce the
- RcppNumerical is a collection of open source libraries
for numerical computing and their integration with 'Rcpp'. It provides
a wrapper for the L-BFGS algorithm, based on the LBFGS++ library
(based on code of N. Okazaki).
- Package ucminf implements an algorithm of quasi-Newton
type for nonlinear unconstrained optimization, combining a trust region
with line search approaches. The interface of
designed for easy interchange with
- 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), Broyden-Fletcher-Goldfarb-Shanno (BFGS)
and limited memory BFGS (L-BFGS) methods. Most internal parameters
can be set through the calling interface.
- stochQN provides implementations of stochastic,
limited-memory quasi-Newton optimizers, similar in spirit to the LBFGS.
It includes an implementation of online LBFGS, stochastic quasi-Newton and adaptive quasi-Newton.
- nonneg.cg realizes a conjugate-gradient based method
to minimize functions subject to all variables being non-negative.
- Package dfoptim, for derivative-free optimization
procedures, contains quite efficient R implementations of the
Nelder-Mead and Hooke-Jeeves 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
derivative-free (COBYLA, Nelder-Mead, Subplex) and gradient-based
(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
- 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)
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]
- psqn provides quasi-Newton methods to minimize partially
separable functions; the methods are largely described in "Numerical
Optimization" by Nocedal and Wright (2006).
- clue contains the function
solving constrained optimization problems via the sequential
unconstrained minimization technique (SUMT).
- BB contains the function
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.
- Package SCOR solves optimization problems under the
constraint that the combined parameters lie on the surface of a unit
- GrassmannOptim is a package for Grassmann manifold
optimization. The implementation uses gradient-based algorithms
and embeds a stochastic gradient method for global search.
- ManifoldOptim is an R interface to the 'ROPTLIB'
optimization library. It optimizes real-valued functions over manifolds
such as Stiefel, Grassmann, and Symmetric Positive Definite matrices.
- Package gsl provides BFGS, conjugate gradient,
steepest descent, and Nelder-Mead algorithms. It uses a "line
search" approach via the function
multimin(). It is
based on the GNU Scientific Library (GSL). [RGA, QN]
- Several derivative-free optimization algorithms are provided with
package minqa; e.g., the functions
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]
- 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 "trust region" for unconstrained
nonlinear optimization. The algorithm is optimized for objective
functions with sparse Hessians.
- Package quantreg contains variations of simplex and
of interior point routines (
crq()). It provides an interface to L1 regression
in the R code of function
rq(). [SPLP, LP, IPM]
- In package quadprog
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]
- 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]
- qpmadr interfaces the 'qpmad' software and solves
quadratic programming (QP) problems with linear inequality, equality
and bound constraints, using the method by Goldfarb and Idnani.[QP]
- kernlab contains the function
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]
- coneproj contains routines for cone projection and
quadratic programming, estimation and inference for constrained parametric
regression, and shape-restricted regression problems. [QP]
- LowRankQP primal/dual interior point method solving
quadratic programming problems (especially for semidefinite quadratic
forms). [IPM, QP]
- The COIN-OR project 'qpOASES' implements a reliable QP solver, even
when tackling semi-definite 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]
- QPmin is active set method solver for the solution of
indefinite quadratic programs, subject to lower bounds on linear functions
of the variables. [QP]
- mixsqp implements the "mix-SQP" algorithm, based on
sequential quadratic programming (SQP), for maximum likelihood estimations
in finite mixture models.
- 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
multi-objective 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' (archived) contain many test
functions for global optimization from the 2005 and 2013 special sessions
on real-parameter optimization at the IEEE CEC congresses on evolutionary
- Package jlmelville/funconstrain (on Github)
implements 35 of the test functions by More, Garbow, and Hillstom, useful
for testing unconstrained optimization methods.
handles over- and under-determined systems of linear equations, returning
least-squares solutions if possible. And package stats provides
nls() to determine least-squares estimates of the parameters
of a nonlinear model. nls2 enhances function
with brute force or grid-based searches, to avoid being dependent on
starting parameters or getting stuck in local solutions.
- Package nlsr provides tools for working with nonlinear
least-squares problems. Functions
are intended to eventually supersede the 'nls()' function in Base R, by
applying a variant of the Marquardt procedure for nonlinear least-squares,
with bounds constraints and optionally Jacobian described as R functions.
(It is based on the now-deprecated package nlmrt.)
- Package minpack.lm provides a function
for solving nonlinear least-squares problems by a modification of the
Levenberg-Marquardt algorithm, with support for lower and upper parameter
bounds, as found in MINPACK.
- Package nnls interfaces the Lawson-Hanson implementation of
an algorithm for non-negative least-squares, allowing the combination of
non-negative and non-positive constraints.
- Package gslnls provides an interface to nonlinear least-squares
optimization methods from the GNU Scientific Library (GSL).
The available trust region methods include the Levenberg-Marquadt algorithm
with and without geodesic acceleration, and several variants of Powell's dogleg
- Package bvls interfaces the Stark-Parker implementation of
an algorithm for least-squares with upper and lower bounded variables.
- Package onls implements orthogonal nonlinear least-squares
regression (ONLS, a.k.a. Orthogonal Distance Regression, ODR) using a
Levenberg-Marquardt-type minimization algorithm based on the ODRPACK
- 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
- Package ECOSolveR provides an interface to the Embedded
COnic Solver (ECOS), a well-known, efficient, and robust C library for
convex problems. Conic and equality constraints can be specified in
addition to integer and boolean variable constraints for mixed-integer
- Package scs applies operator splitting to solve linear
programs (LPs), second-order 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, D-optimal experimental
design, Distance Weighted Discrimination, or the maximum cut problem.
- cccp contains routines for solving cone constrained
convex problems by means of interior-point methods. The implemented
algorithms are partially ported from CVXOPT, a Python module for convex
- The CLSOCP package provides an implementation of a one-step
smoothing Newton method for the solution of second order cone programming
- CSDP is a library of routines that implements a primal-dual barrier
method for solving semidefinite programming problems; it is interfaced in
the Rcsdp package. [SDP]
- The DSDP library implements an interior-point method for semidefinite
programming with primal and dual solutions; it is interfaced in package
- Package Rmosek provides an interface to the (commercial)
MOSEK optimization library for large-scale 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
- 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 cross-entropy 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 non-linear objective function with a large number of
- 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
implementation of a genetic algorithm for multi-dimensional function
- Package rgenoud offers
genoud(), a routine
which is capable of solving complex function minimization/maximization
problems by combining evolutionary algorithms with a derivative-based
- 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
ppso available from
- Package hydroPSO implements the Standard Particle Swarm
Optimization (SPSO) algorithm; it is parallel-capable and includes
several fine-tuning options and post-processing functions.
- floybix/hydromad (on Github) contains the
SCEoptim function for Shuffled Compex Evolution (SCE)
optimization, an evolutionary algorithm, combined with a simplex
- 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 multi-objective continuous or discrete
optimization problems. And emoa has a collection of building
blocks for the design and analysis of evolutionary multiobjective
- CMA-ES 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
cmaOptimDP, interfacing Hansen's own Java
- Package Rmalschains implements an algorithm family for
continuous optimization called memetic algorithms with local search chains
- An R implementation of the Self-Organising 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), multi-level
single-linkage (MLSL), improved stochastic ranking (ISR-ES), 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 black-box functions under severely limited budgets;
it implements an extension of the COBRA algorithm with initial design
generation and self-adjusting random restarts.
- OOR implements optimistic optimization methods for global
optimization of deterministic or stochastic functions.
- RCEIM implements a stochastic heuristic method for
performing multi-dimensional 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
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 solver-independent and thus offer the possibility to solve
models with different solvers. (Inspired by Julia's JuMP project.)
- linprog solves linear programming problems using the
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 two-phase tableau simplex
method for (relatively small) linear programming problems. [LP]
- rcdd offers the function
for solving linear programs with exact arithmetic using the
GNU Multiple Precision (GMP)
- 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 branch-and-bound (B&B)
approach. It supports semi-continuous variables and Special Ordered
Sets (SOS). Furthermore
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 R-Forge).
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
that interfaces the SYMPHONY solver for mixed-integer linear programs.
(SYMPHONY is part of the Computational
Infrastructure for Operations Research (COIN-OR) project.)
lpsymphony 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
- 'Clp' and 'Cbc' are open source solvers from the COIN-OR suite.
'Clp' solves linear programs with continuous objective variables and is
available through datastorm-open/ROI.plugin.clp (on GitHub). 'Cbc' is a powerful mixed
integer linear programming solver (based on 'Clp'); package 'rcbc' can
be installed from: dirkschumacher/rcbc (on Github).
This section surveys interfaces to commercial solvers. Typically, the
corresponding libraries have to be installed separately.
- Package Rcplex provides an interface
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 non-convex) 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]
- 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]
- The localsolver package provides an interface to the hybrid
mathematical programming software
LocalSolver from Innovation 24,
combining exact and heuristic techniques. See their website for more
details. (Academic licenses are available on request.)
[LP, MIP, QP, NLP, HEUR]
- 'Gurobi Optimization' ships an R package with its software that
allows to call its solvers from R. Gurobi provides powerful solvers for
LP, MIP, QP, MIQP, SOCP, and MISOCP models. See their website for more details. (Academic licenses are available on request.)
[LP, QP, MILP, MIQP]
Some more commercial companies, e.g. 'Artelys Knitro' or 'FICO Xpress
Optimization', have R interfaces that are installed while the software
gets installed. Trial licenses are available, see the corresponding
websites for more information.
- Package adagio provides R functions for single and multiple
knapsack problems, and solves subset sum and assignment tasks.
- In package clue
the user to solve the linear sum assignment problem (LSAP) using an
efficient C implementation of the Hungarian algorithm. [SPLP]
- FLSSS provides multi-threaded solvers for
fixed-size single and multi dimensional subset sum problems with optional
constraints on target sum and element range,
fixed-size 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
- 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.
- 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 R-Forge 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
- matchingR and matchingMarkets implement the
Gale-Shapley algorithm for the stable marriage and the college admissions
problem, the stable roommates and the house allocation problem.
- Package optmatch provides routines for solving
matching problems by translating them into minimum-cost flow problems
and then solved optimaly by the RELAX-IV 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
Solver, which has to be downloaded separately. [SPLP]
- rminizinc provides an interface to the open-source
constraint modeling language and system (to be downloaded separately)
MiniZinc. R users can apply the
package to solve combinatorial optimization problems by modifying
existing 'MiniZinc' models, and also by creating their own models.
caRamel in package caRamel is a
multi-objective optimizer, applying a combination of the multi-objective
evolutionary annealing-simplex (MEAS) method and the non-dominated sorting
genetic algorithm (NGSA-II); it was initially developed for the
calibration of hydrological models.
- Multi-criteria optimization problems can be solved using package
mco which implements genetic algorithms. [MOP]
- GPareto provides multi-objective optimization algorithms
for expensive black-box functions and uncertainty quantification methods.
- The rmoo package is a framework for multi- and many-objective optimization,
allowing to work with representation of real numbers, permutations and binaries,
offering a high range of configurations.
- 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.
- The irace package implements automatic configuration
procedures for optimizing the parameters of other optimization algorithms,
that is (offline) tuning their parameters by finding the most appropriate
settings given a set of optimization problems.
- 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
model-based 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 Sequential Parameter Optimization Toolbox SPOT provides
a set of tools for model-based optimization and tuning of algorithms. It
includes surrogate models and design of experiment approaches.
- The desirability package contains S3 classes for
multivariate optimization using the desirability function approach
of Harrington (1965).
- maxLik adds a likelihood-specific layer on top of a number
of maximization routines like Brendt-Hall-Hall-Hausman (BHHH) and
Newton-Raphson 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.
What follows is an attempt to provide a by-subject 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,
limSolve, linprog, lpSolve,
lpSolveAPI, quantreg, rcdd,
- GO (Global Optimization): DEoptim, DEoptimR,
GenSA, GA, pso, rgenoud,
cmaes, nloptr, NMOF, OOR
- SPLP (Special problems of linear programming like transportation,
multi-index, etc., 90C08): clue, lpSolve,
- BP (Boolean programming, 90C09):
glpkAPI, lpSolve, lpSolveAPI,
- IP (Integer programming, 90C10):
glpkAPI, lpSolve, lpSolveAPI,
- MIP (Mixed integer programming and its variants MILP for LP
and MIQP for QP, 90C11): glpkAPI,
lpSolve, lpSolveAPI, Rcplex,
- QP (Quadratic programming, 90C20):
kernlab, limSolve, LowRankQP,
quadprog, Rcplex, Rmosek
- SDP (Semidefinite programming, 90C22): Rcsdp,
- CP (Convex programming, 90C25): cccp,
- COP (Combinatorial optimization, 90C27): adagio,
CEoptim, TSP, matchingR
- MOP (Multi-objective and goal programming, 90C29):
caRamel, GPareto, mco,
- NLP (Nonlinear programming, 90C30): nloptr,
alabama, Rsolnp, Rdonlp2
- GRAPH (Programming involving graphs or networks, 90C35):
- IPM (Interior-point methods, 90C51):
kernlab, glpkAPI, LowRankQP,
- RGA (Methods of reduced gradient type, 90C52): stats
- QN (Methods of quasi-Newton type, 90C53): stats
optim()), gsl, lbfgs,
lbfgsb3c, nloptr, optimParallel,
- DF (Derivative-free methods, 90C56): dfoptim,