Nlopt优化函数库，用法举例

最新推荐文章于 2024-04-07 11:32:19 发布
最新推荐文章于 2024-04-07 11:32:19 发布
阅读量1.4k 收藏 9
点赞数
原文链接：http://www.cnblogs.com/GuanghuiLiu/p/9967684.html
版权 

/*
 * main.c
 *
 *  Created on: Oct 9, 2018
 *      Author: lgh
 */


#include <stdio.h>
#include <math.h>
#include "nlopt.h"
#define INF (1.0/0.0)
int i=0;

//目标函数；
double utility(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
      grad[0]=2*x[0];
      grad[1]=2*x[1];
    }
    printf("迭代次数 i= %d, x[0]=%f, x[1]= %f，f(x1,x2)=%f\n",i++,x[0],x[1],x[0]*x[0]+x[1]*x[1]+8);
  return ( x[0]*x[0]+x[1]*x[1]+8 );
}

//等式限制条件；
double constraint(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
          grad[0]= -1.0;
          grad[1]= -2*x[1];
    }

  return (-x[0]-x[1]*x[1]+2);
}

//不等式限制条件；
double inconstraint(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= -2*x[0];
     grad[1]= 1.0;
    }
  return (-x[0]*x[0]+x[1]);
}


int main(int argc, char const *argv[])
{
  double tol=1e-8;
  double lb[2]={0,0};          //x1、x2的下边界；
  double ub[2]={INF,INF};
  double x[2]={1, 1};      //给x1、x2赋予初始值；
  double f_max;

  nlopt_opt opter=nlopt_create( NLOPT_LD_SLSQP, 2);

  //设置自变量下限；
  nlopt_set_lower_bounds(opter, lb);

  // 目标函数；
  nlopt_set_min_objective(opter, utility, NULL);

  // 不等式约束；
  nlopt_add_inequality_constraint(opter, inconstraint, NULL, tol);

  // 等式约束；
  nlopt_add_equality_constraint(opter, constraint, NULL, tol);

  // 停止时需要的条件；
  nlopt_set_xtol_rel(opter, tol);

  // 开始优化；
  nlopt_result result=nlopt_optimize(opter, x, &f_max);

  if (result)
  {
    printf("目标函数最大值=%g, x=(%g,%g)\n", f_max, x[0], x[1]);
  }

  //free
  nlopt_destroy(opter);
  return 0;
}

结果：

迭代次数 i= 0, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 1, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 2, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 3, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 4, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 5, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 6, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 7, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 8, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 9, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 10, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 11, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 12, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 13, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 14, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 15, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 16, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 17, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 18, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 19, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 20, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 21, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 22, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 23, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
迭代次数 i= 24, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=10.000000
目标函数最大值=10, x=(1,1)

 

/*
 * main.c
 *
 *  Created on: Oct 9, 2018
 *      Author: lgh
 */


#include <stdio.h>
#include <math.h>
#include "nlopt.h"
#define INF (1.0/0.0)
int i=0;

//目标函数；
double utility(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
      grad[0]=-1.0+x[0];
      grad[1]=-2.0+x[2];
    }
    printf("迭代次数 i= %d, x[0]=%f, x[1]= %f，f(x1,x2)=%f\n",
            i++,x[0],x[1],-x[0]-2*x[1]+0.5*x[0]*x[0]+0.5*x[1]*x[1]);
  return (-x[0]-2*x[1]+0.5*x[0]*x[0]+0.5*x[1]*x[1]);
}


//不等式限制条件；
double inconstraint_1(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= 2.0;
     grad[1]= 3.0;
    }
  return (2*x[0]+3*x[1]-6);
}

//不等式限制条件；
double inconstraint_2(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= 1.0;
     grad[1]= 4.0;
    }
  return (x[0]+4*x[1]-5);
}

//不等式限制条件；
double inconstraint_3(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= 2.0;
     grad[1]= 6.0*x[1];
    }
  return (2*x[0]+3*x[1]*x[1]-6);
}


