Last updated on 2020-05-21 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 Optimization Infrastructure Packages, General Purpose Continuous Solvers, Mathematical Programming Solvers, and Specific Applications in Optimization, or Multi Objective Optimization. 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 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 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
or maximum.
Function `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 `nlm`

which
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 optimization time.
- 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
`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), Broyden-Fletcher-Goldfarb-Shanno (BFGS) and limited memory BFGS (L-BFGS) methods. Most internal parameters can be set through the calling interface.
- 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 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. - Package SCOR solves optimization problems under the constraint that the combined parameters lie on the surface of a unit hypersphere.
- 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] - 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 quasi-Newton BFGS method without constraints. - optimsimplex provides building blocks for simplex-based optimization algorithms such as the Nelder-Mead, Spendley, Box method, or multi-dimensional search by Torczon, etc.
- 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] - 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] - 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]
- 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]
- 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]
- mixsqp implements the "mix-SQP" algorithm, based on sequential quadratic programming (SQP), for maximum likelihood estimations in finite mixture models; the algorithm is expected to be accurate and to arrive at solutions quickly.
- 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 computation.
- Package
jlmelville/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 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 nlsr provides tools for working with nonlinear
least-squares 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 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
`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.
- 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 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 (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 optimization
- 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.)
- 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 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. - 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. - The Jaya package provides an implementation of the Jaya algorithm, a population based heuristic algorithm which repeatedly modifies a population by looking at best and worst solutions.
- 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 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 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 multi-objective continuous or discrete optimization problems. And emoa has a collection of building blocks for the design and analysis of evolutionary multiobjective optimization algorithms.
- 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 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 (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.
- 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 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 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
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 two-phase 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]

- The NEOS Server for Optimization provides online access to state-of-the-art optimization problem solvers. The packages rneos and ROI.plugin.neos enable 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 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
`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`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 functions. [MILP] - 'Clp' and 'Cbc' are open source solvers from the COIN-OR 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:
dirkschumacher/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 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] - 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 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 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 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 functions approach).
- 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. [COP, MM]
- 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 Concorde TSP Solver, which has to be downloaded separately. [SPLP]

- Function
`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 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.
- 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 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).
- 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.

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, Jaya, rgenoud, cmaes, nloptr, NMOF, OOR
- 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): caRamel, GPareto, mco, emoa
- NLP (Nonlinear programming, 90C30): nloptr, alabama, Rsolnp, Rdonlp2, rLindo
- GRAPH (Programming involving graphs or networks, 90C35): igraph
- 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, lbfgsb3c, nloptr, optimParallel, ucminf - DF (Derivative-free methods, 90C56): dfoptim, minqa, nloptr

- Journal of Statistical Software Special Volume on Optimization (Editor: Ravi Varadhan)
- Nonlinear Parameter Optimization Using R Tools -- John C. Nash (Wiley)
- Modern Optimization With R -- Paulo Cortez (Springer UseR Series)
- Yet Another Math Programming Consultant
- COIN-OR Project
- NEOS Optimization Guide
- Decision Tree for Optimization Software
- Mathematics Subject Classification - Mathematical programming

3 years ago by George Vega Yon

Implementation of Artificial Bee Colony (ABC) Optimization

7 years ago by Katharine M. Mullen

The Stark-Parker algorithm for bounded-variable least squares

7 days ago by Fabrice Zaoui

Automatic Calibration by Evolutionary Multi Objective Algorithm

6 years ago by Mauricio Zambrano-Bigiarini

Benchmark functions for the Special Session and Competition on Real-Parameter Single Objective Optimization at CEC-2013

2 years ago by Xiyue Liao

Primal or Dual Cone Projections with Routines for Constrained Regression

2 years ago by Yasser Gonzalez-Fernandez

Estimation of Distribution Algorithms Based on Copulas

2 years ago by Peter Solymos

Data Cloning and MCMC Tools for Maximum Likelihood Methods

4 years ago by Eduardo L. T. Conceicao

Differential Evolution Optimization in Pure R

4 years ago by Max Kuhn

