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:

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.

- Trying to unify optimization algorithms via a single wrapper
function,
optimx helps to proper specify the (nonlinear) optimization problem including objective function, gradient function, and scaling. This package supports the (local) optimization of smooth, nonlinear functions with at most box constraints (bounds).optimx depends not only on packages and/or functions mentioned in this section of this task view but also on two packages implemented by the author(s), namelyRcgmin andRvmmin . Both are "pure R" implementations of conjugate gradient minimization and variable metric nonlinear function minimization algorithms, respectively. - 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 in R which can be from different problem classes (e.g., linear, quadratic, non-linear programming problems). This makes optimization transparent for the R user as the corresponding workflow is completely abstracted from the underlying solver. Furthermore, this approach allows for easy switching between solvers, given that corresponding solver plugins are available, and thus enhances comparability.

- Package stats offers several general purpose optimization routines.
First, function
`optim()`

provides an implementation of the Broyden-Fletcher-Goldfarb-Shanno (BFGS) method, bounded BFGS, conjugate gradient, 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()`

. For one-dimensional unconstrained function optimization there is`optimize()`

which searches an interval for a minimum or maximum. Then there is`nlm`

which is used for solving nonlinear unconstrained minimization problems. Eventually,`nlminb()`

offers unconstrained and constrained optimization using PORT routines. [RGA, QN] -
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] - Implementations of the augmented Lagrange barrier minimization
algorithm for optimizing smooth nonlinear objective functions (with
equality and inequality constraints) can be found in packages
alabama andRsolnp . NlcOptim solves nonlinear optimization problems with linear and nonlinear equality and inequality constraints, implementing a Sequential Quadratic Programming (SQP) method.clue contains the function`sumt()`

for solving constrained optimization problems via the sequential unconstrained minimization technique (SUMT).- Package
dfoptim , derivative-free optimization procedures, contains quite efficient R implementations of the Nelder-Mead and Hooke-Jeeves algorithms (unconstrained and bounds-constrained). [DF] GrassmannOptim is a package for Grassmann manifold optimization. The implementation uses gradient-based algorithms and embeds a stochastic gradient method for global search.- 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] lbfgsb3 interfaces the J.Nocedal et al. L-BFGS-B 3.0 Fortran code, a limited memory BFGS solver, allowing bound constraints and being applicable to higher-dimensional problems. [QN]lbfgs wraps the libBFGS library by N.Okazaki, interfacing both the L-BFGS and the OWL-QN algorithm, the latter being particularly suited for higher-dimensional problems. [QN]- Package
maxLik provides a general purpose Newton-Raphson optimizer`maxNR()`

as well as wrapper to methods, implemented in`optim()`

. It supports fitting a submodel by specifying constant parameters. - An R port of the Scilab neldermead module is packaged in
neldermead offering several direct search algorithms based on the simplex approach. - Several derivative-free 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.- Package
ucminf implements an algorithm of quasi-Newtonian type for nonlinear unconstrained optimization. [QN] - 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
nleqslv provides a function`nleqslv()`

implementing Newton and Broyden methods with line search and trust region global strategies for solving medium sized system of nonlinear equations. - Package
rgenoud offers`genoud()`

, a routine which is capable of solving complex function minimization/maximization problems by combining evolutionary algorithms with a derivative-based (quasi-Newtonian) approach.

- Function
`solve.qr()`

(resp.`qr.solve()`

) 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`nls()`

with brute force or grid-based searches, to avoid being dependent on starting parameters or getting stuck in local solutions. - Package
nlmrt provides tools for minimizing nonlinear sums of squares. The function to be minimized can be provided as an R function or as an expression, similar to the way that nls() works.`nlmrt::nlxb()`

tries to compute analytic derivatives for the Jacobian used in a Levenberg-Marquardt. This allows for the solution of problems with poorly conditioned Jacobians and small residuals - Package
minpack.lm provides a function`nls.lm()`

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
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 Fortran library.

- 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 problems. - Package
scs applies operator splitting to solve linear programs, cone programs (SOCP), and semidefinite programs; cones can be second-order, exponential, power cones, or any combination of these. cccp contains routines for solving cone constrained convex problems by means of interior-point methods (partially ported from Python's CVXOPT).- The
CLSOCP package provides an implementation of a one-step smoothing Newton method for the solution of second order cone programming (SOCP) problems. - 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
Rdsdp . [SDP] - 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`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.)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 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 multi-dimensional function optimization. - 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 inpsoptim . 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 (SPSO-2011); it is parallel-capable, and includes several fine-tuning options and post-processing functions. - CMA-ES by N. Hansen, a global optimization procedure using a covariance
matrix adapting evolutionary strategy, is implemented in several packages:
In packages
cmaes andcmaesr , inparma as`cmaes`

