目标最小化  ?
满足  和  约束

#include <iostream>
#include <cppad/ipopt/solve.hpp>

using namespace std;

namespace{
    using CppAD::AD;
    class FG_eval{
    public:
        typedef CPPAD_TESTVECTOR(AD<double>) ADvector;

        void operator()(ADvector& fg, const ADvector& x)
{
            assert(fg.size()==3);
            assert(x.size()==2);

            // 目标函数
            fg[0]=2 * x[0]+ 3 * x[1];

            // 约束条件
            fg[1]=x[0]+ x[1]- 3.0;
            fg[2]=2.0 * x[0]- x[1]- 4.0;

            return;
        }
    };

}

int main()
{
    cout << "Linear Programming Example" << endl;

    bool ok=true;
    size_t i;
    typedef CPPAD_TESTVECTOR(double) Dvector;

    size_t nx=2; // 决策变量的数量
    size_t ng=2; // 约束条件的数量
    Dvector x0(nx); // 决策变量的初始条件
    x0[0]=1.0;
    x0[1]=1.0;

    // 决策变量的上下界
    Dvector xl(nx), xu(nx);
    for(i=0; i < nx; i++)
{
        xl[i]=0.0; // x_i >=0
        xu[i]=1e19; // 无上界
    }
    Dvector gl(ng), gu(ng);
    gl[0]=3.0;    gu[0]=1e19; // x1 + x2 >=3
    gl[1]=-1e19;  gu[1]=4.0;  // 2x1 - x2 <=4

    // 求解器需要一个评估目标函数和约束的对象
    FG_eval fg_eval;

    // 选项
    string options;
    options +="Integer print_level  0\
";
    options +="String sb            yes\
";
    options +="Integer max_iter     10\
";
    options +="Numeric tol          1e-6\
";
    options +="String derivative_test   second-order\
";
    options +="Numeric point_perturbation_radius   0.\
";

    // 存储最终解的对象
    CppAD::ipopt::solve_result<Dvector> solution;

    // 使用Ipopt求解器
    CppAD::ipopt::solve<Dvector, FG_eval>(options, x0, xl, xu, gl, gu, fg_eval, solution);

    // 输出最优解
    cout << "Optimal objective value: " << solution.obj_value << endl;
    cout << "Optimal decision variables: ";
    for (size_t i=0; i < nx; ++i){
        cout << solution.x[i]<< " ";
    }
    cout << endl;

    return 0;
}

#include <cppad/ipopt/solve.hpp>

