Does anyone know of any optimization packages out there for R (similar to NUOPT for S+)?
R has many, many packages for optimization; check the CRAN Task view on Optimization: http://cran.r-project.org/web/views/Optimization.html. Of course, for nonlinear programs, there is optim()
, which is standard and includes Broyden-Fletcher-Goldfarb-Shanno's algorithm, and Nelder-Mead. It's a good first start.
Try lpSolve with R.
A simple example:
# Maximize
# x1 + 9 x2 + x3
# Subject to:
# x1 + 2 x2 + 3 x3 <= 9
# 3 x1 + 2 x2 + 2 x3 <= 15
f.obj <- c(1, 9, 3)
f.con <- matrix(c(1, 2, 3, 3, 2, 2), nrow = 2, byrow = TRUE)
f.dir <- c("<=", "<=")
f.rhs <- c(9, 15)
lp("max", f.obj, f.con, f.dir, f.rhs)
lp("max", f.obj, f.con, f.dir, f.rhs)$solution
you should also try the Rglpk package solve LP problems with GLPK (GNU Linear Programming Kit).
An example:
## Simple linear program.
## maximize: 2 x_1 + 4 x_2 + 3 x_3
## subject to: 3 x_1 + 4 x_2 + 2 x_3 <= 60
## 2 x_1 + x_2 + x_3 <= 40
## x_1 + 3 x_2 + 2 x_3 <= 80
## x_1, x_2, x_3 are non-negative real numbers
obj <- c(2, 4, 3)
mat <- matrix(c(3, 2, 1, 4, 1, 3, 2, 2, 2), nrow = 3)
dir <- c("<=", "<=", "<=")
rhs <- c(60, 40, 80)
max <- TRUE
Rglpk_solve_LP(obj, mat, dir, rhs, max = max)
R output:
(Note that $status
an integer with status information about the solution returned. If the control parameter canonicalize_status is set (the default) then it will return 0 for the optimal solution being found, and non-zero otherwise. If the control parameter is set to FALSE it will return the GLPK status codes).
$optimum
[1] 76.66667
$solution
[1] 0.000000 6.666667 16.666667
$status
[1] 0
Linprog, mentioned by Galwegian, focuses on linear programming via the simplex algorithm. In addition you may be interested in fPortfolio if you are doing portfolio optimization.
I have used linprog for linear problems in the past.
Another package is ompr. An advantage of this package is there are many solvers that can be used and binary
, continuous
, integer
all variables can easily be added. A simple example:
library(tidyverse)
library(ompr)
library(ompr.roi)
model <- MIPModel() %>%
add_variable(x1, type = "integer") %>%
add_variable(x2, type = "integer") %>%
set_bounds(x1, lb = 0) %>%
set_bounds(x2, lb = 0) %>%
set_objective(x1 - x2, "max") %>%
add_constraint(x1 + 2*x2 <= 150) %>%
add_constraint(x1 >= 30) %>%
add_constraint(x2 >= 40)
Solving with glpk
:
library(ROI.plugin.glpk)
result <- solve_model(model, with_ROI(solver = "glpk", verbose = TRUE))
get_solution(result, x1)
get_solution(result, x2)
It can also be solved with other solvers like symphony
where the gap_limit
can be set in case the problem is complex and will take many iterations to converge:
library(ROI.plugin.symphony)
result <- solve_model(model, with_ROI(solver = "symphony",
verbosity=-1, gap_limit=1.5))
I like Gurobi. It's very expensive for a license, but it can be obtained through many universities. See here http://www.gurobi.com/products/modeling-languages/r
Have a look on the NLoptr package. It has quite an extensive documentation with examples and lots of algorithms to choose from, depending what problem you are trying to resolve (etc. linear, non-linear, constraint)
Ideally inject a dynamic momentum in nlopt or any optimizer, involving inertia and viscosity. Does not seem available in .R
© 2022 - 2025 — McMap. All rights reserved.