int main(int argc, char const *argv[])
{
  double tol=1e-4;
  double lb[2]={0,0};       //x1、x2的下边界；
  double ub[2]={INF,INF};
  double x[2]={1, 1};      //给x1、x2赋予初始值；
  double f_min;

  nlopt_opt opter=nlopt_create( NLOPT_LD_SLSQP, 2);

  //设置自变量下限；
  nlopt_set_lower_bounds(opter, lb);

  // 目标函数；
  nlopt_set_min_objective(opter, utility, NULL);

  // 不等式约束；
  nlopt_add_inequality_constraint(opter, inconstraint_1, NULL, tol);
  nlopt_add_inequality_constraint(opter, inconstraint_2, NULL, tol);
  nlopt_add_inequality_constraint(opter, inconstraint_3, NULL, tol);

  // 停止时需要的条件；
  nlopt_set_xtol_rel(opter, tol);

  // 开始优化；
  nlopt_result result=nlopt_optimize(opter, x, &f_min);

  if (result)
  {
    printf("极小值=%g, x=(%g,%g)\n", f_min, x[0], x[1]);
  }

  //free
  nlopt_destroy(opter);
  return 0;
}

结果为：

迭代次数 i= 0, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=-2.000000
迭代次数 i= 1, x[0]=0.764706, x[1]= 1.058824，f(x1,x2)=-2.029412
迭代次数 i= 2, x[0]=0.750000, x[1]= 1.062500，f(x1,x2)=-2.029297
迭代次数 i= 3, x[0]=0.759904, x[1]= 1.060024，f(x1,x2)=-2.029400
迭代次数 i= 4, x[0]=0.762660, x[1]= 1.059335，f(x1,x2)=-2.029410
迭代次数 i= 5, x[0]=0.763753, x[1]= 1.059062，f(x1,x2)=-2.029411
迭代次数 i= 6, x[0]=0.764245, x[1]= 1.058939，f(x1,x2)=-2.029412
迭代次数 i= 7, x[0]=0.764479, x[1]= 1.058880，f(x1,x2)=-2.029412
迭代次数 i= 8, x[0]=0.764594, x[1]= 1.058852，f(x1,x2)=-2.029412
迭代次数 i= 9, x[0]=0.764650, x[1]= 1.058838，f(x1,x2)=-2.029412
迭代次数 i= 10, x[0]=0.764678, x[1]= 1.058831，f(x1,x2)=-2.029412
迭代次数 i= 11, x[0]=0.764692, x[1]= 1.058827，f(x1,x2)=-2.029412
迭代次数 i= 12, x[0]=0.764699, x[1]= 1.058825，f(x1,x2)=-2.029412
迭代次数 i= 13, x[0]=0.764699, x[1]= 1.058825，f(x1,x2)=-2.029412
极小值=-2.02941, x=(0.764706,1.05882)

对于例子二这种有多个非线性约束的情况，也可以采用多非线性函数：

/*
 * main.c
 *
 *  Created on: Oct 9, 2018
 *      Author: lgh
 */

/*************************************************************************
 * 函数：
 * nlopt_result nlopt_add_inequality_mconstraint( nlopt_opt opt, unsigned m,
 *                         nlopt_mfunc c, void* c_data, const double *tol );
 **************************************************************************/

#include <stdio.h>
#include <math.h>
#include "nlopt.h"
#define INF (1.0/0.0)
int i=0;

//目标函数；
double objective_fun(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
      grad[0]=-1.0+x[0];
      grad[1]=-2.0+x[2];
    }
    printf("迭代次数 i= %d, x[0]=%f, x[1]= %f，f(x1,x2)=%f\n",
            i++,x[0],x[1],-x[0]-2*x[1]+0.5*x[0]*x[0]+0.5*x[1]*x[1]);
  return (-x[0]-2*x[1]+0.5*x[0]*x[0]+0.5*x[1]*x[1]);
}

//不等式限制条件；
void c(unsigned m, double *result, unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= 2.0;
     grad[1]= 3.0;
     grad[2]= 1.0;
     grad[3]= 4.0;
     grad[4]= 2.0;
     grad[5]= 6*x[1];
    }
    result[0] = 2*x[0] + 2*x[1]-6;
    result[1] = x[0] + 4*x[1] - 5;
    result[2] = 2*x[1] + 3*x[1]*x[1]-6;
}

