I have solved the problem, refer to
https://github.com/casadi/casadi/issues/2490.
The code:
#include <iostream>
#include <casadi/casadi.hpp>
using namespace casadi;
using namespace std;
class MyCallback : public casadi::Callback {
public:
MyCallback(const std::string& name,const casadi::Dict& opts = casadi::Dict())
{
construct(name, opts);
}
~MyCallback() override {}
// Number of inputs.
casadi_int get_n_in() override { return 2;}
// Number of outputs.
casadi_int get_n_out() override { return 1;}
// Set sparsity of input.
casadi::Sparsity get_sparsity_in(casadi_int i) override {
if(i==0) return casadi::Sparsity::dense(2, 1);
else if (i==1) return casadi::Sparsity::dense(1, 1);
}
// Set sparsity of output.
casadi::Sparsity get_sparsity_out(casadi_int i) override {
return casadi::Sparsity::dense(1, 1);
}
void init() override {
std::cout << "initializing_object! " << std::endl;
}
// Evaluate numerically.
std::vector<casadi::DM> eval(const std::vector<casadi::DM>& arg) const override {
// std::cout << "thie is my evaluating jacobian callback" << std::endl;
DM x= arg[0];
DM p= arg[1];
DM f= sin(x(0)+p);
return {f};
}
bool has_jacobian() const override {return true; }
casadi::Function get_jacobian(const std::string&name, const std::vector<std::string>& inames, const std::vector<std::string> &onames,
const casadi::Dict &opts) const override {
MX x = MX::sym("x",2,1);
MX p = MX::sym("p",1,1);
MX f = MX::sym("f",1,1);
MX res=MX::horzcat({cos(x(0)+p),0,0});
Function f_jac =Function(name,{x,p,f},{res});
return f_jac;
}
};
int main()
{
auto test =MyCallback("my_sin");
std::cout<<test;
MXDict arg,res;
MX x= MX::sym("x",2,1);
MX p= MX::sym("p",1,1);
arg["i0"]=x;
arg["i1"]=p;
MXDict nlp = {{"x", x},{"p",p},{"f",test(arg).at("o0")},{"g",x(1)}};
std::cout<<nlp;
Dict nlp_config_ = {{"ipopt", Dict({{"linear_solver", "ma27"},
{"hessian_approximation","limited-memory"}})}};
Function nlp_solver_=nlpsol("nlp_solver_", "ipopt", nlp,nlp_config_);
std::cout<<nlp_solver_;
DMDict arguments,result;
arguments["x0"]=1.57;
arguments["lbx"]=0;
arguments["ubx"]=3.14;
arguments["p"]=0;
arguments["lbg"]=1;
arguments["ubg"]=1;
result=nlp_solver_(arguments);
std::cout<<result;
}