, inadagio as`pureCMAES`

, and inrCMA as`cmaOptimDP`

, interfacing Hansen's own Java implementation. - Package
Rmalschains implements an algorithm family for continuous optimization called memetic algorithms with local search chains (MA-LS-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. RCEIM implements a stochastic heuristic method for performing multidimensional function optimization.

- Package
linprog solves linear programming problems using the function`solveLP()`

(the solver is based onlpSolve ) and can read model files in MPS format. [LP] - In package
quadprog `solve.QP()`

solves quadratic programming problems with linear equality and inequality constraints. [QP] 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.- 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] kernlab contains the function`ipop`

for solving quadratic programming problems using interior point methods. [IPM, QP]limSolve offers to solve linear or quadratic optimization functions. [LP, QP]LowRankQP primal/dual interior point method solving quadratic programming problems [IPM, QP]- Package
rcdd offers the function`lpcdd()`

for solving linear programs with exact arithmetic using the GNU Multiple Precision (GMP) library. [LP] - 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] - The NEOS Server
for Optimization provides online access to state-of-the-art
optimization problem solvers. Package
rneos enables the user to pass optimization problems to NEOS and retrieve results within R.

- Package
clpAPI provides high level access from R to low-level 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 branch-and-bound (B&B) approach. It supports semi-continuous 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 packagelpSolveAPI which provides an R interface to the low level API routines of lp_solve (see also projectlpsolve 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 packageRglpk 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 mixed-integer linear programs. (SYMPHONY is part of the Computational Infrastructure for Operations Research (COIN-OR) 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.

- Packages
cplexAPI andRcplex provide an interface to the CPLEX solver package from IBM. CPLEX provides dual/primal simplex optimizers as well as a barrier optimizer for solving large scale linear and quadratic programs. Furthermore, 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 from IBM. 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.). Note that you have to get a license from MOSEK. 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 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] - Package
qap solves Quadratic Assignment Problems (QAP) applying a simulated annealing heuristics (other approaches will follow). - The
CEoptim package provides an optimization solver, based on the Cross-Entropy method, for continuous and combinatorial optimization problems. It can be used to solve multi-extremal problems, accepts linear constraints,and handles discrete and continuous variables. [COP] - 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. - Objective functions for benchmarking the performance of
global optimization algorithms can be found in
globalOptTests . Packagesmoof has generators for a number of both single- and multi-objective test functions that are frequently used for the benchmarking optimization algorithms. cec2013 andcec2005benchmark 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 computation.- Package
goalprog provides some functions for lexicographic linear goal programming and optimization. Goal programming is a branch of multi-objective, multi-criteria decision analysis. [MOP] 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]irace contains an optimization algorithm for optimizing the parameters of other optimization algorithms. This problem is called "(offline) algorithm configuration". [GO]matchingR andmatchingMarkets implement the Gale-Shapley algorithm for the stable marriage and the college admissions problem, the stable roommates and the house allocation problem. [COP, MM]- 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. 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. It also provides a function to check whether an analytic derivative is computed directly.- Multi-criteria optimization problems can be solved using
package
mco which implements genetic algorithms. [MOP] - Package
optmatch provides routines for solving matching problems by translating them into minimum-cost flow problems, which are in turn solved optimally by the RELAX-IV codes of Bertsekas and Tseng (free for research). [SPLP] - 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] - 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 front-end to a series of heuristic routines for optimizing some bivariate graph statistic. [GRAPH] - 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]

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 ,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,
multi-index, 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 (Multi-objective and goal programming, 90C29):
goalprog ,mco - NLP (Nonlinear programming, 90C30):
nloptr ,alabama ,Rsolnp , Rdonlp2,rLindo - GRAPH (Programming involving graphs or networks, 90C35):
igraph ,sna - IPM (Interior-point methods, 90C51):
cplexAPI ,kernlab ,glpkAPI ,LowRankQP ,quantreg ,Rcplex - RGA (Methods of reduced gradient type, 90C52): stats
(
`optim()`

),gsl - QN (Methods of quasi-Newton type, 90C53): stats
(
`optim()`

),gsl ,lbfgs ,lbfgsb3 ,nloptr ,ucminf - DF (Derivative-free methods, 90C56):
dfoptim ,minqa ,nloptr - HEUR (Approximation methods and heuristics, 90C59):
irace