int main(int argc, char const *argv[])
{
  double tol=1e-4;
  double lb[2]={0,0};       //x1、x2的下边界；
  double x[2]={1, 1};      //给x1、x2赋予初始值；
  double f_min;

  nlopt_opt opter=nlopt_create( NLOPT_LN_COBYLA, 2);

  //设置自变量下限；
  nlopt_set_lower_bounds(opter, lb);

  // 目标函数；
  nlopt_set_min_objective(opter, objective_fun, NULL);

  // 多个不等式约束；
  nlopt_add_inequality_mconstraint(opter, 3, c, NULL, NULL);

  // 停止时需要的条件；
  nlopt_set_xtol_rel(opter, tol);

  // 开始优化；
  nlopt_result result=nlopt_optimize(opter, x, &f_min);

  if (result)
  {
     printf("极小值=%g, x=(%g,%g)\n", f_min, x[0], x[1]);
  }

  //free
  nlopt_destroy(opter);
  return 0;
}

 

/*
 * main.c
 *
 *  Created on: Oct 9, 2018
 *      Author: lgh
 */


#include <stdio.h>
#include <math.h>
#include "nlopt.h"
#define INF (1.0/0.0)
int i=0;

//目标函数；
double utility(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
      grad[0]=1.0/x[0];
      grad[1]=1.0/x[1];
    }
    printf("迭代次数 i= %d, x[0]=%f, x[1]= %f，f(x1,x2)=%f\n",
          i++,x[0],x[1],log(x[0])+log(x[1]));
  return (log(x[0])+log(x[1]));
}

//等式限制条件；
double constraint(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= 1.0;
     grad[1]= 2.0;
    }
  return (x[0]+2*x[1]-5);
}

//不等式限制条件；
double inconstraint(unsigned n, const double *x, double *grad, void *data)
{
    if(grad){
     grad[0]= 1.0;
     grad[1]= -1.0;
    }
  return (x[0]-x[1]);
}


int main(int argc, char const *argv[])
{
  double tol=1e-4;
  double lb[2]={0,0};       //x1、x2的下边界；
  double ub[2]={INF,INF};
  double x[2]={1, 1};      //给x1、x2赋予初始值；
  double f_min;

  nlopt_opt opter=nlopt_create( NLOPT_LD_SLSQP, 2);

  //设置自变量下限；
  nlopt_set_lower_bounds(opter, lb);

  // 目标函数；
  nlopt_set_max_objective(opter, utility, NULL);

  // 不等式约束；
  nlopt_add_inequality_constraint(opter, inconstraint, NULL, tol);

  //添加等式约束；
  nlopt_add_equality_constraint(opter,  constraint,  NULL,  tol);

  // 停止时需要的条件；
  nlopt_set_xtol_rel(opter, tol);

  // 开始优化；
  nlopt_result result=nlopt_optimize(opter, x, &f_min);

  if (result)
  {
    printf("极小值=%g, x=(%g,%g)\n", f_min, x[0], x[1]);
  }

  //free
  nlopt_destroy(opter);
  return 0;
}

结果为：

迭代次数 i= 0, x[0]=1.000000, x[1]= 1.000000，f(x1,x2)=0.000000
迭代次数 i= 1, x[0]=1.666667, x[1]= 1.666667，f(x1,x2)=1.021651
极小值=1.02165, x=(1.66667,1.66667)

/*
 * main.c
 *
 *  Created on: Oct 9, 2018
 *      Author: lgh
 */


#include <stdio.h>
#include <math.h>
#include "nlopt.h"
#define INF (1.0/0.0)

typedef struct{
    double a, b;
}my_constraint_data;
int i=0;

//不等式约束；
double myconstraint(unsigned n, const double *x, double *grad, void *data)
{
    //将所需要的参数传递给不等式约束的参数；
    my_constraint_data *d = (my_constraint_data*)data;
    double a =d->a, b =d->b;
    if(grad){
        grad[0] = 3*a*(a*x[0]+b)*(a*x[0]+b);
        grad[1] = -1.0;
    }
    return ( (a*x[0]+b)*(a*x[0]+b)*(a*x[0]+b)-x[1] );
}

//设置目标函数，n为目标函数的个数，由nlopt_create函数的第2个参数设置；
//double *x存放自变量数组，初始值在nlopt_optimize函数中第2个参数进行设置；
// grad如果不为空，则grad[0]到grad[n-1]分别存放各个自变量x的偏倒数；
double myfunc(unsigned n, const double *x, double *grad, void *my_func_data)
{
    if(grad){
        grad[0] = 0.0;
        grad[1] = 0.5/sqrt(x[1]);
    }
    i++;
    printf("迭代寻优的次数为： i=%d\n",i);
    return sqrt(x[1]);
}

