R最优化函数的使用

一元函数求最值

optimize(f,interval= ,lower=min(interval),upper=max(interval),tol=，maximum = FALSE....) 

interval:区间，可以与下方的lower和upper互换

lower:最小值

upper:最大值

tol:期望精度

maximum:是否求最大值

f<-function(x) {
     y<-x^3-2*x^2-3*x+5
     y
     }
optimize(f,lower=1,upper=5)
$minimum
[1] 1.86852
$objective
[1] -1.064605

**在x=1.86852处取到最小值为 -1.06460 

多元函数求最值（无约束）

nlm(f, p, ..., hessian = FALSE, typsize = rep(1, length(p)), fscale = 1, print.level = 0, ndigit = 12, gradtol = 1e-6,stepmax = max(1000 * sqrt(sum((p/typsize)^2)), 1000), steptol = 1e-6, iterlim = 100, check.analyticals = TRUE)

f：是一个返回单一值的多元函数

p：最优化的初始点P

gradtol：梯度精度

stepmax：最大步骤数

steptol：步长精度

iterlim：迭代次数

check.analyticals：是否进行结果分析
        code=4：很可能不是最小值
        code=1：很可能是最小值

f<-function(x) {
     y<-100*(x[2]-x[1]^2)^2+(1-x[1])^2
     y
     }
nlm(f,c(-1.2,1))

--------------

$minimum

[1] 3.452977

$estimate

[1] -0.8553545 0.7419449

$gradient

[1] -0.1817065 2.0628184

$code

[1] 4

$iterations

[1] 100

--------------------

minimum：最小值

estimate：取点位置

gradient：此处的梯度 

code：返回代码，判断是否是最小值

iterations：迭代次数

optim(par, fn, gr = NULL, ...,method = c("Nelder-Mead", "BFGS", "CG", "L-BFGS-B", "SANN","Brent"),lower = -Inf, upper = Inf,control = list(), hessian = FALSE)

par：初始点P

fn：返回单值的多元函数

gr：用以返回梯度的函数，默认是"finite-difference approximation"(SANN时则是default Gaussian Markov kernel），也可以指定是其他的，gr在 "BFGS"， "CG" ，"SANN"和 "L-BFGS-B"方法中要用到

method：最优化的方法
        Nelder-Mead：相对稳健的方法（默认），不需要导数。
        CG：适用于高维无约束问题的低内存优化
        BFGS：简单的无约束的准牛顿方法
        L-BFGS-B：用于边界约束问题的优化
        SANN: 模拟退火法
        Brent: 用于一维问题（实际上是调用optimize()）。

lower/upper：区间

hessian：是否返回海森矩阵

f<-function(x) {
     y<-100*(x[2]-x[1]^2)^2+(1-x[1])^2
     y
     }
grad_f<-function(x) {
    g_1<--400*(x[2]-x[1]^2)*x[1]-2*(1-x[1])
    g_2<-200*(x[2]-x[1]^2)
    c(g_1,g_2)
    }
optim(c(-1.2,1),f,grad_f,method="BFGS")
－－－－－－－－－－－－－

$par

[1] 1 1

$value

[1] 9.594955e-18

$counts

function gradient

110 43

$convergence

[1] 0

$message

NULL

－－－－－－－－－－－－

返回值：

par：最优点

value：最小值

convergence：整数返回码
        0：得到的结果时最优的
        1：迭代结束
        10：‎表示 Nelder-Mead 单纯形的简并性‎？？？
        51："L-BFGS-B"出现了一个警告
        52："L-BFGS-B"出现了一个错误

message：附加信息

hessain：返回的海森矩阵
       

多元函数最优化（有约束、线性）

(来自lpSolve包）

lp (direction ="min",objective.in,const.mat,const.dir,const.rhs)

direction：方向是"min"还是"max"

objective.in：目标式的系数向量

const.mat：约束式组的系数矩阵，每个里行向量为一个约束式的系数

const.dir：约束式组的方向，是一个字符向量

const.rhs：约束向量b

        示例：

                20* x1  +  12* x2  <= 1800
                4* x1    +   4* x2   <=  8*60

                即可化为：

                        const.mat        const.dir        const.rhs
                          20，12             "<="                1800
                          4  ， 4              "<="                8*60

##设置决策变量的系数
objective.in <- c(25,20)

##创建约束martix
const.mat <- matrix (c(20,12,4,4),nrow=2,byrow=TRUE)

##约束方向
const.dir <- c("<=","<=")

##RHS用于约束
const.rhs <- c(1800,8*60)

##找到最佳解决方案
res <- lp(direction="max",objective.in,const.mat,const.dir,const.rhs)

多元函数最优化（有约束、非线性）

来自Rdonlp2包，如果直接安装不上(not avalivable），可以在​​​​​https://r-forge.r-project.org/R/?group_id=156​​​​​​​x

里面下载Rdonlp2的tar.gz包，然后在本地自己做一个出来：
install.packages("C:/Users/xxxx/Desktop/Rdonlp2_3042.11.tar.gz", repos = NULL, type = "source")

donlp2(par,fn,
       par.upper=rep(+Inf,length(par)),
       par.lower=rep(+Inf,length(par)),
       A=NULL,
       lin.upper=rep(+Inf,length(par)),
       lin.lower=rep(-Inf,length(par)),
       nlin=list(),
       nlin.upper=rep(+Inf,length(nlin)),
       nlin.lower=rep(-Inf,length(nlin)),
       control=donlp2.control(),
       control.fun=function(lst){return(TRUE)},
       env=.GlobalEnv,
       name="Rdonlp2"
       )
par：自变量（参数），是一个向量
fn：一个多元的连续函数
par.upper/par.lower：自变量定义域
A：线性约束矩阵，每个行向量均为一个线性约束式的参数，其大于的小于的值被移到了lin.upper和lin.lower中，这里只表示抽象的线性约束式子本身，其形式参考上文optim()
lin.upper/lin.lower：各个线性约束条件式的上下界，只有一个不等式的需要引入inf，整个合起来作为矩阵的话，每行均代表A中每个行向量代表的式子的上下界
nlin : 非线性约束条件函数列表，类型为list

例子：参考文章R语言与优化模型（二）：非线性规划与多目标规划_louwill12的博客-CSDN博客

 中的例子