ipopt-sys 0.6.0

Raw unsafe Rust bindings to the Ipopt non-linear optimization library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#include "c_api.h"
#include "nlp.hpp"

#include <coin/IpIpoptApplication.hpp>
#include <memory>
#include <vector>
#include <iterator>

using namespace std;

enum CNLP_CreateProblemStatus cnlp_create_problem(
        CNLP_ProblemPtr * const out_problem,
        CNLP_Index index_style,
        CNLP_Sizes_CB sizes,
        CNLP_Init_CB init,
        CNLP_Bounds_CB bounds,
        CNLP_Eval_F_CB eval_f,
        CNLP_Eval_G_CB eval_g,
        CNLP_Eval_Grad_F_CB eval_grad_f,
        CNLP_Eval_Jac_G_CB eval_jac_g,
        CNLP_Eval_H_CB eval_h,
        CNLP_ScalingParams_CB scaling)
{
    // make sure input is Ok
    if ( !init ) {
        return CNLP_MISSING_INITIAL_GUESS;
    } else if ( !sizes ) {
        return CNLP_MISSING_SIZES;
    } else if ( !bounds ) {
        return CNLP_MISSING_BOUNDS;
    } else if ( !eval_f ) {
        return CNLP_MISSING_EVAL_F;
    } else if ( !eval_grad_f ) {
        return CNLP_MISSING_EVAL_GRAD_F;
    }

    CNLP_ProblemPtr problem = nullptr;

    Ipopt::IpoptApplication *app = new Ipopt::IpoptApplication;

    CNLP_CreateProblemStatus status = CNLP_SUCCESS;

    try {
        // Create the original nlp
        problem = new CNLP_Problem(
                app,
                index_style,
                sizes,
                init,
                bounds,
                eval_f,
                eval_g,
                eval_grad_f,
                eval_jac_g,
                eval_h,
                scaling);
    }
    catch (INVALID_NLP& exc) {
        exc.ReportException(*app->Jnlst(), Ipopt::J_ERROR);
        status = CNLP_INVALID_PROBLEM_DEFINITION_ON_CREATE;
    }
    catch( Ipopt::IpoptException& exc ) {
        exc.ReportException(*app->Jnlst(), Ipopt::J_ERROR);
        status = CNLP_UNRECOVERABLE_EXCEPTION_ON_CREATE;
    }

    app->RethrowNonIpoptException(false);

    *out_problem = problem;
    return status;
}

void cnlp_free_problem(CNLP_ProblemPtr problem)
{
    delete problem;
}

CNLP_Bool cnlp_add_str_option(CNLP_ProblemPtr problem, const char* keyword, const char* val)
{
    std::string tag(keyword);
    std::string value(val);
    return (CNLP_Bool) problem->get_app()->Options()->SetStringValue(tag, value);
}

CNLP_Bool cnlp_add_num_option(CNLP_ProblemPtr problem, const char* keyword, CNLP_Number val)
{
    std::string tag(keyword);
    Ipopt::Number value = val;
    return (CNLP_Bool) problem->get_app()->Options()->SetNumericValue(tag, value);
}

CNLP_Bool cnlp_add_int_option(CNLP_ProblemPtr problem, const char* keyword, CNLP_Int val)
{
    std::string tag(keyword);
    Ipopt::Index value = val;
    return (CNLP_Bool) problem->get_app()->Options()->SetIntegerValue(tag, value);
}

CNLP_Bool cnlp_open_output_file(CNLP_ProblemPtr problem, const char* file_name,
                                CNLP_Int print_level)
{
    std::string name(file_name);
    Ipopt::EJournalLevel level = Ipopt::EJournalLevel(print_level);
    return (CNLP_Bool) problem->get_app()->OpenOutputFile(name, level);
}

void cnlp_set_intermediate_callback(CNLP_ProblemPtr problem,
        CNLP_Intermediate_CB intermediate_cb)
{
    problem->set_intermediate_cb(intermediate_cb);
}

CNLP_SolveResult cnlp_solve(CNLP_ProblemPtr problem, CNLP_UserDataPtr user_data)
{
    return problem->solve(user_data);
}

CNLP_Bool cnlp_init_solution(CNLP_ProblemPtr problem, CNLP_UserDataPtr user_data)
{
    problem->set_user_data(user_data);
    return (CNLP_Bool) problem->init_solution();
}

CNLP_SolverData cnlp_get_solver_data(CNLP_ProblemPtr problem)
{
    return problem->get_solution_arguments();
}