int main()
{
    //设置自变量{x0,x1}的下限；
    double lb[2] = {-INF,0};

    nlopt_opt opt = nlopt_create(NLOPT_LD_MMA,2);
    nlopt_set_lower_bounds(opt,lb);
    nlopt_set_min_objective(opt,myfunc,NULL);

    //为两个不等式的系数；
    my_constraint_data data[2] = {{2,0},{-1,1}};

    //添加不等式约束，data[0]是给a、b进行赋值；
    nlopt_add_inequality_constraint(opt,myconstraint,&data[0],1e-8);
    nlopt_add_inequality_constraint(opt,myconstraint,&data[1],1e-8);

    //当前后差值小于 1e-4时就跳出迭代循环；
    nlopt_set_xtol_rel(opt,1e-4);

    //设置最大迭代寻优次数；
    nlopt_set_maxeval(opt,5000);

    //设置初始值；
    double x[2] = {1.234, 5.678};
    double minf;

    if(nlopt_optimize(opt,x,&minf)<0){
        printf("nlopt 搜索失败.\n");
    }
    else{
        printf("找到最小值 f(%g,%g) = %0.10g\n",x[0],x[1],minf);
    }
    nlopt_destroy(opt);
    return 0;
}

结果为：

迭代寻优的次数为： i=1
迭代寻优的次数为： i=2
迭代寻优的次数为： i=3
迭代寻优的次数为： i=4
迭代寻优的次数为： i=5
迭代寻优的次数为： i=6
迭代寻优的次数为： i=7
迭代寻优的次数为： i=8
迭代寻优的次数为： i=9
迭代寻优的次数为： i=10
迭代寻优的次数为： i=11
找到最小值 f(0.333333,0.296296) = 0.5443310474

 

转载于:https://www.cnblogs.com/GuanghuiLiu/p/9967684.html

weixin_33937499
关注
NLopt优化库在c++下的使用
potxxx的博客
06-20 6641
  NLopt在windows下的安装以及vs下的include可以参考其他博客，本文主要记录nlopt示例程序的c++使用。数学模型如下：目标函数求最大值，约束函数为后两行；#include"nlopt.hpp" using namespace nlopt; 使用c++接口首先包含.hpp文件，相应的接口名均在nlopt命名空间里。/*******************************...
