Пример #1
0
extern void* jl_glpkw__iptcp_init()
{
    glp_iptcp * iptcp = calloc(1, sizeof(glp_iptcp));
    glp_init_iptcp(iptcp);
    return (void*) iptcp;
}
Пример #2
0
bool glpk_wrapper::is_sat() {
    if (solver_type == SIMPLEX || solver_type == EXACT) {
        int status = glp_get_status(lp);
        if (status == GLP_UNDEF || changed) {
            glp_smcp parm;
            glp_init_smcp(&parm);
            parm.msg_lev = GLP_MSG_OFF;
            // always try first the normal simple (get close to an optimal solution in double precision)
            int solved = glp_simplex(lp, &parm);
            // TODO(dzufferey) should we always fall back on exact when the normal simplex failed ?
            if (solver_type == EXACT || solved != 0) {
                solved = glp_exact(lp, &parm);
            }
            if (solved != 0) {
                switch (solved) {
                    case GLP_EBADB:
                        throw std::runtime_error("GLPK simplex failed: GLP_EBADB");
                    case GLP_ESING:
                        throw std::runtime_error("GLPK simplex failed: GLP_ESING");
                    case GLP_ECOND:
                        throw std::runtime_error("GLPK simplex failed: GLP_ECOND");
                    case GLP_EBOUND:
                        throw std::runtime_error("GLPK simplex failed: GLP_EBOUND");
                    case GLP_EFAIL:
                        throw std::runtime_error("GLPK simplex failed: GLP_EFAIL");
                    case GLP_EOBJLL:
                        throw std::runtime_error("GLPK simplex failed: GLP_EOBJLL");
                    case GLP_EOBJUL:
                        throw std::runtime_error("GLPK simplex failed: GLP_EOBJUL");
                    case GLP_EITLIM:
                        throw std::runtime_error("GLPK simplex failed: GLP_EITLIM");
                    case GLP_ETMLIM:
                        throw std::runtime_error("GLPK simplex failed: GLP_ETMLIM");
                    case GLP_ENOPFS:
                        throw std::runtime_error("GLPK simplex failed: GLP_ENOPFS");
                    case GLP_ENODFS:
                        throw std::runtime_error("GLPK simplex failed: GLP_ENODFS");
                    default:
                        throw std::runtime_error("GLPK simplex failed");
                }
            }
            status = glp_get_status(lp);
            changed = false;
        }
        return (status == GLP_OPT || status == GLP_FEAS || status == GLP_UNBND);
    } else {
        assert(solver_type == INTERIOR);
        int status = glp_ipt_status(lp);
        if (status == GLP_UNDEF || changed) {
            glp_iptcp parm;
            glp_init_iptcp(&parm);
            parm.msg_lev = GLP_MSG_OFF;
            int solved = glp_interior(lp, &parm);
            if (solved != 0) {
                switch (solved) {
                    case GLP_EFAIL:
                        throw std::runtime_error("GLPK interior-point failed: GLP_EFAIL");
                    case GLP_ENOCVG:
                        throw std::runtime_error("GLPK interior-point failed: GLP_ENOCVG");
                    case GLP_EOBJUL:
                        throw std::runtime_error("GLPK interior-point failed: GLP_EOBJUL");
                    case GLP_EITLIM:
                        throw std::runtime_error("GLPK interior-point failed: GLP_EITLIM");
                    case GLP_EINSTAB:
                        throw std::runtime_error("GLPK interior-point failed: GLP_EINSTAB");
                    default:
                        throw std::runtime_error("GLPK interior-point failed");
                }
            }
            status = glp_ipt_status(lp);
            changed = false;
        }
        return status == GLP_OPT;
    }
}