Maximized Objective Value: 0

[wladimirpetrov]

Hello.
I'm still trying to work with simple tasks to get used to ipopt.
I've tried to work with this task:
We have 2 values x1 and x2 that are both 0 <= x1 <= 10, 0 <= x2 <= 10. Their sum is x1+x2 <=20. I need to maximize the product between x1 and x2.

here is my code:

#include "Ipopt/src/Interfaces/IpIpoptApplication.hpp"
#include "Ipopt/src/Interfaces/IpTNLP.hpp"
#include <iostream>

using namespace Ipopt;

class DerivedOptimizationProblem : public TNLP {
public:
    // Constructor
    DerivedOptimizationProblem() {}

    // Define problem dimensions
    virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style) {
        // Number of variables
        n = 2;

        // Number of constraints
        m = 1;

        // Number of non-zero elements in the Jacobian of the constraints
        nnz_jac_g = 2;

        // Number of non-zero elements in the Hessian of the Lagrangian (0 if not available)
        nnz_h_lag = 0;

        // Use C-style indexing
        index_style = TNLP::C_STYLE;
        return true;
    }

    // Define bounds for variables and constraints
    virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u) {
        // Variable bounds
        x_l[0] = 0.0; // x1 lower bound
        x_u[0] = 10.0; // x1 upper bound
        x_l[1] = 0.0; // x2 lower bound
        x_u[1] = 10.0; // x2 upper bound

        // Constraint bounds
        g_l[0] = 0; // Lower bound for the constraint
        g_u[0] = 20; // Upper bound for the constraint
        return true;
    }

    // Define initial guess for the variables
    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) {
        // Initialize the variables
        x[0] = 0.0; // Initial guess for x1
        x[1] = 0.0; // Initial guess for x2
        return true;
    }

    // Define the objective function
    virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value) {
        // Objective: maximize the product of x1 and x2
        obj_value = -x[0] * x[1]; // Negative sign bc of maximization
        return true;
    }

    // Define the constraints
    virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g) {
        // Constraint: x1 + x2 <= 20
        g[0] = x[0] + x[1];
        return true;
    }

    // Define the Jacobian of the constraints
    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) {
            // Non zero elements for Jacobian
            iRow[0] = 0; // Row index for the constraint
            jCol[0] = 0; // Column index for x1
            iRow[1] = 0; // Row index for the constraint
            jCol[1] = 1; // Column index for x2
        } else {
            // Calculate the values of the Jacobian matrix
            values[0] = 1.0; // Deriv of the constraint wrt x1
            values[1] = 1.0; // Deriv of the constraint wrt x2
        }
        return true;
    }

    // Define the gradient of the objective function
    virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f) {
        // Implement the gradient evaluation
        grad_f[0] = -x[1]; // Partial derivative wrt to x1
        grad_f[1] = -x[0]; // Partial derivative wrt to x2
        return true;
    }

    // Implement the missing finalize_solution function
    virtual void finalize_solution(
        Ipopt::SolverReturn status,
        Ipopt::Index n,
        const Number* x, 
        const Number* z_L, 
        const Number* z_U,
        Ipopt::Index m, 
        const Number* g, 
        const Number* lambda, 
        Ipopt::Number obj_value,
        const IpoptData* ip_data, 
        Ipopt::IpoptCalculatedQuantities* ip_cq) {
    
    }
};

int main() {
    SmartPtr<TNLP> problem = new DerivedOptimizationProblem();
    SmartPtr<IpoptApplication> app = IpoptApplicationFactory();

    // Adjust the maximum number of iterations
    app->Options()->SetIntegerValue("max_iter", 1000); 
    // Adjust the convergence tolerance
    app->Options()->SetNumericValue("tol", 1e-6); 
    // Set Hessian approximation method
    app->Options()->SetStringValue("hessian_approximation", "limited-memory");

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

    status = app->OptimizeTNLP(problem);

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

        std::cout << "Optimal solution:" << std::endl;
        std::cout << "x1: " << x[0] << std::endl;
        std::cout << "x2: " << x[1] << std::endl;
        std::cout << "Maximized Objective Value: " << -obj_value << std::endl; // Restore the objective value to its positive form
    } else {
        std::cout << "IPOPT optimization failed with status " << status << std::endl;
    }

    return 0;
}

The issue is that my maximized value has to be equal to "100" however ipopt calculated it so the maximized objective value is equal to "0"

I checked the constraints several times, everything seemed to be correct. It seems like it was minimizing the value. however in my objective value obj_value = -x[0] * x[1]; I put - What can be an issue?

[svigerske]

-9.9999931446e+01 seems pretty close to -100 to me.

What you expect you will get from

        Number x[2];
        problem->eval_f(2, x, true, obj_value);

?

Maybe https://coin-or.github.io/Ipopt/INTERFACES.html#INTERFACE_CPP could help, in particular the part about finalize_solution.

[wladimirpetrov]

yes, you're right, i'm just having problems with the solution representation. thank you!