NLOPT使用说明及参考程序c、c++
08-14
可以在vs2013或vs2015上运行，非线性约束优化数值库Nlopt
nlopt优化库使用
guijiaqing的博客
10-14 423
nlopt简介：https://www.guyuehome.com/35109 c++ nlopt库使用范例：https://www.guyuehome.com/35169 nlopt库文件网站：https://nlopt.readthedocs.io/en/latest/NLopt_Algorithms/
Nlopt在c++里的简单应用
weixin_42345358的博客
03-13 1067
https://blog.csdn.net/potxxx/article/details/80743146
nlopt库的使用
m0_54853503的博客
05-15 376
https://nlopt.readthedocs.io/en/latest/NLopt_Installation/
nlopt 二次优化
weixin_30354675的博客
08-02 295
/* * main.c * * Created on: Oct 9, 2018 * Author: lgh */ #include <stdio.h> #include <math.h> #include "nlopt.h" #define INF 1e10 int i = 0; double step ...
nlopt:非线性优化库，包含许多用于全局和局部，约束或无约束优化的算法
04-30
NLopt是一个用于非线性局部和全局优化的库，用于具有和不具有梯度信息的函数。 它被设计为简单，统一的界面，并包装了多个免费/开源非线性优化库。 可以从Github上的页面下载最新版本，并且托管在readthedocs上。 ...
nimnlopt：非线性优化库Nlopt的包装
02-03
**nimnlopt：非线性优化库Nlopt的包装** 在计算机科学和工程领域，优化问题常常出现在各种计算任务中，例如机器学习、数据分析和控制理论等。非线性优化是解决这类问题的关键技术之一，它涉及寻找函数的最小值或...
基于C/C++的非线性优化库nlopt
03-22
3. **无梯度优化算法**：对于无法获取或计算梯度的函数，nlopt提供了一些无梯度的优化方法，如Nelder-Mead简单形法、Powell法和Conjugate Gradient（CG）法。 4. **约束优化**：nlopt支持有约束的优化问题，可以...
非线性优化库——NLopt
我才睡醒的博客
06-12 4512
在trac_ik中用到-&gt; NLopt是一个用于非线性优化的免费/开放源代码库，为在线提供的许多不同的免费优化例程提供通用接口，以及各种其他算法的原始实现。 其功能包括： 安装NLOPT ：直接在终端 输入 ：sudo apt-get install libnlopt.dev include 文档参考https://nlopt.readthedocs.io/en/late...
NLopt在C++和win+VS下的使用
10-20
https://mp.csdn.net/postedit/102653703，这是我的博客最后的成品，如果嫌麻烦，就直接下载使用
NLopt
最新发布
try_trying_try的博客
04-07 504
非线性优化–NLopt(nonlinear optimization)是一个免费的开源的库，提供了很多种非线性优化算的使用接口。1、其中非常大的优势就是提供多种支持的语言，包括C/ C++/ Julia/ Python/ R/ Fortran/ Lua/ OCaml/ Octave等都支持。
非线性优化算法求解线性规划（python）
weixin_45452300的博客
04-05 1834
Nlopt是一种求解非线性模型最优解的一种集合算法，尝试一下线性模型中的应用 问题： x1+x2+x3<=95 6x1+5x2+2x3<=400 5x1+2x2<=200 12x1+10x2+16x3<1200 x1,x2,x3>=0 使得6x1+4x2+3x3最大 这个其实可以用Excel或者单纯搜索法手动计算，这里测试下nlopt中的SUBPLEX算法在上面的应用 import nlopt # 导入模块 # 定义代价函数 class ObjectiveFunction(
Nlopt优化包在Windows上的安装配置及C/C++应用案例
象牙塔小明的博客
02-21 6019
​​​1.Nlopt优化包介绍 ​ NLopt是一个用于非线性优化的免费/开源库，提供了多种局部优化、全局优化算法的原始实现及通用接口，类似于MATLAB中的 fmincon ，其简单粗暴，方便好用，支持C++，但是其安装配置稍显麻烦。现有的帖子中多多少少不够全面或者有些许问题，因此特作此文作为总结，So，废话少说，进入正题。 2.下载Nlopt优化包 Nlopt下载地址：ht...
非线性优化--NLopt算法使用及C++实例
月照银海似蛟龙的博客
09-16 3273
NLopt--非线性优化--算法使用及C++实例NLopt 支持的算法命名规律：算法选择选择全局优化要注意的问题CodeResult 看这篇之前建议先看这篇，里面讲了非线性优化的原理即相关名词的概念，然后介绍了NLopt的使用方法，这个方法是基于C语言的，本片介绍一个NLopt的实例，用的C++语言。 在实例之前，先介绍下NLopt支持的算法，以及算法使用的注意事项 NLopt 支持的算法 NLopt 包含很多种不同的优化算法。 在头文件里面算法名称的枚举类型为 enum algorithm {
非线性优化库NLopt简介
老越爱吃鱼
04-03 9894
非线性优化库NLopt NLopt 是一个轻量级开源非线性优化库, 为多种优化算法提供了统一的接口。 主页：https://nlopt.readthedocs.io/en/latest/ git：https://github.com/stevengj/nlopt 目录 非线性优化库NLopt 目录 下载安装 API nlopt_create nlopt_set_min_obj...
python valueerror函数使用_Python：scipy.optimize.minimize在使用x和y args调用函数时失败并显示“ValueError：设置带序列的数组元素 . ”...
weixin_33252423的博客
01-14 540
如 Headers 中所述，scipy.optimize.minimize失败并显示“ValueError：使用序列设置数组元素” . 当调用最小化时 .我正在将scipy.optimize.minimize应用于使用变量coef(我正在优化的系数)和xData和yData(数据变量)的函数 .我'll provide an example code below. I am aware throu...
NLopt--非线性优化--原理介绍及使用方法
dbdxnuliba的博客
06-03 1097
NLopt--非线性优化--原理介绍及使用方法
Nlopt在matlab中的配置教程
罗伯特祥的博客
10-12 667
Nlopt在matlab中的配置教程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值