namespace{//这里的 namespace 用于限定 FG_eval 类的作用域。
using CppAD::AD;
class FG_eval{
public:
    //CPPAD_TESTVECTOR 是 CppAD 中定义的一个宏，用于创建 AD 向量。
    typedef CPPAD_TESTVECTOR(AD<double>) ADvector;
    //operator() 函数实现了仿函数的功能，计算目标函数和约束。在这里，目标函数和约束的数量都是 3 个。
    void operator()(ADvector& fg, const ADvector& x)
{
        //assert 语句用于确保 fg 向量和 x 向量的大小分别为 3 和 4。
        assert(fg.size()==3);
        assert(x.size()==4);

        //将决策变量从 x 向量中提取出来，分别赋值给 x1、x2、x3 和 x4
        AD<double> x1=x[0];
        AD<double> x2=x[1];
        AD<double> x3=x[2];
        AD<double> x4=x[3];

        // f(x) 目标函数
        fg[0]=x1 * x4 * (x1 + x2 + x3) + x3;

        // 约束
        fg[1]=x1 * x2 * x3 * x4;
        fg[2]=x1 * x1 + x2 * x2 + x3 * x3 + x4 * x4;
        return;
    }

};

bool get_started(void)
{
    bool ok=true;
    size_t i;
    typedef CPPAD_TESTVECTOR(double) Dvector;

    size_t nx=4; // 决策变量个数
    size_t ng=2; // 决策约束个数

    Dvector x0(nx); // 变量初始值
    x0[0]=1.0;
    x0[1]=5.0;
    x0[2]=5.0;
    x0[3]=1.0;

    // 决策变量界限设置
    Dvector xl(nx), xu(nx);
    for(i=0; i < nx; i++)
{
        xl[i]=1.0;
        xu[i]=5.0;
    }

    Dvector gl(ng), gu(ng);
    gl[0]=25.0;    gu[0]=1.0e19;
    gl[1]=40.0;    gu[1]=40.0;//等式约束描述为等式约束

    FG_eval fg_eval;//创建了 FG_eval 类的实例，用于计算目标函数和约束

   
    string options; // 字符串，用于存储 Ipopt 求解器的选项。

    //设置打印级别，0 表示关闭所有打印输出。在求解器运行时，
    //它会输出一些信息，例如每次迭代的结果等。通过将打印级别设置为 0，可以减少冗余的输出信息。
    options +="Integer print_level  0\
";

    options +="String sb            yes\
";

    // 设置最大迭代次数为 10。这是一个控制求解器运行时间的参数。
    //如果求解器达到了最大迭代次数而没有找到满足收敛标准的解，求解器将提前退出。
    options +="Integer max_iter     10\
";

    //设置收敛容许误差。这个参数控制求解器停止迭代的条件，
    //当当前迭代的优化进度足够小（小于 tol）时，求解器将停止运行。
    options +="Numeric tol          1e-6\
";

    options +="String derivative_test   second-order\
";

    //置数值微分的随机扰动半径。在进行数值微分时，为了计算梯度和黑塞矩阵，
    //可能会对变量进行小幅度的扰动。这个选项设置了扰动的最大半径。将其设置为 0 表示关闭数值微分。
    options +="Numeric point_perturbation_radius   0.\
";


    CppAD::ipopt::solve_result<Dvector> solution; // 将结果存储在 solution 
    CppAD::ipopt::solve<Dvector, FG_eval>(options, x0, xl, xu, gl, gu, fg_eval, solution); // 求解问题
    cout<<"solution: "<<solution.x<<endl;


    //进行最优解的检查，确保求解器成功并且最优解在预期范围内。
    //CppAD::ipopt::solve_result<Dvector>::success 表示求解器成功找到了解。
    ok &=solution.status==CppAD::ipopt::solve_result<Dvector>::success;
    double check_x[]={1.000000, 4.743000, 3.82115, 1.379408};//预期的最优解。这是在已知问题的情况下提前计算的一个参考解。
    
    
    double check_zl[]={1.087871, 0.,       0.,       0.      };
    double check_zu[]={0.,       0.,       0.,       0.      };

    //相对容差和绝对容差。在进行近似相等性比较时，通常会使用相对容差和绝对容差。这两个参数用于定义两个值在多大程度上被认为是相等的。
    double rel_tol=1e-6; // relative tolerance
    double abs_tol=1e-6; // absolute tolerance

  //对最优解的逐个分量进行检查。使用 CppAD::NearEqual 函数进行比较，
  //如果解与预期解在相对容差和绝对容差内足够接近，则 ok 变量会保持为 true，否则为 false。
    for(i=0; i < nx; i++)
{
        ok &=CppAD::NearEqual(
                    check_x[i], solution.x[i], rel_tol, abs_tol);
        ok &=CppAD::NearEqual(
                    check_zl[i], solution.zl[i], rel_tol, abs_tol);
        ok &=CppAD::NearEqual(
                    check_zu[i], solution.zu[i], rel_tol, abs_tol);
    }

    return ok;
}

int main()
{
    cout << "CppAD : Hello World Demo!" << endl;
    get_started();
    return 0;
}

add_executable(opti
  src/opti.cpp
)
target_link_libraries(opti
  ${catkin_LIBRARIES}
  ${OCTOMAP_INCLUDE_DIRS}
  ${SIPP_LINK_LIBS}
  ${PYTHON_LIBRARIES}
  m
  ipopt
}
3