LinearProblem& LinearProblem::operator=(const LinearProblem &old) {
if (&old != this) {
glp_delete_prob(this->lp_);
copyFrom(old);
}
return *this;
}
/**
* Delete the MLP problem and free the constrain matrix
*
* @param mlp the MLP handle
*/
static void
mlp_delete_problem (struct GAS_MLP_Handle *mlp)
{
if (mlp != NULL)
{
if (mlp->prob != NULL)
glp_delete_prob(mlp->prob);
/* delete row index */
if (mlp->ia != NULL)
{
GNUNET_free (mlp->ia);
mlp->ia = NULL;
}
/* delete column index */
if (mlp->ja != NULL)
{
GNUNET_free (mlp->ja);
mlp->ja = NULL;
}
/* delete coefficients */
if (mlp->ar != NULL)
{
GNUNET_free (mlp->ar);
mlp->ar = NULL;
}
mlp->ci = 0;
mlp->prob = NULL;
}
}
void NUMlinprog_delete (NUMlinprog me) {
if (! me) return;
if (my linearProgram) glp_delete_prob (my linearProgram);
NUMvector_free <int> (my ind, 1);
NUMvector_free <double> (my val, 1);
Melder_free (me);
}
void ios_proxy_heur(glp_tree *T)
{ glp_prob *prob;
int j, status;
double *xstar, zstar;
/* this heuristic is applied only once on the root level */
if (!(T->curr->level == 0 && T->curr->solved == 1))
goto done;
prob = glp_create_prob();
glp_copy_prob(prob, T->mip, 0);
xstar = xcalloc(1+prob->n, sizeof(double));
for (j = 1; j <= prob->n; j++)
xstar[j] = 0.0;
if (T->mip->mip_stat != GLP_FEAS)
status = proxy(prob, &zstar, xstar, NULL, 0.0,
T->parm->ps_tm_lim, 1);
else
{ double *xinit = xcalloc(1+prob->n, sizeof(double));
for (j = 1; j <= prob->n; j++)
xinit[j] = T->mip->col[j]->mipx;
status = proxy(prob, &zstar, xstar, xinit, 0.0,
T->parm->ps_tm_lim, 1);
xfree(xinit);
}
if (status == 0)
glp_ios_heur_sol(T, xstar);
xfree(xstar);
glp_delete_prob(prob);
done: return;
}
int main(void)
{ glp_prob *mip;
glp_tran *tran;
int ret;
mip = glp_create_prob();
tran = glp_mpl_alloc_wksp();
ret = glp_mpl_read_model(tran, "sudoku.mod", 1);
if (ret != 0)
{ fprintf(stderr, "Error on translating model\n");
goto skip;
}
ret = glp_mpl_read_data(tran, "sudoku.dat");
if (ret != 0)
{ fprintf(stderr, "Error on translating data\n");
goto skip;
}
ret = glp_mpl_generate(tran, NULL);
if (ret != 0)
{ fprintf(stderr, "Error on generating model\n");
goto skip;
}
glp_mpl_build_prob(tran, mip);
glp_simplex(mip, NULL);
glp_intopt(mip, NULL);
ret = glp_mpl_postsolve(tran, mip, GLP_MPL_MIP);
if (ret != 0)
fprintf(stderr, "Error on postsolving model\n");
skip: glp_mpl_free_wksp(tran);
glp_delete_prob(mip);
return 0;
}
int GLPKClearSolver() {
if (GLPKModel != NULL) {
glp_delete_prob(GLPKModel);
GLPKModel = NULL;
}
return SUCCESS;
}
// call destructor from the R level to guarantee that data has been
// copied to R data structures.
void Rglpk_delete_prob() {
extern glp_prob *lp;
// delete problem object (if any)
if (lp){
glp_delete_prob(lp);
lp = NULL;
}
}
int main(void)
{
glp_prob *mip = glp_create_prob();
glp_set_prob_name(mip, "sample");
glp_set_obj_dir(mip, GLP_MAX);
// 拘束条件
// 具体的な関数は後で
glp_add_rows(mip, 3); // 拘束条件の数
glp_set_row_name(mip, 1, "c1"); glp_set_row_bnds(mip, 1, GLP_DB, 0.0, 20.0);
glp_set_row_name(mip, 2, "c2"); glp_set_row_bnds(mip, 2, GLP_DB, 0.0, 30.0);
glp_set_row_name(mip, 3, "c3"); glp_set_row_bnds(mip, 3, GLP_FX, 0.0, 0);
// 変数
// 変数そのものにかかる拘束は、拘束条件ではなくてこちらで管理
glp_add_cols(mip, 4); // 変数の数
glp_set_col_name(mip, 1, "x1");
glp_set_col_bnds(mip, 1, GLP_DB, 0.0, 40.0); glp_set_obj_coef(mip, 1, 1.0);
glp_set_col_name(mip, 2, "x2");
glp_set_col_bnds(mip, 2, GLP_LO, 0.0, 0.0); glp_set_obj_coef(mip, 2, 2.0);
glp_set_col_name(mip, 3, "x3");
glp_set_col_bnds(mip, 3, GLP_LO, 0.0, 0.0); glp_set_obj_coef(mip, 3, 3.0);
glp_set_col_kind(mip, 3, GLP_IV); // 整数値としての宣言
glp_set_col_name(mip, 4, "x4");
glp_set_col_bnds(mip, 4, GLP_DB, 2.0, 3.0); glp_set_obj_coef(mip, 4, 1.0);
glp_set_col_kind(mip, 4, GLP_IV); // 整数値としての宣言
int ia[1+9], ja[1+9];
double ar[1+9];
ia[1]=1,ja[1]=1,ar[1]=-1; // a[1,1] = -1
ia[2]=1,ja[2]=2,ar[2]=1; // a[1,2] = 1
ia[3]=1,ja[3]=3,ar[3]=1; // a[1,3] = 1
ia[4]=1,ja[4]=4,ar[4]=10; // a[1,4] = 10
ia[5]=2,ja[5]=1,ar[5]=1; // a[2,1] = 1
ia[6]=2,ja[6]=2,ar[6]=-3; // a[2,2] = -3
ia[7]=2,ja[7]=3,ar[7]=1; // a[2,3] = 1
ia[8]=3,ja[8]=2,ar[8]=1; // a[3,2] = 1
ia[9]=3,ja[9]=4,ar[9]=-3.5; // a[3,4] = -3.5
glp_load_matrix(mip, 9, ia, ja, ar);
glp_iocp parm;
glp_init_iocp(&parm);
parm.presolve = GLP_ON;
int err = glp_intopt(mip, &parm);
double z = glp_mip_obj_val(mip);
double x1 = glp_mip_col_val(mip, 1);
double x2 = glp_mip_col_val(mip, 2);
double x3 = glp_mip_col_val(mip, 3);
double x4 = glp_mip_col_val(mip, 4);
printf("\nz = %g; x1 = %g; x2 = %g; x3 = %g, x4 = %g\n", z, x1, x2, x3, x4);
// z = 122.5; x1 = 40; x2 = 10.5; x3 = 19.5, x4 = 3
glp_delete_prob(mip);
return 0;
}
int main(void)
{ glp_prob *P;
P = glp_create_prob();
glp_read_mps(P, GLP_MPS_DECK, NULL, "25fv47.mps");
glp_adv_basis(P, 0);
glp_simplex(P, NULL);
glp_print_sol(P, "25fv47.txt");
glp_delete_prob(P);
return 0;
}
int main(void)
{ glp_prob *P;
glp_smcp parm;
P = glp_create_prob();
glp_read_mps(P, GLP_MPS_DECK, NULL, "25fv47.mps");
glp_init_smcp(&parm);
parm.meth = GLP_DUAL;
glp_simplex(P, &parm);
glp_print_sol(P, "25fv47.txt");
glp_delete_prob(P);
return 0;
}
static PyObject* LPX_Erase(LPXObject *self) {
#if GLPK_VERSION(4, 29)
glp_erase_prob(LP);
#else
// Approximate the functionality by deleting and reassigning the
// underlying pointer. The Python code shouldn't actually know the
// difference.
if (LP) glp_delete_prob(LP);
self->lp = glp_create_prob();
#endif
Py_RETURN_NONE;
}
int main(void) {
glp_prob *lp;
int ia[1+1000], ja[1+1000];
double ar[1+1000], z, x1, x2, x3;
s1: lp = glp_create_prob();
s2: glp_set_prob_name(lp, "sample");
s3: glp_set_obj_dir(lp, GLP_MAX);
s4: glp_add_rows(lp, 3);
s5: glp_set_row_name(lp, 1, "p");
s6: glp_set_row_bnds(lp, 1, GLP_UP, 0.0, 100.0);
s7: glp_set_row_name(lp, 2, "q");
s8: glp_set_row_bnds(lp, 2, GLP_UP, 0.0, 600.0);
s9: glp_set_row_name(lp, 3, "r");
s10: glp_set_row_bnds(lp, 3, GLP_UP, 0.0, 300.0);
s11: glp_add_cols(lp, 3);
s12: glp_set_col_name(lp, 1, "x1");
s13: glp_set_col_bnds(lp, 1, GLP_LO, 0.0, 0.0);
s14: glp_set_obj_coef(lp, 1, 10.0);
s15: glp_set_col_name(lp, 2, "x2");
s16: glp_set_col_bnds(lp, 2, GLP_LO, 0.0, 0.0);
s17: glp_set_obj_coef(lp, 2, 6.0);
s18: glp_set_col_name(lp, 3, "x3");
s19: glp_set_col_bnds(lp, 3, GLP_LO, 0.0, 0.0);
s20: glp_set_obj_coef(lp, 3, 4.0);
s21: ia[1] = 1, ja[1] = 1, ar[1] = 1.0; /* a[1,1] = 1 */
s22: ia[2] = 1, ja[2] = 2, ar[2] = 1.0; /* a[1,2] = 1 */
s23: ia[3] = 1, ja[3] = 3, ar[3] = 1.0; /* a[1,3] = 1 */
s24: ia[4] = 2, ja[4] = 1, ar[4] = 10.0; /* a[2,1] = 10 */
s25: ia[5] = 3, ja[5] = 1, ar[5] = 2.0; /* a[3,1] = 2 */
s26: ia[6] = 2, ja[6] = 2, ar[6] = 4.0; /* a[2,2] = 4 */
s27: ia[7] = 3, ja[7] = 2, ar[7] = 2.0; /* a[3,2] = 2 */
s28: ia[8] = 2, ja[8] = 3, ar[8] = 5.0; /* a[2,3] = 5 */
s29: ia[9] = 3, ja[9] = 3, ar[9] = 6.0; /* a[3,3] = 6 */
s30: glp_load_matrix(lp, 9, ia, ja, ar);
s31: glp_simplex(lp, NULL);
s32: z = glp_get_obj_val(lp);
s33: x1 = glp_get_col_prim(lp, 1);
s34: x2 = glp_get_col_prim(lp, 2);
s35: x3 = glp_get_col_prim(lp, 3);
s36: printf("\nz = %g; x1 = %g; x2 = %g; x3 = %g\n", z, x1, x2, x3);
s37: glp_delete_prob(lp);
return 0;
}
/**
* Build a model with one column
* @param forceError force error if bit 0 = 1
*/
void buildModel(int forceError) {
glp_prob *lp;
/* create problem */
lp = glp_create_prob();
if (forceError & 1) {
/* add -1 column
* this will cause an error.
*/
glp_add_cols(lp, -1);
} else {
/* add 1 column */
glp_add_cols(lp, 1);
}
/* delete problem */
glp_delete_prob(lp);
}
void freeMem(){
/** GLPK: free structures **/
if (tran) glp_mpl_free_wksp(tran);
if (mip) glp_delete_prob(mip);
if (retGRB) printf("ERROR: %s\n", GRBgeterrormsg(env));
/** GUROBI: free structures **/
if (model) GRBfreemodel(model);
if (env) GRBfreeenv(env);
printf("ERRORS OCCURRED.\nGLPK -> GUROBI -> GLPK wrapper v0.1 (2010)\n");
exit(1);
}
int main(int argc, char *argv[]) {
/* Structures de données propres à GLPK */
glp_prob *prob; // Déclaration d'un pointeur sur le problème
int ia[1 + NBCREUX];
int ja[1 + NBCREUX];
double ar[1 + NBCREUX]; // Déclaration des 3 tableaux servant à définir la partie creuse de la matrice des contraintes
/* Variables récupérant les résultats de la résolution du problème (fonction objectif et valeur des variables) */
int i, j;
double z;
double x[NBVAR];
// Autres variables
int * p = (int*)malloc(n * sizeof(int));
p[1] = 34;
p[2] = 6;
p[3] = 8;
p[4] = 17;
p[5] = 16;
p[6] = 5;
p[7] = 13;
p[8] = 21;
p[9] = 25;
p[10] = 31;
p[11] = 14;
p[12] = 13;
p[13] = 33;
p[14] = 9;
p[15] = 25;
p[16] = 25;
/* Transfert de ces données dans les structures utilisées par la bibliothèque GLPK */
prob = glp_create_prob(); /* allocation mémoire pour le problème */
glp_set_prob_name(prob, "wagons"); /* affectation d'un nom */
glp_set_obj_dir(prob, GLP_MIN); /* Il s'agit d'un problème de minimisation */
/* Déclaration du nombre de contraintes (nombre de lignes de la matrice des contraintes) */
glp_add_rows(prob, NBCONTR);
/* On commence par préciser les bornes sur les contraintes, les indices commencent à 1 (!) dans GLPK */
/* Premier ensemble de contraintes ( c = 1 ) */
for(i = 1; i <= n; i++) {
glp_set_row_bnds(prob, i, GLP_FX, 1.0, 1.0);
}
/* Second ensembles de contraintes (c <= 0 ) */
for(i = n + 1; i <= NBCONTR; i++) {
glp_set_row_bnds(prob, i, GLP_UP, 0.0, 0.0);
}
/* Déclaration du nombre de variables */
glp_add_cols(prob, NBVAR);
/* On précise le type des variables, les indices commencent à 1 également pour les variables! */
for(i = 1; i <= NBVAR - 1; i++) {
glp_set_col_bnds(prob, i, GLP_DB, 0.0, 1.0);
glp_set_col_kind(prob, i, GLP_BV); /* les variables sont binaires */
}
glp_set_col_bnds(prob, NBVAR, GLP_LO, 0.0, 0.0); /* La dernière variables est continue (par défaut) non négative */
/* Définition des coefficients des variables dans la fonction objectif */
for(i = 1;i <= n*m;i++) {
glp_set_obj_coef(prob,i,0.0); // Tous les coûts sont à 0 (sauf le dernier)
}
/* Dernier coût (qui vaut 1) */
glp_set_obj_coef(prob,n*m + 1,1.0);
/* Définition des coefficients non-nuls dans la matrice des contraintes, autrement dit les coefficients de la matrice creuse */
int pos = 1;
for(i = 1; i <= n; i++) {
for(j = 1; j <= m; j++) {
// Première moitié de la matrice
ja[pos] = (i - 1)*m + j;
ia[pos] = i;
ar[pos] = 1;
pos++;
// Deuxième moitié de la matrice
ja[pos] = (i - 1)*m + j;
ia[pos] = n + j;
ar[pos] = p[i];
pos++;
}
}
// ajout des -1 dans la dernière colonne
for(i = n + 1; i <= n + m; i++) {
ja[pos] = n*m + 1;
ia[pos] = i;
ar[pos] = -1;
pos++;
}
/* Chargement de la matrice dans le problème */
glp_load_matrix(prob,NBCREUX,ia,ja,ar);
/* Ecriture de la modélisation dans un fichier */
glp_write_lp(prob,NULL,"wagons.lp");
/* Résolution, puis lecture des résultats */
glp_simplex(prob,NULL); glp_intopt(prob,NULL); /* Résolution */
z = glp_mip_obj_val(prob); /* Récupération de la valeur optimale. Dans le cas d'un problème en variables continues, l'appel est différent : z = glp_get_obj_val(prob); */
for(i = 0;i < NBVAR; i++) x[i] = glp_mip_col_val(prob,i+1); /* Récupération de la valeur des variables, Appel différent dans le cas d'un problème en variables continues : for(i = 0;i < p.nbvar;i++) x[i] = glp_get_col_prim(prob,i+1); */
printf("z = %lf\n",z);
for(i = 0;i < NBVAR;i++) printf("x%c = %d, ",'B'+i,(int)(x[i] + 0.5)); /* un cast est ajouté, x[i] pourrait être égal à 0.99999... */
puts("");
/* Libération de la mémoire */
glp_delete_prob(prob);
free(p);
return 0;
}
int main(int argc, char *argv[])
{
/* structures de données propres à GLPK */
glp_prob *prob; // déclaration d'un pointeur sur le problème
int ia[1 + NBCREUX];
int ja[1 + NBCREUX];
double ar[1 + NBCREUX]; // déclaration des 3 tableaux servant à définir la partie creuse de la matrice des contraintes
int p[N+1];
p[1] = 34;
p[2] = 6; p[3] = 8; p[4] = 17; p[5] = 16; p[6] = 5; p[7] = 13; p[8] = 21; p[9] = 25; p[10] = 31; p[11] = 14; p[12] = 13; p[13] = 33; p[14] = 9; p[15] = 25; p[16] = 25;
/* variables récupérant les résultats de la résolution du problème (fonction objectif et valeur des variables) */
int i,j,pos;
double z;
double x[NBVAR];
/* Les déclarations suivantes sont optionnelles, leur but est de donner des noms aux variables et aux contraintes.
Cela permet de lire plus facilement le modèle saisi si on en demande un affichage à GLPK, ce qui est souvent utile pour détecter une erreur! */
char nomcontr[NBCONTR][8]; /* ici, les contraintes seront nommées "caisse1", "caisse2",... */
char numero[NBCONTR][3]; /* pour un nombre à deux chiffres */
char nomvar[NBVAR][3]; /* "xA", "xB", ... */
/* Création d'un problème (initialement vide) */
prob = glp_create_prob(); /* allocation mémoire pour le problème */
glp_set_prob_name(prob, "wagons"); /* affectation d'un nom (on pourrait mettre NULL) */
glp_set_obj_dir(prob, GLP_MIN); /* Il s'agit d'un problème de minimisation, on utiliserait la constante GLP_MAX dans le cas contraire */
/* Déclaration du nombre de contraintes (nombre de lignes de la matrice des contraintes) : NBCONTR */
glp_add_rows(prob, NBCONTR);
/* On commence par préciser les bornes sur les constrainte, les indices des contraintes commencent à 1 (!) dans GLPK */
for(i = 1;i <= N;i++)
{
/* partie optionnelle : donner un nom aux contraintes */
strcpy(nomcontr[i-1], "caisse");
sprintf(numero[i-1], "%d", i);
strcat(nomcontr[i-1], numero[i-1]); /* Les contraintes sont nommés "salle1", "salle2"... */
glp_set_row_name(prob, i, nomcontr[i-1]); /* Affectation du nom à la contrainte i */
/* partie indispensable : les bornes sur les contraintes */
glp_set_row_bnds(prob, i, GLP_FX, 1.0, 1.0);
}
for(i = N+1;i <= NBCONTR;i++)
{
/* partie optionnelle : donner un nom aux contraintes */
strcpy(nomcontr[i-1], "chaMax");
sprintf(numero[i-1], "%d", i);
strcat(nomcontr[i-1], numero[i-1]); /* Les contraintes sont nommés "chargemax", "chargemax2"... */
glp_set_row_name(prob, i, nomcontr[i-1]); /* Affectation du nom à la contrainte i */
// il doit manquer un bout ici
glp_set_row_bnds(prob, i, GLP_UP, 0.0, 0.0);
//<=0
// on met cmax a gauche car c'est une variable
// il aura le coeff -1 dans la mat creuse
}
/* Déclaration du nombre de variables : NBVAR */
glp_add_cols(prob, NBVAR);
/* On précise le type des variables, les indices commencent à 1 également pour les variables! */
for(i = 1;i <= NBVAR;i++)
{
if(i==NBVAR){
sprintf(nomvar[i-1],"Cm");
glp_set_col_name(prob, i , nomvar[i-1]);
glp_set_col_bnds(prob, i, GLP_LO, 0.0, 0.0);
}else{
/* partie optionnelle : donner un nom aux variables */
sprintf(nomvar[i-1],"x%d",i-1);
glp_set_col_name(prob, i , nomvar[i-1]); /* Les variables sont nommées "xA", "xB"... afin de respecter les noms de variables de l'exercice 2.2 */
/* partie obligatoire : bornes éventuelles sur les variables, et type */
glp_set_col_bnds(prob, i, GLP_DB, 0.0, 1.0); /* bornes sur les variables, comme sur les contraintes */
glp_set_col_kind(prob, i, GLP_BV); /* les variables sont par défaut continues, nous précisons ici qu'elles sont binaires avec la constante GLP_BV, on utiliserait GLP_IV pour des variables entières */
}
}
/* définition des coefficients des variables dans la fonction objectif */
for(i = 1;i <= N*M;i++) glp_set_obj_coef(prob,i,0.0); // Tous les coûts sont ici à 0! Mais on doit specifier quand meme
glp_set_obj_coef(prob,N*M+1,1.0); // 1 fois cmax
/* Définition des coefficients non-nuls dans la matrice des contraintes, autrement dit les coefficients de la matrice creuse */
/* Les indices commencent également à 1 ! */
// pour i de 1 a n
//pour i de 1 a m
/* xij intervient dans la ligne i avec un coeff 1 et dans la ligne
n+j avec un coeff pi
ia -> i et n+j
ar -> 1 et pi
ja -> xij -> (i-1)*m+j
*/
pos = 1;
for(i=1; i<=N; i++){
for(j=1; j<=M; j++){
ia[pos] = i;
ja[pos] = (i-1)*M+j; ar[pos] = 1;
pos++;
ia[pos] = N+j;
ja[pos] = (i-1)*M+j; ar[pos] = p[i];
pos++;
}
}
//Cmax a -1 !!!
for(i=N+1; i<=N+M;i++){
ia[pos] = i;
ja[pos] = N*M+1; ar[pos] = -1;
pos++;
}
/* chargement de la matrice dans le problème */
glp_load_matrix(prob,NBCREUX,ia,ja,ar);
/* Optionnel : écriture de la modélisation dans un fichier (TRES utile pour debugger!) */
glp_write_lp(prob,NULL,"wagons.lp");
/* Résolution, puis lecture des résultats */
glp_simplex(prob,NULL); glp_intopt(prob,NULL); /* Résolution */
z = glp_mip_obj_val(prob); /* Récupération de la valeur optimale. Dans le cas d'un problème en variables continues, l'appel est différent : z = glp_get_obj_val(prob); */
for(i = 0;i < NBVAR; i++) x[i] = glp_mip_col_val(prob,i+1); /* Récupération de la valeur des variables, Appel différent dans le cas d'un problème en variables continues : for(i = 0;i < p.nbvar;i++) x[i] = glp_get_col_prim(prob,i+1); */
printf("z = %lf\n",z);
for(i = 0;i < NBVAR;i++) printf("x%d = %d, ",i,(int)(x[i] + 0.5)); /* un cast est ajouté, x[i] pourrait être égal à 0.99999... */
puts("");
/* libération mémoire */
glp_delete_prob(prob);
/* J'adore qu'un plan se déroule sans accroc! */
return 0;
}
int glp_intfeas1(glp_prob *P, int use_bound, int obj_bound)
{ /* solve integer feasibility problem */
NPP *npp = NULL;
glp_prob *mip = NULL;
int *obj_ind = NULL;
double *obj_val = NULL;
int obj_row = 0;
int i, j, k, obj_len, temp, ret;
/* check the problem object */
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_intfeas1: P = %p; invalid problem object\n",
P);
if (P->tree != NULL)
xerror("glp_intfeas1: operation not allowed\n");
/* integer solution is currently undefined */
P->mip_stat = GLP_UNDEF;
P->mip_obj = 0.0;
/* check columns (variables) */
for (j = 1; j <= P->n; j++)
{ GLPCOL *col = P->col[j];
#if 0 /* currently binarization is not yet implemented */
if (!(col->kind == GLP_IV || col->type == GLP_FX))
{ xprintf("glp_intfeas1: column %d: non-integer non-fixed var"
"iable not allowed\n", j);
#else
if (!((col->kind == GLP_IV && col->lb == 0.0 && col->ub == 1.0)
|| col->type == GLP_FX))
{ xprintf("glp_intfeas1: column %d: non-binary non-fixed vari"
"able not allowed\n", j);
#endif
ret = GLP_EDATA;
goto done;
}
temp = (int)col->lb;
if ((double)temp != col->lb)
{ if (col->type == GLP_FX)
xprintf("glp_intfeas1: column %d: fixed value %g is non-"
"integer or out of range\n", j, col->lb);
else
xprintf("glp_intfeas1: column %d: lower bound %g is non-"
"integer or out of range\n", j, col->lb);
ret = GLP_EDATA;
goto done;
}
temp = (int)col->ub;
if ((double)temp != col->ub)
{ xprintf("glp_intfeas1: column %d: upper bound %g is non-int"
"eger or out of range\n", j, col->ub);
ret = GLP_EDATA;
goto done;
}
if (col->type == GLP_DB && col->lb > col->ub)
{ xprintf("glp_intfeas1: column %d: lower bound %g is greater"
" than upper bound %g\n", j, col->lb, col->ub);
ret = GLP_EBOUND;
goto done;
}
}
/* check rows (constraints) */
for (i = 1; i <= P->m; i++)
{ GLPROW *row = P->row[i];
GLPAIJ *aij;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
{ temp = (int)aij->val;
if ((double)temp != aij->val)
{ xprintf("glp_intfeas1: row = %d, column %d: constraint c"
"oefficient %g is non-integer or out of range\n",
i, aij->col->j, aij->val);
ret = GLP_EDATA;
goto done;
}
}
temp = (int)row->lb;
if ((double)temp != row->lb)
{ if (row->type == GLP_FX)
xprintf("glp_intfeas1: row = %d: fixed value %g is non-i"
"nteger or out of range\n", i, row->lb);
else
xprintf("glp_intfeas1: row = %d: lower bound %g is non-i"
"nteger or out of range\n", i, row->lb);
ret = GLP_EDATA;
goto done;
}
temp = (int)row->ub;
if ((double)temp != row->ub)
{ xprintf("glp_intfeas1: row = %d: upper bound %g is non-inte"
"ger or out of range\n", i, row->ub);
ret = GLP_EDATA;
goto done;
}
if (row->type == GLP_DB && row->lb > row->ub)
{ xprintf("glp_intfeas1: row %d: lower bound %g is greater th"
"an upper bound %g\n", i, row->lb, row->ub);
ret = GLP_EBOUND;
goto done;
}
}
/* check the objective function */
temp = (int)P->c0;
if ((double)temp != P->c0)
{ xprintf("glp_intfeas1: objective constant term %g is non-integ"
"er or out of range\n", P->c0);
ret = GLP_EDATA;
goto done;
}
for (j = 1; j <= P->n; j++)
{ temp = (int)P->col[j]->coef;
if ((double)temp != P->col[j]->coef)
{ xprintf("glp_intfeas1: column %d: objective coefficient is "
"non-integer or out of range\n", j, P->col[j]->coef);
ret = GLP_EDATA;
goto done;
}
}
/* save the objective function and set it to zero */
obj_ind = xcalloc(1+P->n, sizeof(int));
obj_val = xcalloc(1+P->n, sizeof(double));
obj_len = 0;
obj_ind[0] = 0;
obj_val[0] = P->c0;
P->c0 = 0.0;
for (j = 1; j <= P->n; j++)
{ if (P->col[j]->coef != 0.0)
{ obj_len++;
obj_ind[obj_len] = j;
obj_val[obj_len] = P->col[j]->coef;
P->col[j]->coef = 0.0;
}
}
/* add inequality to bound the objective function, if required */
if (!use_bound)
xprintf("Will search for ANY feasible solution\n");
else
{ xprintf("Will search only for solution not worse than %d\n",
obj_bound);
obj_row = glp_add_rows(P, 1);
glp_set_mat_row(P, obj_row, obj_len, obj_ind, obj_val);
if (P->dir == GLP_MIN)
glp_set_row_bnds(P, obj_row,
GLP_UP, 0.0, (double)obj_bound - obj_val[0]);
else if (P->dir == GLP_MAX)
glp_set_row_bnds(P, obj_row,
GLP_LO, (double)obj_bound - obj_val[0], 0.0);
else
xassert(P != P);
}
/* create preprocessor workspace */
xprintf("Translating to CNF-SAT...\n");
xprintf("Original problem has %d row%s, %d column%s, and %d non-z"
"ero%s\n", P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" :
"s", P->nnz, P->nnz == 1 ? "" : "s");
npp = npp_create_wksp();
/* load the original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_MIP, GLP_OFF);
/* perform translation to SAT-CNF problem instance */
ret = npp_sat_encode_prob(npp);
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
xprintf("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION\n");
else if (ret == GLP_ERANGE)
xprintf("glp_intfeas1: translation to SAT-CNF failed because o"
"f integer overflow\n");
else
xassert(ret != ret);
if (ret != 0)
goto done;
/* build SAT-CNF problem instance and try to solve it */
mip = glp_create_prob();
npp_build_prob(npp, mip);
ret = glp_minisat1(mip);
/* only integer feasible solution can be postprocessed */
if (!(mip->mip_stat == GLP_OPT || mip->mip_stat == GLP_FEAS))
{ P->mip_stat = mip->mip_stat;
goto done;
}
/* postprocess the solution found */
npp_postprocess(npp, mip);
/* the transformed problem is no longer needed */
glp_delete_prob(mip), mip = NULL;
/* store solution to the original problem object */
npp_unload_sol(npp, P);
/* change the solution status to 'integer feasible' */
P->mip_stat = GLP_FEAS;
/* check integer feasibility */
for (i = 1; i <= P->m; i++)
{ GLPROW *row;
GLPAIJ *aij;
double sum;
row = P->row[i];
sum = 0.0;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
sum += aij->val * aij->col->mipx;
xassert(sum == row->mipx);
if (row->type == GLP_LO || row->type == GLP_DB ||
row->type == GLP_FX)
xassert(sum >= row->lb);
if (row->type == GLP_UP || row->type == GLP_DB ||
row->type == GLP_FX)
xassert(sum <= row->ub);
}
/* compute value of the original objective function */
P->mip_obj = obj_val[0];
for (k = 1; k <= obj_len; k++)
P->mip_obj += obj_val[k] * P->col[obj_ind[k]]->mipx;
xprintf("Objective value = %17.9e\n", P->mip_obj);
done: /* delete the transformed problem, if it exists */
if (mip != NULL)
glp_delete_prob(mip);
/* delete the preprocessor workspace, if it exists */
if (npp != NULL)
npp_delete_wksp(npp);
/* remove inequality used to bound the objective function */
if (obj_row > 0)
{ int ind[1+1];
ind[1] = obj_row;
glp_del_rows(P, 1, ind);
}
/* restore the original objective function */
if (obj_ind != NULL)
{ P->c0 = obj_val[0];
for (k = 1; k <= obj_len; k++)
P->col[obj_ind[k]]->coef = obj_val[k];
xfree(obj_ind);
xfree(obj_val);
}
return ret;
}
static void
solve(char* file_name) {
ppl_Constraint_System_t ppl_cs;
#ifndef NDEBUG
ppl_Constraint_System_t ppl_cs_copy;
#endif
ppl_Generator_t optimum_location;
ppl_Linear_Expression_t ppl_le;
int dimension, row, num_rows, column, nz, i, j, type;
int* coefficient_index;
double lb, ub;
double* coefficient_value;
mpq_t rational_lb, rational_ub;
mpq_t* rational_coefficient;
mpq_t* objective;
ppl_Linear_Expression_t ppl_objective_le;
ppl_Coefficient_t optimum_n;
ppl_Coefficient_t optimum_d;
mpq_t optimum;
mpz_t den_lcm;
int optimum_found;
glp_mpscp glpk_mpscp;
glpk_lp = glp_create_prob();
glp_init_mpscp(&glpk_mpscp);
if (verbosity == 0) {
/* FIXME: find a way to suppress output from glp_read_mps. */
}
#ifdef PPL_LPSOL_SUPPORTS_TIMINGS
if (print_timings)
start_clock();
#endif /* defined(PPL_LPSOL_SUPPORTS_TIMINGS) */
if (glp_read_mps(glpk_lp, GLP_MPS_FILE, &glpk_mpscp, file_name) != 0)
fatal("cannot read MPS file `%s'", file_name);
#ifdef PPL_LPSOL_SUPPORTS_TIMINGS
if (print_timings) {
fprintf(stderr, "Time to read the input file: ");
print_clock(stderr);
fprintf(stderr, " s\n");
start_clock();
}
#endif /* defined(PPL_LPSOL_SUPPORTS_TIMINGS) */
glpk_lp_num_int = glp_get_num_int(glpk_lp);
if (glpk_lp_num_int > 0 && !no_mip && !use_simplex)
fatal("the enumeration solving method can not handle MIP problems");
dimension = glp_get_num_cols(glpk_lp);
/* Read variables constrained to be integer. */
if (glpk_lp_num_int > 0 && !no_mip && use_simplex) {
if (verbosity >= 4)
fprintf(output_file, "Integer variables:\n");
integer_variables = (ppl_dimension_type*)
malloc((glpk_lp_num_int + 1)*sizeof(ppl_dimension_type));
for (i = 0, j = 0; i < dimension; ++i) {
int col_kind = glp_get_col_kind(glpk_lp, i+1);
if (col_kind == GLP_IV || col_kind == GLP_BV) {
integer_variables[j] = i;
if (verbosity >= 4) {
ppl_io_fprint_variable(output_file, i);
fprintf(output_file, " ");
}
++j;
}
}
}
coefficient_index = (int*) malloc((dimension+1)*sizeof(int));
coefficient_value = (double*) malloc((dimension+1)*sizeof(double));
rational_coefficient = (mpq_t*) malloc((dimension+1)*sizeof(mpq_t));
ppl_new_Constraint_System(&ppl_cs);
mpq_init(rational_lb);
mpq_init(rational_ub);
for (i = 1; i <= dimension; ++i)
mpq_init(rational_coefficient[i]);
mpz_init(den_lcm);
if (verbosity >= 4)
fprintf(output_file, "\nConstraints:\n");
/* Set up the row (ordinary) constraints. */
num_rows = glp_get_num_rows(glpk_lp);
for (row = 1; row <= num_rows; ++row) {
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
/* Set `nz' to the number of non-zero coefficients. */
nz = glp_get_mat_row(glpk_lp, row, coefficient_index, coefficient_value);
for (i = 1; i <= nz; ++i) {
set_mpq_t_from_double(rational_coefficient[i], coefficient_value[i]);
/* Update den_lcm. */
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_coefficient[i]));
}
lb = glp_get_row_lb(glpk_lp, row);
ub = glp_get_row_ub(glpk_lp, row);
set_mpq_t_from_double(rational_lb, lb);
set_mpq_t_from_double(rational_ub, ub);
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_lb));
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_ub));
ppl_new_Linear_Expression_with_dimension(&ppl_le, dimension);
for (i = 1; i <= nz; ++i) {
mpz_mul(tmp_z, den_lcm, mpq_numref(rational_coefficient[i]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(rational_coefficient[i]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_coefficient(ppl_le, coefficient_index[i]-1,
ppl_coeff);
}
type = glp_get_row_type(glpk_lp, row);
add_constraints(ppl_le, type, rational_lb, rational_ub, den_lcm, ppl_cs);
ppl_delete_Linear_Expression(ppl_le);
}
free(coefficient_value);
for (i = 1; i <= dimension; ++i)
mpq_clear(rational_coefficient[i]);
free(rational_coefficient);
free(coefficient_index);
#ifndef NDEBUG
ppl_new_Constraint_System_from_Constraint_System(&ppl_cs_copy, ppl_cs);
#endif
/*
FIXME: here we could build the polyhedron and minimize it before
adding the variable bounds.
*/
/* Set up the columns constraints, i.e., variable bounds. */
for (column = 1; column <= dimension; ++column) {
lb = glp_get_col_lb(glpk_lp, column);
ub = glp_get_col_ub(glpk_lp, column);
set_mpq_t_from_double(rational_lb, lb);
set_mpq_t_from_double(rational_ub, ub);
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_lb));
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_ub));
ppl_new_Linear_Expression_with_dimension(&ppl_le, dimension);
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, den_lcm);
ppl_Linear_Expression_add_to_coefficient(ppl_le, column-1, ppl_coeff);
type = glp_get_col_type(glpk_lp, column);
add_constraints(ppl_le, type, rational_lb, rational_ub, den_lcm, ppl_cs);
ppl_delete_Linear_Expression(ppl_le);
}
mpq_clear(rational_ub);
mpq_clear(rational_lb);
/* Deal with the objective function. */
objective = (mpq_t*) malloc((dimension+1)*sizeof(mpq_t));
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
mpq_init(objective[0]);
set_mpq_t_from_double(objective[0], glp_get_obj_coef(glpk_lp, 0));
for (i = 1; i <= dimension; ++i) {
mpq_init(objective[i]);
set_mpq_t_from_double(objective[i], glp_get_obj_coef(glpk_lp, i));
/* Update den_lcm. */
mpz_lcm(den_lcm, den_lcm, mpq_denref(objective[i]));
}
/* Set the ppl_objective_le to be the objective function. */
ppl_new_Linear_Expression_with_dimension(&ppl_objective_le, dimension);
/* Set value for objective function's inhomogeneous term. */
mpz_mul(tmp_z, den_lcm, mpq_numref(objective[0]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(objective[0]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_inhomogeneous(ppl_objective_le, ppl_coeff);
/* Set values for objective function's variable coefficients. */
for (i = 1; i <= dimension; ++i) {
mpz_mul(tmp_z, den_lcm, mpq_numref(objective[i]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(objective[i]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_coefficient(ppl_objective_le, i-1, ppl_coeff);
}
if (verbosity >= 4) {
fprintf(output_file, "Objective function:\n");
if (mpz_cmp_si(den_lcm, 1) != 0)
fprintf(output_file, "(");
ppl_io_fprint_Linear_Expression(output_file, ppl_objective_le);
}
for (i = 0; i <= dimension; ++i)
mpq_clear(objective[i]);
free(objective);
if (verbosity >= 4) {
if (mpz_cmp_si(den_lcm, 1) != 0) {
fprintf(output_file, ")/");
mpz_out_str(output_file, 10, den_lcm);
}
fprintf(output_file, "\n%s\n",
(maximize ? "Maximizing." : "Minimizing."));
}
ppl_new_Coefficient(&optimum_n);
ppl_new_Coefficient(&optimum_d);
ppl_new_Generator_zero_dim_point(&optimum_location);
optimum_found = use_simplex
? solve_with_simplex(ppl_cs,
ppl_objective_le,
optimum_n,
optimum_d,
optimum_location)
: solve_with_generators(ppl_cs,
ppl_objective_le,
optimum_n,
optimum_d,
optimum_location);
ppl_delete_Linear_Expression(ppl_objective_le);
if (glpk_lp_num_int > 0)
free(integer_variables);
if (optimum_found) {
mpq_init(optimum);
ppl_Coefficient_to_mpz_t(optimum_n, tmp_z);
mpq_set_num(optimum, tmp_z);
ppl_Coefficient_to_mpz_t(optimum_d, tmp_z);
mpz_mul(tmp_z, tmp_z, den_lcm);
mpq_set_den(optimum, tmp_z);
if (verbosity == 1)
fprintf(output_file, "Optimized problem.\n");
if (verbosity >= 2)
fprintf(output_file, "Optimum value: %.10g\n", mpq_get_d(optimum));
if (verbosity >= 3) {
fprintf(output_file, "Optimum location:\n");
ppl_Generator_divisor(optimum_location, ppl_coeff);
ppl_Coefficient_to_mpz_t(ppl_coeff, tmp_z);
for (i = 0; i < dimension; ++i) {
mpz_set(mpq_denref(tmp1_q), tmp_z);
ppl_Generator_coefficient(optimum_location, i, ppl_coeff);
ppl_Coefficient_to_mpz_t(ppl_coeff, mpq_numref(tmp1_q));
ppl_io_fprint_variable(output_file, i);
fprintf(output_file, " = %.10g\n", mpq_get_d(tmp1_q));
}
}
#ifndef NDEBUG
{
ppl_Polyhedron_t ph;
unsigned int relation;
ppl_new_C_Polyhedron_recycle_Constraint_System(&ph, ppl_cs_copy);
ppl_delete_Constraint_System(ppl_cs_copy);
relation = ppl_Polyhedron_relation_with_Generator(ph, optimum_location);
ppl_delete_Polyhedron(ph);
assert(relation == PPL_POLY_GEN_RELATION_SUBSUMES);
}
#endif
maybe_check_results(PPL_MIP_PROBLEM_STATUS_OPTIMIZED,
mpq_get_d(optimum));
mpq_clear(optimum);
}
ppl_delete_Constraint_System(ppl_cs);
ppl_delete_Coefficient(optimum_d);
ppl_delete_Coefficient(optimum_n);
ppl_delete_Generator(optimum_location);
glp_delete_prob(glpk_lp);
}
static double eval_degrad(glp_prob *P, int j, double bnd)
{ /* compute degradation of the objective on fixing x[j] at given
value with a limited number of dual simplex iterations */
/* this routine fixes column x[j] at specified value bnd,
solves resulting LP, and returns a lower bound to degradation
of the objective, degrad >= 0 */
glp_prob *lp;
glp_smcp parm;
int ret;
double degrad;
/* the current basis must be optimal */
xassert(glp_get_status(P) == GLP_OPT);
/* create a copy of P */
lp = glp_create_prob();
glp_copy_prob(lp, P, 0);
/* fix column x[j] at specified value */
glp_set_col_bnds(lp, j, GLP_FX, bnd, bnd);
/* try to solve resulting LP */
glp_init_smcp(&parm);
parm.msg_lev = GLP_MSG_OFF;
parm.meth = GLP_DUAL;
parm.it_lim = 30;
parm.out_dly = 1000;
parm.meth = GLP_DUAL;
ret = glp_simplex(lp, &parm);
if (ret == 0 || ret == GLP_EITLIM)
{ if (glp_get_prim_stat(lp) == GLP_NOFEAS)
{ /* resulting LP has no primal feasible solution */
degrad = DBL_MAX;
}
else if (glp_get_dual_stat(lp) == GLP_FEAS)
{ /* resulting basis is optimal or at least dual feasible,
so we have the correct lower bound to degradation */
if (P->dir == GLP_MIN)
degrad = lp->obj_val - P->obj_val;
else if (P->dir == GLP_MAX)
degrad = P->obj_val - lp->obj_val;
else
xassert(P != P);
/* degradation cannot be negative by definition */
/* note that the lower bound to degradation may be close
to zero even if its exact value is zero due to round-off
errors on computing the objective value */
if (degrad < 1e-6 * (1.0 + 0.001 * fabs(P->obj_val)))
degrad = 0.0;
}
else
{ /* the final basis reported by the simplex solver is dual
infeasible, so we cannot determine a non-trivial lower
bound to degradation */
degrad = 0.0;
}
}
else
{ /* the simplex solver failed */
degrad = 0.0;
}
/* delete the copy of P */
glp_delete_prob(lp);
return degrad;
}
/* clean up all results */
static void release_glp(void){
if(P){ glp_delete_prob(P); P=NULL; }
}
static int preprocess_and_solve_mip(glp_prob *P, const glp_iocp *parm)
{ /* solve MIP using the preprocessor */
ENV *env = get_env_ptr();
int term_out = env->term_out;
NPP *npp;
glp_prob *mip = NULL;
glp_bfcp bfcp;
glp_smcp smcp;
int ret;
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Preprocessing...\n");
/* create preprocessor workspace */
npp = npp_create_wksp();
/* load original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_MIP, GLP_OFF);
/* process MIP prior to applying the branch-and-bound method */
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
ret = npp_integer(npp, parm);
env->term_out = term_out;
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
}
else if (ret == GLP_ENODFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("LP RELAXATION HAS NO DUAL FEASIBLE SOLUTION\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
/* build transformed MIP */
mip = glp_create_prob();
npp_build_prob(npp, mip);
/* if the transformed MIP is empty, it has empty solution, which
is optimal */
if (mip->m == 0 && mip->n == 0)
{ mip->mip_stat = GLP_OPT;
mip->mip_obj = mip->c0;
if (parm->msg_lev >= GLP_MSG_ALL)
{ xprintf("Objective value = %17.9e\n", mip->mip_obj);
xprintf("INTEGER OPTIMAL SOLUTION FOUND BY MIP PREPROCESSOR"
"\n");
}
goto post;
}
/* display some statistics */
if (parm->msg_lev >= GLP_MSG_ALL)
{ int ni = glp_get_num_int(mip);
int nb = glp_get_num_bin(mip);
char s[50];
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
mip->m, mip->m == 1 ? "" : "s", mip->n, mip->n == 1 ? "" :
"s", mip->nnz, mip->nnz == 1 ? "" : "s");
if (nb == 0)
strcpy(s, "none of");
else if (ni == 1 && nb == 1)
strcpy(s, "");
else if (nb == 1)
strcpy(s, "one of");
else if (nb == ni)
strcpy(s, "all of");
else
sprintf(s, "%d of", nb);
xprintf("%d integer variable%s, %s which %s binary\n",
ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
/* inherit basis factorization control parameters */
glp_get_bfcp(P, &bfcp);
glp_set_bfcp(mip, &bfcp);
/* scale the transformed problem */
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_scale_prob(mip,
GLP_SF_GM | GLP_SF_EQ | GLP_SF_2N | GLP_SF_SKIP);
env->term_out = term_out;
/* build advanced initial basis */
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_adv_basis(mip, 0);
env->term_out = term_out;
/* solve initial LP relaxation */
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Solving LP relaxation...\n");
glp_init_smcp(&smcp);
smcp.msg_lev = parm->msg_lev;
mip->it_cnt = P->it_cnt;
ret = glp_simplex(mip, &smcp);
P->it_cnt = mip->it_cnt;
if (ret != 0)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: cannot solve LP relaxation\n");
ret = GLP_EFAIL;
goto done;
}
/* check status of the basic solution */
ret = glp_get_status(mip);
if (ret == GLP_OPT)
ret = 0;
else if (ret == GLP_NOFEAS)
ret = GLP_ENOPFS;
else if (ret == GLP_UNBND)
ret = GLP_ENODFS;
else
xassert(ret != ret);
if (ret != 0) goto done;
/* solve the transformed MIP */
mip->it_cnt = P->it_cnt;
#if 0 /* 11/VII-2013 */
ret = solve_mip(mip, parm);
#else
if (parm->use_sol)
{ mip->mip_stat = P->mip_stat;
mip->mip_obj = P->mip_obj;
}
ret = solve_mip(mip, parm, P, npp);
#endif
P->it_cnt = mip->it_cnt;
/* only integer feasible solution can be postprocessed */
if (!(mip->mip_stat == GLP_OPT || mip->mip_stat == GLP_FEAS))
{ P->mip_stat = mip->mip_stat;
goto done;
}
/* postprocess solution from the transformed MIP */
post: npp_postprocess(npp, mip);
/* the transformed MIP is no longer needed */
glp_delete_prob(mip), mip = NULL;
/* store solution to the original problem */
npp_unload_sol(npp, P);
done: /* delete the transformed MIP, if it exists */
if (mip != NULL) glp_delete_prob(mip);
/* delete preprocessor workspace */
npp_delete_wksp(npp);
return ret;
}
void lpx_delete_prob(LPX *lp)
{ /* delete problem object */
glp_delete_prob(lp);
return;
}
static int preprocess_and_solve_lp(glp_prob *P, const glp_smcp *parm)
{ /* solve LP using the preprocessor */
NPP *npp;
glp_prob *lp = NULL;
glp_bfcp bfcp;
int ret;
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Preprocessing...\n");
/* create preprocessor workspace */
npp = npp_create_wksp();
/* load original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_SOL, GLP_OFF);
/* process LP prior to applying primal/dual simplex method */
ret = npp_simplex(npp, parm);
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
}
else if (ret == GLP_ENODFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO DUAL FEASIBLE SOLUTION\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
/* build transformed LP */
lp = glp_create_prob();
npp_build_prob(npp, lp);
/* if the transformed LP is empty, it has empty solution, which
is optimal */
if (lp->m == 0 && lp->n == 0)
{ lp->pbs_stat = lp->dbs_stat = GLP_FEAS;
lp->obj_val = lp->c0;
if (parm->msg_lev >= GLP_MSG_ON && parm->out_dly == 0)
{ xprintf("~%6d: obj = %17.9e infeas = %10.3e\n", P->it_cnt,
lp->obj_val, 0.0);
}
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("OPTIMAL SOLUTION FOUND BY LP PREPROCESSOR\n");
goto post;
}
if (parm->msg_lev >= GLP_MSG_ALL)
{ xprintf("%d row%s, %d column%s, %d non-zero%s\n",
lp->m, lp->m == 1 ? "" : "s", lp->n, lp->n == 1 ? "" : "s",
lp->nnz, lp->nnz == 1 ? "" : "s");
}
/* inherit basis factorization control parameters */
glp_get_bfcp(P, &bfcp);
glp_set_bfcp(lp, &bfcp);
/* scale the transformed problem */
{ ENV *env = get_env_ptr();
int term_out = env->term_out;
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_scale_prob(lp, GLP_SF_AUTO);
env->term_out = term_out;
}
/* build advanced initial basis */
{ ENV *env = get_env_ptr();
int term_out = env->term_out;
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_adv_basis(lp, 0);
env->term_out = term_out;
}
/* solve the transformed LP */
lp->it_cnt = P->it_cnt;
ret = solve_lp(lp, parm);
P->it_cnt = lp->it_cnt;
/* only optimal solution can be postprocessed */
if (!(ret == 0 && lp->pbs_stat == GLP_FEAS && lp->dbs_stat ==
GLP_FEAS))
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: unable to recover undefined or non-op"
"timal solution\n");
if (ret == 0)
{ if (lp->pbs_stat == GLP_NOFEAS)
ret = GLP_ENOPFS;
else if (lp->dbs_stat == GLP_NOFEAS)
ret = GLP_ENODFS;
else
xassert(lp != lp);
}
goto done;
}
post: /* postprocess solution from the transformed LP */
npp_postprocess(npp, lp);
/* the transformed LP is no longer needed */
glp_delete_prob(lp), lp = NULL;
/* store solution to the original problem */
npp_unload_sol(npp, P);
/* the original LP has been successfully solved */
ret = 0;
done: /* delete the transformed LP, if it exists */
if (lp != NULL) glp_delete_prob(lp);
/* delete preprocessor workspace */
npp_delete_wksp(npp);
return ret;
}
void inline instrumentert::instrument_minimum_interference_inserter(
const std::set<event_grapht::critical_cyclet>& set_of_cycles)
{
/* Idea:
We solve this by a linear programming approach,
using for instance glpk lib.
Input: the edges to instrument E, the cycles C_j
Pb: min sum_{e_i in E} d(e_i).x_i
s.t. for all j, sum_{e_i in C_j} >= 1,
where e_i is a pair to potentially instrument,
x_i is a Boolean stating whether we instrument
e_i, and d() is the cost of an instrumentation.
Output: the x_i, saying which pairs to instrument
For this instrumentation, we propose:
d(poW*)=1
d(poRW)=d(rfe)=2
d(poRR)=3
This function can be refined with the actual times
we get in experimenting the different pairs in a
single IRIW.
*/
#ifdef HAVE_GLPK
/* first, identify all the unsafe pairs */
std::set<event_grapht::critical_cyclet::delayt> edges;
for(std::set<event_grapht::critical_cyclet>::iterator
C_j=set_of_cycles.begin();
C_j!=set_of_cycles.end();
++C_j)
for(std::set<event_grapht::critical_cyclet::delayt>::const_iterator e_i=
C_j->unsafe_pairs.begin();
e_i!=C_j->unsafe_pairs.end();
++e_i)
edges.insert(*e_i);
glp_prob* lp;
glp_iocp parm;
glp_init_iocp(&parm);
parm.msg_lev=GLP_MSG_OFF;
parm.presolve=GLP_ON;
lp=glp_create_prob();
glp_set_prob_name(lp, "instrumentation optimisation");
glp_set_obj_dir(lp, GLP_MIN);
message.debug() << "edges: "<<edges.size()<<" cycles:"<<set_of_cycles.size()
<< messaget::eom;
/* sets the variables and coefficients */
glp_add_cols(lp, edges.size());
unsigned i=0;
for(std::set<event_grapht::critical_cyclet::delayt>::iterator
e_i=edges.begin();
e_i!=edges.end();
++e_i)
{
++i;
std::string name="e_"+i2string(i);
glp_set_col_name(lp, i, name.c_str());
glp_set_col_bnds(lp, i, GLP_LO, 0.0, 0.0);
glp_set_obj_coef(lp, i, cost(*e_i));
glp_set_col_kind(lp, i, GLP_BV);
}
/* sets the constraints (soundness): one per cycle */
glp_add_rows(lp, set_of_cycles.size());
i=0;
for(std::set<event_grapht::critical_cyclet>::iterator
C_j=set_of_cycles.begin();
C_j!=set_of_cycles.end();
++C_j)
{
++i;
std::string name="C_"+i2string(i);
glp_set_row_name(lp, i, name.c_str());
glp_set_row_bnds(lp, i, GLP_LO, 1.0, 0.0); /* >= 1*/
}
const unsigned mat_size=set_of_cycles.size()*edges.size();
message.debug() << "size of the system: " << mat_size
<< messaget::eom;
int* imat=(int*)malloc(sizeof(int)*(mat_size+1));
int* jmat=(int*)malloc(sizeof(int)*(mat_size+1));
double* vmat=(double*)malloc(sizeof(double)*(mat_size+1));
/* fills the constraints coeff */
/* tables read from 1 in glpk -- first row/column ignored */
unsigned col=1;
unsigned row=1;
i=1;
for(std::set<event_grapht::critical_cyclet::delayt>::iterator
e_i=edges.begin();
e_i!=edges.end();
++e_i)
{
row=1;
for(std::set<event_grapht::critical_cyclet>::iterator
C_j=set_of_cycles.begin();
C_j!=set_of_cycles.end();
++C_j)
{
imat[i]=row;
jmat[i]=col;
if(C_j->unsafe_pairs.find(*e_i)!=C_j->unsafe_pairs.end())
vmat[i]=1.0;
else
vmat[i]=0.0;
++i;
++row;
}
++col;
}
#ifdef DEBUG
for(i=1; i<=mat_size; ++i)
message.statistics() <<i<<"["<<imat[i]<<","<<jmat[i]<<"]="<<vmat[i]
<< messaget::eom;
#endif
/* solves MIP by branch-and-cut */
glp_load_matrix(lp, mat_size, imat, jmat, vmat);
glp_intopt(lp, &parm);
/* loads results (x_i) */
message.statistics() << "minimal cost: " << glp_mip_obj_val(lp)
<< messaget::eom;
i=0;
for(std::set<event_grapht::critical_cyclet::delayt>::iterator
e_i=edges.begin();
e_i!=edges.end();
++e_i)
{
++i;
if(glp_mip_col_val(lp, i)>=1)
{
const abstract_eventt& first_ev=egraph[e_i->first];
var_to_instr.insert(first_ev.variable);
id2loc.insert(
std::pair<irep_idt,source_locationt>(first_ev.variable,first_ev.source_location));
if(!e_i->is_po)
{
const abstract_eventt& second_ev=egraph[e_i->second];
var_to_instr.insert(second_ev.variable);
id2loc.insert(
std::pair<irep_idt,source_locationt>(second_ev.variable,second_ev.source_location));
}
}
}
glp_delete_prob(lp);
free(imat);
free(jmat);
free(vmat);
#else
throw "Sorry, minimum interference option requires glpk; "
"please recompile goto-instrument with glpk.";
#endif
}
int max_flow_lp(int nn, int ne, const int beg[/*1+ne*/],
const int end[/*1+ne*/], const int cap[/*1+ne*/], int s, int t,
int x[/*1+ne*/])
{ glp_prob *lp;
glp_smcp smcp;
int i, k, nz, flow, *rn, *cn;
double temp, *aa;
/* create LP problem instance */
lp = glp_create_prob();
/* create LP rows; i-th row is the conservation condition of the
* flow at i-th node, i = 1, ..., nn */
glp_add_rows(lp, nn);
for (i = 1; i <= nn; i++)
glp_set_row_bnds(lp, i, GLP_FX, 0.0, 0.0);
/* create LP columns; k-th column is the elementary flow thru
* k-th edge, k = 1, ..., ne; the last column with the number
* ne+1 is the total flow through the network, which goes along
* a dummy feedback edge from the sink to the source */
glp_add_cols(lp, ne+1);
for (k = 1; k <= ne; k++)
{ xassert(cap[k] > 0);
glp_set_col_bnds(lp, k, GLP_DB, -cap[k], +cap[k]);
}
glp_set_col_bnds(lp, ne+1, GLP_FR, 0.0, 0.0);
/* build the constraint matrix; structurally this matrix is the
* incidence matrix of the network, so each its column (including
* the last column for the dummy edge) has exactly two non-zero
* entries */
rn = xalloc(1+2*(ne+1), sizeof(int));
cn = xalloc(1+2*(ne+1), sizeof(int));
aa = xalloc(1+2*(ne+1), sizeof(double));
nz = 0;
for (k = 1; k <= ne; k++)
{ /* x[k] > 0 means the elementary flow thru k-th edge goes from
* node beg[k] to node end[k] */
nz++, rn[nz] = beg[k], cn[nz] = k, aa[nz] = -1.0;
nz++, rn[nz] = end[k], cn[nz] = k, aa[nz] = +1.0;
}
/* total flow thru the network goes from the sink to the source
* along the dummy feedback edge */
nz++, rn[nz] = t, cn[nz] = ne+1, aa[nz] = -1.0;
nz++, rn[nz] = s, cn[nz] = ne+1, aa[nz] = +1.0;
/* check the number of non-zero entries */
xassert(nz == 2*(ne+1));
/* load the constraint matrix into the LP problem object */
glp_load_matrix(lp, nz, rn, cn, aa);
xfree(rn);
xfree(cn);
xfree(aa);
/* objective function is the total flow through the network to
* be maximized */
glp_set_obj_dir(lp, GLP_MAX);
glp_set_obj_coef(lp, ne + 1, 1.0);
/* solve LP instance with the (primal) simplex method */
glp_term_out(0);
glp_adv_basis(lp, 0);
glp_term_out(1);
glp_init_smcp(&smcp);
smcp.msg_lev = GLP_MSG_ON;
smcp.out_dly = 5000;
xassert(glp_simplex(lp, &smcp) == 0);
xassert(glp_get_status(lp) == GLP_OPT);
/* obtain optimal elementary flows thru edges of the network */
/* (note that the constraint matrix is unimodular and the data
* are integral, so all elementary flows in basic solution should
* also be integral) */
for (k = 1; k <= ne; k++)
{ temp = glp_get_col_prim(lp, k);
x[k] = (int)floor(temp + .5);
xassert(fabs(x[k] - temp) <= 1e-6);
}
/* obtain the maximum flow thru the original network which is the
* flow thru the dummy feedback edge */
temp = glp_get_col_prim(lp, ne+1);
flow = (int)floor(temp + .5);
xassert(fabs(flow - temp) <= 1e-6);
/* delete LP problem instance */
glp_delete_prob(lp);
/* return to the calling program */
return flow;
}
void CMyProblem::_destroy()
{
glp_delete_prob(lp);
}
int c_simplex_sparse(int m, int n, DMAT(c), DMAT(b), DVEC(s)) {
glp_prob *lp;
lp = glp_create_prob();
glp_set_obj_dir(lp, GLP_MAX);
int i,j,k;
int tot = cr - n;
glp_add_rows(lp, m);
glp_add_cols(lp, n);
//printf("%d %d\n",m,n);
// the first n values
for (k=1;k<=n;k++) {
glp_set_obj_coef(lp, k, AT(c, k-1, 2));
//printf("%d %f\n",k,AT(c, k-1, 2));
}
int * ia = malloc((1+tot)*sizeof(int));
int * ja = malloc((1+tot)*sizeof(int));
double * ar = malloc((1+tot)*sizeof(double));
for (k=1; k<= tot; k++) {
ia[k] = rint(AT(c,k-1+n,0));
ja[k] = rint(AT(c,k-1+n,1));
ar[k] = AT(c,k-1+n,2);
//printf("%d %d %f\n",ia[k],ja[k],ar[k]);
}
glp_load_matrix(lp, tot, ia, ja, ar);
int t;
for (i=1;i<=m;i++) {
switch((int)rint(AT(b,i-1,0))) {
case 0: { t = GLP_FR; break; }
case 1: { t = GLP_LO; break; }
case 2: { t = GLP_UP; break; }
case 3: { t = GLP_DB; break; }
default: { t = GLP_FX; break; }
}
glp_set_row_bnds(lp, i, t , AT(b,i-1,1), AT(b,i-1,2));
}
for (j=1;j<=n;j++) {
switch((int)rint(AT(b,m+j-1,0))) {
case 0: { t = GLP_FR; break; }
case 1: { t = GLP_LO; break; }
case 2: { t = GLP_UP; break; }
case 3: { t = GLP_DB; break; }
default: { t = GLP_FX; break; }
}
glp_set_col_bnds(lp, j, t , AT(b,m+j-1,1), AT(b,m+j-1,2));
}
glp_term_out(0);
glp_simplex(lp, NULL);
sp[0] = glp_get_status(lp);
sp[1] = glp_get_obj_val(lp);
for (k=1; k<=n; k++) {
sp[k+1] = glp_get_col_prim(lp, k);
}
glp_delete_prob(lp);
free(ia);
free(ja);
free(ar);
return 0;
}
/*
R is the random contraint data in row major memory layout
ridx is an N array of integers
soln is an array of length (n+1) soln[n] is t (objective value)
active_constr is an N-length 0-1 array
*/
void solve_lp(int N, int n, double* R, int* ridx, double* soln, int* active_constr)
{
double tol = 1.0e-14;
int size = (N+1)*(n+1) + 1; // We add one because GLPK indexes arrays
// starting at 1 instead of 0.
glp_prob *lp;
int* ia = malloc(size * sizeof(int));
int* ja = malloc(size * sizeof(int));
double* ar = malloc(size * sizeof(double));
int i, j;
lp = glp_create_prob();
glp_set_prob_name(lp, "portfolio");
glp_set_obj_dir(lp, GLP_MAX);
glp_add_rows(lp, N+1);
// Sampled constraints are ">= 0"
for (i = 1; i <= N; i++) {
glp_set_row_bnds(lp, i, GLP_LO, 0.0, 0.0);
}
// Sum = 1 constraint
glp_set_row_name(lp, N+1, "sum");
glp_set_row_bnds(lp, N+1, GLP_FX, 1.0, 1.0);
glp_add_cols(lp, n+1);
// Nonnegative variables y
for (i = 1; i <= n; i++) {
glp_set_col_bnds(lp, i, GLP_LO, 0.0, 0.0);
glp_set_obj_coef(lp, i, 0.0);
}
// Free variable t
glp_set_col_name(lp, n+1, "t");
glp_set_col_bnds(lp, n+1, GLP_FR, 0.0, 0.0);
glp_set_obj_coef(lp, n+1, 1.0);
// for (i = 0; i < N*(n-1); i++) {
// printf("%d: %g\n", i, R[i]);
// }
int idx = 1;
// Sampled constraints
for (i = 1; i <= N; i++) {
// Uncertain assets
for (j = 1; j < n; j++) {
ia[idx] = i;
ja[idx] = j;
ar[idx] = R[ ridx[(i-1)] * (n-1) + (j-1) ];
idx += 1;
}
// Fixed return asset
ia[idx] = i;
ja[idx] = n;
ar[idx] = 1.05;
idx += 1;
// t
ia[idx] = i;
ja[idx] = n+1;
ar[idx] = -1.0;
idx += 1;
}
// Sum = 1 constraint
for (i = 1; i <= n; i++) {
ia[idx] = N+1;
ja[idx] = i;
ar[idx] = 1.0;
idx += 1;
}
// t
ia[idx] = N+1;
ja[idx] = n+1;
ar[idx] = 0.0;
idx += 1;
// for (i = 1; i < size; i++) {
// printf("%d %d %g\n", ia[i], ja[i], ar[i]);
// }
glp_load_matrix(lp, size-1, ia, ja, ar);
// glp_scale_prob(lp, GLP_SF_AUTO);
glp_smcp param;
glp_init_smcp(¶m);
param.meth = GLP_PRIMAL;
//glp_std_basis(lp);
glp_simplex(lp, ¶m);
double z = glp_get_obj_val(lp);
// printf("z = %g\n", z);
if (soln) {
for (i = 0; i < n; i++) {
double y = glp_get_col_prim(lp, i+1);
soln[i] = y;
// printf("y%d = %g\n", i, y);
}
double t = glp_get_col_prim(lp, n+1);
soln[n] = t;
// printf("t = %g\n", glp_get_col_prim(lp, n+1));
}
for (i = 1; i <= N; i++) {
double slack = glp_get_row_prim(lp, i);
active_constr[i-1] = fabs(slack) < tol ? 1 : 0;
// printf("constr%d %d\n", i, active_constr[i-1]);
}
glp_delete_prob(lp);
// glp_free_env();
free(ia);
free(ja);
free(ar);
}
~IPimpl()
{
glp_delete_prob(ip_);
}
static void LPX_dealloc(LPXObject *self) {
LPX_clear(self);
if (LP) glp_delete_prob(LP);
self->ob_type->tp_free((PyObject*)self);
}