Function Optimization and Ranking via Desirability Functions

6 months ago by Pascal Kerschke

Feature-Based Landscape Analysis of Continuous and Constrained Optimization Problems

3 days ago by Charlie Wusuo Liu

Mining Rigs for Specialized Subset Sum, Multi-Subset Sum, Multidimensional Subset Sum, Multidimensional Knapsack, Generalized Assignment Problems

6 months ago by Mickael Binois

Gaussian Processes for Pareto Front Estimation and Optimization

6 years ago by Katharine Mullen

Objective functions for benchmarking the performance of global optimization algorithms

5 months ago by Mauricio Zambrano-Bigiarini

Particle Swarm Optimisation, with Focus on Environmental Models

5 years ago by Patrick Mair

Active Set and Generalized PAVA for Isotone Optimization

7 months ago by Matthew L Fidler

Limited Memory BFGS Minimizer with Bounds on Parameters with optim() 'C' Interface

8 months ago by Gábor Csárdi

Interface to 'Lp_solve' v. 5.5 to Solve Linear/Integer Programs

3 months ago by Florian Schwendinger

R Interface to 'lp_solve' Version 5.5.2.0

5 months ago by Sean R. Martin

An R Interface to the 'ROPTLIB' Library for Riemannian Manifold Optimization

2 years ago by Mehmet Hakan Satman

Machine Coded Genetic Algorithms for Real-Valued Optimization Problems

6 years ago by Olaf Mersmann

Multiple Criteria Optimization Algorithms and Related Functions

4 years ago by Katharine M. Mullen

R Interface to the Levenberg-Marquardt Nonlinear Least-Squares Algorithm Found in MINPACK, Plus Support for Bounds

6 years ago by Katharine M. Mullen

Derivative-free optimization algorithms by quadratic approximation

4 months ago by Peter Carbonetto

Sequential Quadratic Programming for Fast Maximum-Likelihood Estimation of Mixture Proportions

7 months ago by Jakob Richter

Bayesian Optimization and Model-Based Optimization of Expensive Black-Box Functions

3 months ago by Matthew Fidler

Port of the 'Scilab' 'n1qn1' Modules for Un-constrained BFGS Optimization

a year ago by Natalya Pya Arnqvist

Nonnegative Integer Solutions of Linear Diophantine Equations with Applications

9 years ago by Katharine Mullen

The Lawson-Hanson algorithm for non-negative least squares (NNLS)

5 months ago by Florian Gerber

Parallel Version of the L-BFGS-B Optimization Method

6 months ago by John C Nash

Expanded Replacement and Extension of the 'optim' Function

10 months ago by Berwin A. Turlach

Functions to Solve Quadratic Programming Problems

6 years ago by John C. Nash

Conjugate Gradient Minimization of Nonlinear Functions

2 years ago by Dirk Eddelbuettel

Global Optimization by Differential Evolution in C++

10 months ago by Yixuan Qiu

'Rcpp' Integration for Numerical Computing Libraries

6 months ago by Hector Corrada Bravo

R Interface to the CSDP Semidefinite Programming Library

2 years ago by Jasjeet Singh Sekhon

R Version of GENetic Optimization Using Derivatives

a year ago by Christoph Bergmeir

Continuous Optimization using Memetic Algorithms with Local Search Chains (MA-LS-Chains) in R

3 years ago by Benoit Thieurmel

'Clp (Coin-or linear programming)' Plugin for the 'R' Optimization Interface

a month ago by Florian Schwendinger

'NEOS' Plug-in for the 'R' Optimization Interface

a month ago by Florian Schwendinger

'qpOASES' Plugin for the 'R' Optimization Infrastructure

4 years ago by John C Nash

Truncated Newton Function Minimization with Bounds Constraints

6 years ago by Jon Clayden

General-Purpose Optimisation With the Self-Organising Migrating Algorithm

2 years ago by Michael Braun

Trust Region Optimization for Nonlinear Functions with Sparse Hessians

4 years ago by Stig Bousgaard Mortensen

General-Purpose Unconstrained Non-Linear Optimization