cannot find -lIpopt, collect2: error: ld returned 1 exit status

[wladimirpetrov]

Hello.

May I ask you to help me out please.
I'm currently trying to implement optimizer C++ library on my research.
I decided to try Ipopt. I followed all instructions https://weigao.space/how/how_to_install_IPOPT(C++)_in_Ubuntu/proceduresEN.html that is similar to the documentation you have here : https://coin-or.github.io/Ipopt/INSTALL.html

In order to check how it works I decided to compare results I received in Matlab (fmincon function) with newly installed IPOPT.

I have a simple task:

A farmer has to build a fence along a river that maximizes the area for a given fence length = 1000.
• Parameters: a = 1000;
• Optimization variables: x = [x1, x2]⊤;
• Initial guess: x0 = [0, 0]⊤;
• Cost function: J(x, a) = −x1x2;
• Constraints: x1 + 2 ∗ x2 − a = 0.

I wrote a pretty much simple code in C++ for solving this task.

#include "Ipopt/src/Interfaces/IpIpoptApplication.hpp"
#include "Ipopt/src/Interfaces/IpTNLP.hpp"

using namespace Ipopt;

class MyNLP : public TNLP {
public:
    MyNLP(double fence_length) : fence_length_(fence_length) {}

    virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style) {
        n = 2;
        m = 1;
        nnz_jac_g = 2;
        nnz_h_lag = 0;
        index_style = TNLP::C_STYLE;
        return true;
    }

    virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u) {
        x_l[0] = 0.0;
        x_l[1] = 0.0;
        x_u[0] = fence_length_;
        x_u[1] = fence_length_ / 2.0;
        g_l[0] = 0.0;
        g_u[0] = 0.0;
        return true;
    }

    virtual bool get_starting_point(Index n, bool init_x, Number* x, bool init_z, Number* z_L, Number* z_U, Index m, bool init_lambda, Number* lambda) {
        x[0] = 0.0;
        x[1] = 0.0;
        return true;
    }

    virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value) {
        obj_value = -x[0] * x[1];
        return true;
    }

    virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g) {
        g[0] = x[0] + 2.0 * x[1] - fence_length_;
        return true;
    }

    virtual bool eval_jac_g(Index n, const Number* x, bool new_x, Index m, Index nele_jac, Index* iRow, Index* jCol, Number* values) {
        if (values == NULL) {
            iRow[0] = 0;
            jCol[0] = 0;
            iRow[1] = 0;
            jCol[1] = 1;
        } else {
            values[0] = 1.0;
            values[1] = 2.0;
        }
        return true;
    }

    virtual bool get_variables_linearity(Index n, LinearityType* var_types) {
        for (Index i = 0; i < n; i++) {
            var_types[i] = TNLP::LINEAR;
        }
        return true;
    }

    virtual bool get_constraints_linearity(Index m, LinearityType* const_types) {
        const_types[0] = TNLP::LINEAR;
        return true;
    }

private:
    double fence_length_;
};

class MyNLPWithSensitivity : public MyNLP {
public:
    MyNLPWithSensitivity(double fence_length) : MyNLP(fence_length) {}

    // Implement the function for sensitivity analysis
    virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f) {
        grad_f[0] = -x[1];  // Partial derivative of f wrt x1
        grad_f[1] = -x[0];  // Partial derivative of f wrt x2
        return true;
    }

    // Implement the function for sensitivity analysis
    virtual void finalize_solution(
        SolverReturn status,
        Index n,
        const Number* x,
        const Number* z_L,
        const Number* z_U,
        Index m,
        const Number* g,
        const Number* lambda,
        Number obj_value,
        const IpoptData* ip_data,
        IpoptCalculatedQuantities* ip_cq) {
        // Implement finalization logic here if needed
    }
};

int main() {
    double a = 1000.0;
    
    // Create a pointer to MyNLPWithSensitivity
    SmartPtr<MyNLPWithSensitivity> myNLP = new MyNLPWithSensitivity(a);
    SmartPtr<IpoptApplication> app = IpoptApplicationFactory();

    app->RethrowNonIpoptException(true);
    ApplicationReturnStatus status = app->Initialize();
    if (status != Solve_Succeeded) {
        std::cout << "IPOPT initialization failed!" << std::endl;
        return -1;
    }

    status = app->OptimizeTNLP(myNLP);

    if (status == Solve_Succeeded) {
        Number obj_value;
        Number x[2];
        myNLP->eval_f(2, x, true, obj_value);

        std::cout << "Optimal x1: " << x[0] << std::endl;
        std::cout << "Optimal x2: " << x[1] << std::endl;
        std::cout << "Optimal J(x, a): " << obj_value << std::endl;
    } else {
        std::cout << "IPOPT optimization failed with status " << status << std::endl;
    }

    return 0;
}

Then I tried to run the code above by using the command
g++ -o farmer_problem farmer_problem.cpp -lIpopt
and I received an error:

/usr/bin/ld: cannot find -lIpopt
collect2: error: ld returned 1 exit status

What should I do to solve the issue? Thank you in advance for your time!

[svigerske]

It should be -lipopt, since the library is libipopt.so or libipopt.a.

Depending on where you installed Ipopt, you may have to let the compiler know where to look for the library with an appropriate -L flag.

[wladimirpetrov]

Thank you very much!!!