limp-cbc-0.3.2.0: cbits/coin/Cbc_ampl.cpp
/* $Id: Cbc_ampl.cpp 1926 2013-05-24 10:19:49Z stefan $ */
/****************************************************************
Copyright (C) 1997-2000 Lucent Technologies
Modifications for Coin - Copyright (C) 2006, International Business Machines Corporation and others.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of Lucent or any of its entities
not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
****************************************************************/
/*! \file Cbc_ampl.cpp
Interface routines for AMPL.
*/
#include "CbcConfig.h"
#ifdef COIN_HAS_ASL
#ifdef HAVE_UNISTD_H
# include "unistd.h"
#endif
#include "CoinUtilsConfig.h"
#include "CoinHelperFunctions.hpp"
#include "CoinModel.hpp"
#include "CoinSort.hpp"
#include "CoinPackedMatrix.hpp"
#include "CoinMpsIO.hpp"
#include "CoinFloatEqual.hpp"
#ifdef COIN_HAS_CLP
#include "OsiClpSolverInterface.hpp"
#endif
#include "Cbc_ampl.h"
extern "C" {
# include "getstub.h"
# include "asl_pfgh.h"
}
#include <string>
#include <cassert>
/* so decodePhrase and clpCheck can access */
static ampl_info * saveInfo = NULL;
// Set to 1 if algorithm found
static char algFound[20] = "";
static char*
checkPhrase(Option_Info *oi, keyword *kw, char *v)
{
if (strlen(v))
printf("string %s\n", v);
// Say algorithm found
strcpy(algFound, kw->desc);
return v;
}
static char*
checkPhrase2(Option_Info *oi, keyword *kw, char *v)
{
if (strlen(v))
printf("string %s\n", v);
// put out keyword
saveInfo->arguments = (char **) realloc(saveInfo->arguments, (saveInfo->numberArguments + 1) * sizeof(char *));
saveInfo->arguments[saveInfo->numberArguments++] = strdup(kw->desc);
return v;
}
static fint
decodePhrase(char * phrase, ftnlen length)
{
char * blank = strchr(phrase, ' ');
if (blank) {
/* split arguments */
*blank = '\0';
saveInfo->arguments = (char **) realloc(saveInfo->arguments, (saveInfo->numberArguments + 2) * sizeof(char *));
saveInfo->arguments[saveInfo->numberArguments++] = strdup(phrase);
*blank = ' ';
phrase = blank + 1; /* move on */
if (strlen(phrase))
saveInfo->arguments[saveInfo->numberArguments++] = strdup(phrase);
} else if (strlen(phrase)) {
saveInfo->arguments = (char **) realloc(saveInfo->arguments, (saveInfo->numberArguments + 1) * sizeof(char *));
saveInfo->arguments[saveInfo->numberArguments++] = strdup(phrase);
}
return 0;
}
static void
sos_kludge(int nsos, int *sosbeg, double *sosref, int * sosind)
{
// Adjust sosref if necessary to make monotonic increasing
int i, j, k;
// first sort
for (i = 0; i < nsos; i++) {
k = sosbeg[i];
int end = sosbeg[i+1];
CoinSort_2(sosref + k, sosref + end, sosind + k);
}
double t, t1;
for (i = j = 0; i++ < nsos; ) {
k = sosbeg[i];
t = sosref[j];
while (++j < k) {
t1 = sosref[j];
t += 1e-10;
if (t1 <= t)
sosref[j] = t1 = t + 1e-10;
t = t1;
}
}
}
static char xxxxxx[20];
#define VP (char*)
static keyword keywds[] = { /* must be sorted */
{ const_cast<char*>("barrier"), checkPhrase, (char *) xxxxxx ,
const_cast<char*>("-barrier")},
{ const_cast<char*>("dual"), checkPhrase, (char *) xxxxxx ,
const_cast<char*>("-dualsimplex")},
{ const_cast<char*>("help"), checkPhrase2, (char *) xxxxxx ,
const_cast<char*>("-?")},
{ const_cast<char*>("initial"), checkPhrase, (char *) xxxxxx ,
const_cast<char*>("-initialsolve")},
{ const_cast<char*>("max"), checkPhrase2, (char *) xxxxxx ,
const_cast<char*>("-maximize")},
{ const_cast<char*>("maximize"), checkPhrase2, (char *) xxxxxx ,
const_cast<char*>("-maximize")},
{ const_cast<char*>("primal"), checkPhrase, (char *) xxxxxx ,
const_cast<char*>("-primalsimplex")},
{ const_cast<char*>("quit"), checkPhrase2, (char *) xxxxxx ,
const_cast<char*>("-quit")},
{ const_cast<char*>("wantsol"), WS_val, NULL,
const_cast<char*>("write .sol file (without -AMPL)")}
};
static Option_Info Oinfo = {
const_cast<char*>("cbc"),
const_cast<char*>("CBC " CBC_VERSION),
const_cast<char*>("cbc_options"),
keywds,
nkeywds,
0,
0,
0,
decodePhrase,
0,
0,
0,
20130502
};
// strdup used to avoid g++ compiler warning
static SufDecl suftab[] = {
#ifdef JJF_ZERO
{ const_cast<char*>("current"), 0, ASL_Sufkind_con | ASL_Sufkind_outonly },
{ const_cast<char*>("current"), 0, ASL_Sufkind_var | ASL_Sufkind_outonly },
{ const_cast<char*>("direction"), 0, ASL_Sufkind_var },
{ const_cast<char*>("down"), 0, ASL_Sufkind_con | ASL_Sufkind_outonly },
{ const_cast<char*>("down"), 0, ASL_Sufkind_var | ASL_Sufkind_outonly },
{ const_cast<char*>("priority"), 0, ASL_Sufkind_var },
#endif
{ const_cast<char*>("cut"), 0, ASL_Sufkind_con },
{ const_cast<char*>("direction"), 0, ASL_Sufkind_var },
{ const_cast<char*>("downPseudocost"), 0, ASL_Sufkind_var | ASL_Sufkind_real },
{ const_cast<char*>("priority"), 0, ASL_Sufkind_var },
{ const_cast<char*>("ref"), 0, ASL_Sufkind_var | ASL_Sufkind_real },
{ const_cast<char*>("sos"), 0, ASL_Sufkind_var },
{ const_cast<char*>("sos"), 0, ASL_Sufkind_con },
{ const_cast<char*>("sosno"), 0, ASL_Sufkind_var | ASL_Sufkind_real },
{ const_cast<char*>("sosref"), 0, ASL_Sufkind_var | ASL_Sufkind_real },
{ const_cast<char*>("special"), 0, ASL_Sufkind_var },
{ const_cast<char*>("special"), 0, ASL_Sufkind_con },
/*{ const_cast<char*>("special"), 0, ASL_Sufkind_con },*/
{ const_cast<char*>("sstatus"), 0, ASL_Sufkind_var, 0 },
{ const_cast<char*>("sstatus"), 0, ASL_Sufkind_con, 0 },
{ const_cast<char*>("upPseudocost"), 0, ASL_Sufkind_var | ASL_Sufkind_real }
#ifdef JJF_ZERO
{ const_cast<char*>("unbdd"), 0, ASL_Sufkind_var | ASL_Sufkind_outonly},
{ const_cast<char*>("up"), 0, ASL_Sufkind_con | ASL_Sufkind_outonly },
{ const_cast<char*>("up"), 0, ASL_Sufkind_var | ASL_Sufkind_outonly }
#endif
};
#include "float.h"
#include "limits.h"
static ASL *asl = NULL;
static FILE *nl = NULL;
static void
mip_stuff(void)
{
int i;
double *pseudoUp, *pseudoDown;
int *priority, *direction;
// To label cuts (there will be other uses for special)
int *cut;
// To label special variables - at present 1= must be >= 1 or <= -1
int * special;
SufDesc *dpup, *dpdown, *dpri, *ddir, *dcut, *dspecial;
ddir = suf_get("direction", ASL_Sufkind_var);
direction = ddir->u.i;
dpri = suf_get("priority", ASL_Sufkind_var);
priority = dpri->u.i;
dspecial = suf_get("special", ASL_Sufkind_con);
dcut = suf_get("cut", ASL_Sufkind_con);
cut = dcut->u.i;
if (!cut) {
// try special
dcut = suf_get("special", ASL_Sufkind_con);
cut = dcut->u.i;
}
dspecial = suf_get("special", ASL_Sufkind_var);
special = dspecial->u.i;
dpdown = suf_get("downPseudocost", ASL_Sufkind_var);
pseudoDown = dpdown->u.r;
dpup = suf_get("upPseudocost", ASL_Sufkind_var);
pseudoUp = dpup->u.r;
assert(saveInfo);
int numberColumns = saveInfo->numberColumns;
if (direction) {
int baddir = 0;
saveInfo->branchDirection = (int *) malloc(numberColumns * sizeof(int));
for (i = 0; i < numberColumns; i++) {
int value = direction[i];
if (value < -1 || value > 1) {
baddir++;
value = 0;
}
saveInfo->branchDirection[i] = value;
}
if (baddir)
fprintf(Stderr,
"Treating %d .direction values outside [-1, 1] as 0.\n",
baddir);
}
if (priority) {
int badpri = 0;
saveInfo->priorities = (int *) malloc(numberColumns * sizeof(int));
for (i = 0; i < numberColumns; i++) {
int value = priority[i];
if (value < 0) {
badpri++;
value = 0;
}
saveInfo->priorities[i] = value;
}
if (badpri)
fprintf(Stderr,
"Treating %d negative .priority values as 0\n",
badpri);
}
if (special) {
int badspecial = 0;
saveInfo->special = (int *) malloc(numberColumns * sizeof(int));
for (i = 0; i < numberColumns; i++) {
int value = special[i];
if (value < 0) {
badspecial++;
value = 0;
}
saveInfo->special[i] = value;
}
if (badspecial)
fprintf(Stderr,
"Treating %d negative special values as 0\n",
badspecial);
}
int numberRows = saveInfo->numberRows;
if (cut) {
int badcut = 0;
saveInfo->cut = (int *) malloc(numberRows * sizeof(int));
for (i = 0; i < numberRows; i++) {
int value = cut[i];
if (value < 0) {
badcut++;
value = 0;
}
saveInfo->cut[i] = value;
}
if (badcut)
fprintf(Stderr,
"Treating %d negative cut values as 0\n",
badcut);
}
if (pseudoDown || pseudoUp) {
int badpseudo = 0;
if (!pseudoDown || !pseudoUp)
fprintf(Stderr,
"Only one set of pseudocosts - assumed same\n");
saveInfo->pseudoDown = (double *) malloc(numberColumns * sizeof(double));
saveInfo->pseudoUp = (double *) malloc(numberColumns * sizeof(double));
for (i = 0; i < numberColumns; i++) {
double valueD = 0.0, valueU = 0.0;
if (pseudoDown) {
valueD = pseudoDown[i];
if (valueD < 0) {
badpseudo++;
valueD = 0.0;
}
}
if (pseudoUp) {
valueU = pseudoUp[i];
if (valueU < 0) {
badpseudo++;
valueU = 0.0;
}
}
if (!valueD)
valueD = valueU;
if (!valueU)
valueU = valueD;
saveInfo->pseudoDown[i] = valueD;
saveInfo->pseudoUp[i] = valueU;
}
if (badpseudo)
fprintf(Stderr,
"Treating %d negative pseudoCosts as 0.0\n", badpseudo);
}
}
static void
stat_map(int *stat, int n, int *map, int mx, const char *what)
{
int bad, i, i1 = 0, j, j1 = 0;
static char badfmt[] = "Coin driver: %s[%d] = %d\n";
for (i = bad = 0; i < n; i++) {
if ((j = stat[i]) >= 0 && j <= mx)
stat[i] = map[j];
else {
stat[i] = 0;
i1 = i;
j1 = j;
if (!bad++)
fprintf(Stderr, badfmt, what, i, j);
}
}
if (bad > 1) {
if (bad == 2)
fprintf(Stderr, badfmt, what, i1, j1);
else
fprintf(Stderr,
"Coin driver: %d messages about bad %s values suppressed.\n",
bad - 1, what);
}
}
int
readAmpl(ampl_info * info, int argc, char **argv, void ** coinModel)
{
char *stub;
ograd *og;
int i;
SufDesc *csd;
SufDesc *rsd;
/*bool *basis, *lower;*/
/*double *LU, *c, lb, objadj, *rshift, *shift, t, ub, *x, *x0, *x1;*/
char * environment = getenv("cbc_options");
char tempBuffer[20];
double * obj;
double * columnLower;
double * columnUpper;
double * rowLower;
double * rowUpper;
char ** saveArgv = argv;
char fileName[1000];
if (argc > 1)
strcpy(fileName, argv[1]);
else
fileName[0] = '\0';
int nonLinearType = -1;
// testosi parameter - if >= 10 then go in through coinModel
for (i = 1; i < argc; i++) {
if (!strncmp(argv[i], "testosi", 7)) {
char * equals = strchr(argv[i], '=');
if (equals && atoi(equals + 1) >= 10 && atoi(equals + 1) <= 20) {
nonLinearType = atoi(equals + 1);
break;
}
}
}
int saveArgc = argc;
if (info->numberRows != -1234567)
memset(info, 0, sizeof(ampl_info)); // overwrite unless magic number set
/* save so can be accessed by decodePhrase */
saveInfo = info;
info->numberArguments = 0;
info->arguments = (char **) malloc(2 * sizeof(char *));
info->arguments[info->numberArguments++] = strdup("ampl");
info->arguments[info->numberArguments++] = strdup("cbc");
asl = ASL_alloc(ASL_read_f);
stub = getstub(&argv, &Oinfo);
if (!stub)
usage_ASL(&Oinfo, 1);
nl = jac0dim(stub, 0);
suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
/* set A_vals to get the constraints column-wise (malloc so can be freed) */
A_vals = (double *) malloc(nzc * sizeof(double));
if (!A_vals) {
printf("no memory\n");
return 1;
}
/* say we want primal solution */
want_xpi0 = 1;
/* for basis info */
info->columnStatus = (int *) malloc(n_var * sizeof(int));
info->rowStatus = (int *) malloc(n_con * sizeof(int));
csd = suf_iput("sstatus", ASL_Sufkind_var, info->columnStatus);
rsd = suf_iput("sstatus", ASL_Sufkind_con, info->rowStatus);
if (!(nlvc + nlvo) && nonLinearType < 10) {
/* read linear model*/
f_read(nl, 0);
// see if any sos
if (true) {
char *sostype;
int nsosnz, *sosbeg, *sosind, * sospri;
double *sosref;
int nsos;
int i = ASL_suf_sos_explict_free;
int copri[2], **p_sospri;
copri[0] = 0;
copri[1] = 0;
p_sospri = &sospri;
nsos = suf_sos(i, &nsosnz, &sostype, p_sospri, copri,
&sosbeg, &sosind, &sosref);
if (nsos) {
info->numberSos = nsos;
info->sosType = (char *) malloc(nsos);
info->sosPriority = (int *) malloc(nsos * sizeof(int));
info->sosStart = (int *) malloc((nsos + 1) * sizeof(int));
info->sosIndices = (int *) malloc(nsosnz * sizeof(int));
info->sosReference = (double *) malloc(nsosnz * sizeof(double));
sos_kludge(nsos, sosbeg, sosref, sosind);
for (int i = 0; i < nsos; i++) {
char ichar = sostype[i];
assert (ichar == '1' || ichar == '2');
info->sosType[i] = static_cast<char>(ichar - '0');
}
memcpy(info->sosPriority, sospri, nsos*sizeof(int));
memcpy(info->sosStart, sosbeg, (nsos + 1)*sizeof(int));
memcpy(info->sosIndices, sosind, nsosnz*sizeof(int));
memcpy(info->sosReference, sosref, nsosnz*sizeof(double));
}
}
/*sos_finish(&specialOrderedInfo, 0, &j, 0, 0, 0, 0, 0);*/
Oinfo.uinfo = tempBuffer;
if (getopts(argv, &Oinfo))
return 1;
/* objective*/
obj = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++)
obj[i] = 0.0;
if (n_obj) {
for (og = Ograd[0]; og; og = og->next)
obj[og->varno] = og->coef;
}
if (objtype[0])
info->direction = -1.0;
else
info->direction = 1.0;
info->offset = objconst(0);
/* Column bounds*/
columnLower = (double *) malloc(n_var * sizeof(double));
columnUpper = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++) {
columnLower[i] = LUv[2*i];
if (columnLower[i] <= negInfinity)
columnLower[i] = -COIN_DBL_MAX;
columnUpper[i] = LUv[2*i+1];
if (columnUpper[i] >= Infinity)
columnUpper[i] = COIN_DBL_MAX;
}
/* Row bounds*/
rowLower = (double *) malloc(n_con * sizeof(double));
rowUpper = (double *) malloc(n_con * sizeof(double));
for (i = 0; i < n_con; i++) {
rowLower[i] = LUrhs[2*i];
if (rowLower[i] <= negInfinity)
rowLower[i] = -COIN_DBL_MAX;
rowUpper[i] = LUrhs[2*i+1];
if (rowUpper[i] >= Infinity)
rowUpper[i] = COIN_DBL_MAX;
}
info->numberRows = n_con;
info->numberColumns = n_var;
info->numberElements = nzc;
info->numberBinary = nbv;
info->numberIntegers = niv + nbv;
info->objective = obj;
info->rowLower = rowLower;
info->rowUpper = rowUpper;
info->columnLower = columnLower;
info->columnUpper = columnUpper;
info->starts = A_colstarts;
/*A_colstarts=NULL;*/
info->rows = A_rownos;
/*A_rownos=NULL;*/
info->elements = A_vals;
/*A_vals=NULL;*/
info->primalSolution = NULL;
/* put in primalSolution if exists */
if (X0) {
info->primalSolution = (double *) malloc(n_var * sizeof(double));
memcpy(info->primalSolution, X0, n_var*sizeof(double));
}
info->dualSolution = NULL;
if (niv + nbv > 0)
mip_stuff(); // get any extra info
if ((!(niv + nbv) && (csd->kind & ASL_Sufkind_input))
|| (rsd->kind & ASL_Sufkind_input)) {
/* convert status - need info on map */
static int map[] = {1, 3, 1, 1, 2, 1, 1};
stat_map(info->columnStatus, n_var, map, 6, "incoming columnStatus");
stat_map(info->rowStatus, n_con, map, 6, "incoming rowStatus");
} else {
/* all slack basis */
// leave status for output */
#ifdef JJF_ZERO
free(info->rowStatus);
info->rowStatus = NULL;
free(info->columnStatus);
info->columnStatus = NULL;
#endif
}
} else {
// QP
// Add .nl if not there
if (!strstr(fileName, ".nl"))
strcat(fileName, ".nl");
CoinModel * model = new CoinModel((nonLinearType > 10) ? 2 : 1, fileName, info);
if (model->numberRows() > 0 || model->numberColumns() > 0)
*coinModel = (void *) model;
Oinfo.uinfo = tempBuffer;
if (getopts(argv, &Oinfo))
return 1;
Oinfo.wantsol = 1;
if (objtype[0])
info->direction = -1.0;
else
info->direction = 1.0;
model->setOptimizationDirection(info->direction);
info->offset = objconst(0);
info->numberRows = n_con;
info->numberColumns = n_var;
info->numberElements = nzc;
info->numberBinary = nbv;
int numberIntegers = niv + nlvci + nlvoi + nbv;
if (nlvci + nlvoi + nlvc + nlvo) {
// Non linear
// No idea if there are overlaps so compute
int numberIntegers = 0;
for ( i = 0; i < n_var; i++) {
if (model->columnIsInteger(i))
numberIntegers++;
}
}
info->numberIntegers = numberIntegers;
// Say nonlinear if it is
info->nonLinear = nlvc + nlvo;
if (numberIntegers > 0) {
mip_stuff(); // get any extra info
if (info->cut)
model->setCutMarker(info->numberRows, info->cut);
if (info->priorities)
model->setPriorities(info->numberColumns, info->priorities);
}
}
/* add -solve - unless something there already
- also check for sleep=yes */
{
int found = 0;
int foundLog = 0;
int foundSleep = 0;
const char * something[] = {"solve", "branch", "duals", "primals", "user"};
for (i = 0; i < info->numberArguments; i++) {
unsigned int j;
const char * argument = info->arguments[i];
for (j = 0; j < sizeof(something) / sizeof(char *); j++) {
const char * check = something[j];
if (!strncmp(argument, check, sizeof(check))) {
found = (int)(j + 1);
} else if (!strncmp(argument, "log", 3)) {
foundLog = 1;
} else if (!strncmp(argument, "sleep", 5)) {
foundSleep = 1;
}
}
}
if (foundLog) {
/* print options etc */
for (i = 0; i < saveArgc; i++)
printf("%s ", saveArgv[i]);
printf("\n");
if (environment)
printf("env %s\n", environment);
/*printf("%d rows %d columns %d elements\n",n_con,n_var,nzc);*/
}
if (!found) {
if (!strlen(algFound)) {
info->arguments = (char **) realloc(info->arguments, (info->numberArguments + 1) * sizeof(char *));
info->arguments[info->numberArguments++] = strdup("-solve");
} else {
// use algorithm from keyword
info->arguments = (char **) realloc(info->arguments, (info->numberArguments + 1) * sizeof(char *));
info->arguments[info->numberArguments++] = strdup(algFound);
}
}
if (foundSleep) {
/* let user copy .nl file */
fprintf(stderr, "You can copy .nl file %s for debug purposes or attach debugger\n", saveArgv[1]);
fprintf(stderr, "Type q to quit, anything else to continue\n");
int getChar = getc(stdin);
if (getChar == 'q' || getChar == 'Q')
exit(1);
}
}
/* add -quit */
info->arguments = (char **) realloc(info->arguments, (info->numberArguments + 1) * sizeof(char *));
info->arguments[info->numberArguments++] = strdup("-quit");
return 0;
}
void freeArrays1(ampl_info * info)
{
free(info->objective);
info->objective = NULL;
free(info->rowLower);
info->rowLower = NULL;
free(info->rowUpper);
info->rowUpper = NULL;
free(info->columnLower);
info->columnLower = NULL;
free(info->columnUpper);
info->columnUpper = NULL;
/* this one not freed by ASL_free */
free(info->elements);
info->elements = NULL;
free(info->primalSolution);
info->primalSolution = NULL;
free(info->dualSolution);
info->dualSolution = NULL;
/*free(info->rowStatus);
info->rowStatus=NULL;
free(info->columnStatus);
info->columnStatus=NULL;*/
}
void freeArrays2(ampl_info * info)
{
free(info->primalSolution);
info->primalSolution = NULL;
free(info->dualSolution);
info->dualSolution = NULL;
free(info->rowStatus);
info->rowStatus = NULL;
free(info->columnStatus);
info->columnStatus = NULL;
free(info->priorities);
info->priorities = NULL;
free(info->branchDirection);
info->branchDirection = NULL;
free(info->pseudoDown);
info->pseudoDown = NULL;
free(info->pseudoUp);
info->pseudoUp = NULL;
free(info->sosType);
info->sosType = NULL;
free(info->sosPriority);
info->sosPriority = NULL;
free(info->sosStart);
info->sosStart = NULL;
free(info->sosIndices);
info->sosIndices = NULL;
free(info->sosReference);
info->sosReference = NULL;
free(info->cut);
info->cut = NULL;
ASL_free(&asl);
}
void freeArgs(ampl_info * info)
{
int i;
for ( i = 0; i < info->numberArguments; i++)
free(info->arguments[i]);
free(info->arguments);
}
int ampl_obj_prec()
{
return obj_prec();
}
void writeAmpl(ampl_info * info)
{
char buf[1000];
typedef struct {
const char *msg;
int code;
int wantObj;
} Sol_info;
static Sol_info solinfo[] = {
{ "optimal solution", 000, 1 },
{ "infeasible", 200, 1 },
{ "unbounded", 300, 0 },
{ "iteration limit etc", 400, 1 },
{ "solution limit", 401, 1 },
{ "ran out of space", 500, 0 },
{ "status unknown", 501, 1 },
{ "bug!", 502, 0 },
{ "best MIP solution so far restored", 101, 1 },
{ "failed to restore best MIP solution", 503, 1 },
{ "optimal (?) solution", 100, 1 }
};
/* convert status - need info on map */
static int map[] = {0, 3, 4, 1};
sprintf(buf, "%s %s", Oinfo.bsname, info->buffer);
solve_result_num = solinfo[info->problemStatus].code;
if (info->columnStatus) {
stat_map(info->columnStatus, n_var, map, 4, "outgoing columnStatus");
stat_map(info->rowStatus, n_con, map, 4, "outgoing rowStatus");
suf_iput("sstatus", ASL_Sufkind_var, info->columnStatus);
suf_iput("sstatus", ASL_Sufkind_con, info->rowStatus);
}
write_sol(buf, info->primalSolution, info->dualSolution, &Oinfo);
}
/* Read a problem from AMPL nl file
*/
CoinModel::CoinModel( int nonLinear, const char * fileName, const void * info)
: CoinBaseModel(),
maximumRows_(0),
maximumColumns_(0),
numberElements_(0),
maximumElements_(0),
numberQuadraticElements_(0),
maximumQuadraticElements_(0),
rowLower_(NULL),
rowUpper_(NULL),
rowType_(NULL),
objective_(NULL),
columnLower_(NULL),
columnUpper_(NULL),
integerType_(NULL),
columnType_(NULL),
start_(NULL),
elements_(NULL),
packedMatrix_(NULL),
quadraticElements_(NULL),
sortIndices_(NULL),
sortElements_(NULL),
sortSize_(0),
sizeAssociated_(0),
associated_(NULL),
numberSOS_(0),
startSOS_(NULL),
memberSOS_(NULL),
typeSOS_(NULL),
prioritySOS_(NULL),
referenceSOS_(NULL),
priority_(NULL),
cut_(NULL),
moreInfo_(NULL),
type_(-1),
noNames_(false),
links_(0)
{
problemName_ = "";
int status = 0;
if (!strcmp(fileName, "-") || !strcmp(fileName, "stdin")) {
// stdin
} else {
std::string name = fileName;
bool readable = fileCoinReadable(name);
if (!readable) {
std::cerr << "Unable to open file "
<< fileName << std::endl;
status = -1;
}
}
if (!status) {
gdb(nonLinear, fileName, info);
}
}
#ifdef JJF_ZERO
static real
qterm(ASL *asl, fint *colq, fint *rowq, real *delsq)
{
double t, t1, *x, *x0, *xe;
fint *rq0, *rqe;
t = 0.;
x0 = x = X0;
xe = x + n_var;
rq0 = rowq;
while (x < xe) {
t1 = *x++;
rqe = rq0 + *++colq;
while (rowq < rqe)
t += t1 * x0[*rowq++]**delsq++;
}
return 0.5 * t;
}
#endif
// stolen from IPopt with changes
typedef struct {
double obj_sign_;
ASL_pfgh * asl_;
double * non_const_x_;
int * column_; // for jacobian
int * rowStart_;
double * gradient_;
double * constraintValues_;
int nz_h_full_; // number of nonzeros in hessian
int nerror_;
bool objval_called_with_current_x_;
bool conval_called_with_current_x_;
bool jacval_called_with_current_x_;
} CbcAmplInfo;
void
CoinModel::gdb( int nonLinear, const char * fileName, const void * info)
{
const ampl_info * amplInfo = (const ampl_info *) info;
ograd *og = NULL;
int i;
SufDesc *csd = NULL;
SufDesc *rsd = NULL;
/*bool *basis, *lower;*/
/*double *LU, *c, lb, objadj, *rshift, *shift, t, ub, *x, *x0, *x1;*/
//char tempBuffer[20];
double * objective = NULL;
double * columnLower = NULL;
double * columnUpper = NULL;
double * rowLower = NULL;
double * rowUpper = NULL;
int * columnStatus = NULL;
int * rowStatus = NULL;
int numberRows = -1;
int numberColumns = -1;
int numberElements = -1;
int numberBinary = -1;
int numberIntegers = -1;
int numberAllNonLinearBoth = 0;
int numberIntegerNonLinearBoth = 0;
int numberAllNonLinearConstraints = 0;
int numberIntegerNonLinearConstraints = 0;
int numberAllNonLinearObjective = 0;
int numberIntegerNonLinearObjective = 0;
double * primalSolution = NULL;
double direction = 1.0;
char * stub = strdup(fileName);
CoinPackedMatrix matrixByRow;
fint ** colqp = NULL;
int *z = NULL;
if (nonLinear == 0) {
// linear
asl = ASL_alloc(ASL_read_f);
nl = jac0dim(stub, 0);
free(stub);
suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
/* set A_vals to get the constraints column-wise (malloc so can be freed) */
A_vals = (double *) malloc(nzc * sizeof(double));
if (!A_vals) {
printf("no memory\n");
return ;
}
/* say we want primal solution */
want_xpi0 = 1;
/* for basis info */
columnStatus = (int *) malloc(n_var * sizeof(int));
rowStatus = (int *) malloc(n_con * sizeof(int));
csd = suf_iput("sstatus", ASL_Sufkind_var, columnStatus);
rsd = suf_iput("sstatus", ASL_Sufkind_con, rowStatus);
/* read linear model*/
f_read(nl, 0);
// see if any sos
if (true) {
char *sostype;
int nsosnz, *sosbeg, *sosind, * sospri;
double *sosref;
int nsos;
int i = ASL_suf_sos_explict_free;
int copri[2], **p_sospri;
copri[0] = 0;
copri[1] = 0;
p_sospri = &sospri;
nsos = suf_sos(i, &nsosnz, &sostype, p_sospri, copri,
&sosbeg, &sosind, &sosref);
if (nsos) {
abort();
#ifdef JJF_ZERO
info->numberSos = nsos;
info->sosType = (char *) malloc(nsos);
info->sosPriority = (int *) malloc(nsos * sizeof(int));
info->sosStart = (int *) malloc((nsos + 1) * sizeof(int));
info->sosIndices = (int *) malloc(nsosnz * sizeof(int));
info->sosReference = (double *) malloc(nsosnz * sizeof(double));
sos_kludge(nsos, sosbeg, sosref, sosind);
for (int i = 0; i < nsos; i++) {
int ichar = sostype[i];
assert (ichar == '1' || ichar == '2');
info->sosType[i] = ichar - '0';
}
memcpy(info->sosPriority, sospri, nsos*sizeof(int));
memcpy(info->sosStart, sosbeg, (nsos + 1)*sizeof(int));
memcpy(info->sosIndices, sosind, nsosnz*sizeof(int));
memcpy(info->sosReference, sosref, nsosnz*sizeof(double));
#endif
}
}
/*sos_finish(&specialOrderedInfo, 0, &j, 0, 0, 0, 0, 0);*/
//Oinfo.uinfo = tempBuffer;
//if (getopts(argv, &Oinfo))
//return 1;
/* objective*/
objective = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++)
objective[i] = 0.0;
if (n_obj) {
for (og = Ograd[0]; og; og = og->next)
objective[og->varno] = og->coef;
}
if (objtype[0])
direction = -1.0;
else
direction = 1.0;
objectiveOffset_ = objconst(0);
/* Column bounds*/
columnLower = (double *) malloc(n_var * sizeof(double));
columnUpper = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++) {
columnLower[i] = LUv[2*i];
if (columnLower[i] <= negInfinity)
columnLower[i] = -COIN_DBL_MAX;
columnUpper[i] = LUv[2*i+1];
if (columnUpper[i] >= Infinity)
columnUpper[i] = COIN_DBL_MAX;
}
/* Row bounds*/
rowLower = (double *) malloc(n_con * sizeof(double));
rowUpper = (double *) malloc(n_con * sizeof(double));
for (i = 0; i < n_con; i++) {
rowLower[i] = LUrhs[2*i];
if (rowLower[i] <= negInfinity)
rowLower[i] = -COIN_DBL_MAX;
rowUpper[i] = LUrhs[2*i+1];
if (rowUpper[i] >= Infinity)
rowUpper[i] = COIN_DBL_MAX;
}
numberRows = n_con;
numberColumns = n_var;
numberElements = nzc;
numberBinary = nbv;
numberIntegers = niv;
/* put in primalSolution if exists */
if (X0) {
primalSolution = (double *) malloc(n_var * sizeof(double));
memcpy( primalSolution, X0, n_var*sizeof(double));
}
//double * dualSolution=NULL;
if (niv + nbv > 0)
mip_stuff(); // get any extra info
if ((!(niv + nbv) && (csd->kind & ASL_Sufkind_input))
|| (rsd->kind & ASL_Sufkind_input)) {
/* convert status - need info on map */
static int map[] = {1, 3, 1, 1, 2, 1, 1};
stat_map(columnStatus, n_var, map, 6, "incoming columnStatus");
stat_map(rowStatus, n_con, map, 6, "incoming rowStatus");
} else {
/* all slack basis */
// leave status for output */
#ifdef JJF_ZERO
free(rowStatus);
rowStatus = NULL;
free(columnStatus);
columnStatus = NULL;
#endif
}
CoinPackedMatrix columnCopy(true, numberRows, numberColumns, numberElements,
A_vals, A_rownos, A_colstarts, NULL);
matrixByRow.reverseOrderedCopyOf(columnCopy);
} else if (nonLinear == 1) {
// quadratic
asl = ASL_alloc(ASL_read_fg);
nl = jac0dim(stub, (ftnlen) strlen(stub));
free(stub);
suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
/* read model*/
X0 = (double*) malloc(n_var * sizeof(double));
CoinZeroN(X0, n_var);
qp_read(nl, 0);
assert (n_obj == 1);
int nz = 1 + n_con;
colqp = (fint**) malloc(nz * (2 * sizeof(int*)
+ sizeof(double*)));
fint ** rowqp = colqp + nz;
double ** delsqp = (double **)(rowqp + nz);
z = (int*) malloc(nz * sizeof(int));
for (i = 0; i <= n_con; i++) {
z[i] = nqpcheck(-i, rowqp + i, colqp + i, delsqp + i);
}
qp_opify();
/* objective*/
objective = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++)
objective[i] = 0.0;
if (n_obj) {
for (og = Ograd[0]; og; og = og->next)
objective[og->varno] = og->coef;
}
if (objtype[0])
direction = -1.0;
else
direction = 1.0;
objectiveOffset_ = objconst(0);
/* Column bounds*/
columnLower = (double *) malloc(n_var * sizeof(double));
columnUpper = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++) {
columnLower[i] = LUv[2*i];
if (columnLower[i] <= negInfinity)
columnLower[i] = -COIN_DBL_MAX;
columnUpper[i] = LUv[2*i+1];
if (columnUpper[i] >= Infinity)
columnUpper[i] = COIN_DBL_MAX;
}
// Build by row from scratch
//matrixByRow.reserve(n_var,nzc,true);
// say row orderded
matrixByRow.transpose();
/* Row bounds*/
rowLower = (double *) malloc(n_con * sizeof(double));
rowUpper = (double *) malloc(n_con * sizeof(double));
CoinBigIndex * rowStart = new CoinBigIndex [n_con+1];
int * column = new int [nzc];
double * element = new double [nzc];
rowStart[0] = 0;
numberElements = 0;
for (i = 0; i < n_con; i++) {
rowLower[i] = LUrhs[2*i];
if (rowLower[i] <= negInfinity)
rowLower[i] = -COIN_DBL_MAX;
rowUpper[i] = LUrhs[2*i+1];
if (rowUpper[i] >= Infinity)
rowUpper[i] = COIN_DBL_MAX;
for (cgrad * cg = Cgrad[i]; cg; cg = cg->next) {
column[numberElements] = cg->varno;
element[numberElements++] = cg->coef;
}
rowStart[i+1] = numberElements;
}
assert (numberElements == nzc);
matrixByRow.appendRows(n_con, rowStart, column, element);
delete [] rowStart;
delete [] column;
delete [] element;
numberRows = n_con;
numberColumns = n_var;
//numberElements=nzc;
numberBinary = nbv;
numberIntegers = niv;
numberAllNonLinearBoth = nlvb;
numberIntegerNonLinearBoth = nlvbi;
numberAllNonLinearConstraints = nlvc;
numberIntegerNonLinearConstraints = nlvci;
numberAllNonLinearObjective = nlvo;
numberIntegerNonLinearObjective = nlvoi;
/* say we want primal solution */
want_xpi0 = 1;
//double * dualSolution=NULL;
// save asl
// Fix memory leak one day
CbcAmplInfo * info = new CbcAmplInfo;
//amplGamsData_ = info;
info->asl_ = NULL; // as wrong form asl;
info->nz_h_full_ = -1; // number of nonzeros in hessian
info->objval_called_with_current_x_ = false;
info->nerror_ = 0;
info->obj_sign_ = direction;
info->conval_called_with_current_x_ = false;
info->non_const_x_ = NULL;
info->jacval_called_with_current_x_ = false;
info->rowStart_ = NULL;
info->column_ = NULL;
info->gradient_ = NULL;
info->constraintValues_ = NULL;
} else if (nonLinear == 2) {
// General nonlinear!
//ASL_pfgh* asl = (ASL_pfgh*)ASL_alloc(ASL_read_pfgh);
asl = ASL_alloc(ASL_read_pfgh);
nl = jac0dim(stub, (ftnlen) strlen(stub));
free(stub);
suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
/* read model*/
X0 = (double*) malloc(n_var * sizeof(double));
CoinZeroN(X0, n_var);
// code stolen from Ipopt
int retcode = pfgh_read(nl, ASL_return_read_err | ASL_findgroups);
switch (retcode) {
case ASL_readerr_none : {}
break;
case ASL_readerr_nofile : {
printf( "Cannot open .nl file\n");
exit(-1);
}
break;
case ASL_readerr_nonlin : {
assert(false); // this better not be an error!
printf( "model involves nonlinearities (ed0read)\n");
exit(-1);
}
break;
case ASL_readerr_argerr : {
printf( "user-defined function with bad args\n");
exit(-1);
}
break;
case ASL_readerr_unavail : {
printf( "user-defined function not available\n");
exit(-1);
}
break;
case ASL_readerr_corrupt : {
printf( "corrupt .nl file\n");
exit(-1);
}
break;
case ASL_readerr_bug : {
printf( "bug in .nl reader\n");
exit(-1);
}
break;
case ASL_readerr_CLP : {
printf( "ASL error message: \"solver cannot handle CLP extensions\"\n");
exit(-1);
}
break;
default: {
printf( "Unknown error in stub file read. retcode = %d\n", retcode);
exit(-1);
}
break;
}
// see "changes" in solvers directory of ampl code...
hesset(1, 0, 1, 0, nlc);
assert (n_obj == 1);
// find the nonzero structure for the hessian
// parameters to sphsetup:
int coeff_obj = 1; // coefficient of the objective fn ???
int mult_supplied = 1; // multipliers will be supplied
int uptri = 1; // only need the upper triangular part
// save asl
// Fix memory leak one day
CbcAmplInfo * info = new CbcAmplInfo;
moreInfo_ = (void *) info;
//amplGamsData_ = info;
info->asl_ = (ASL_pfgh *) asl;
// This is not easy to get from ampl so save
info->nz_h_full_ = sphsetup(-1, coeff_obj, mult_supplied, uptri);
info->objval_called_with_current_x_ = false;
info->nerror_ = 0;
info->obj_sign_ = direction;
info->conval_called_with_current_x_ = false;
info->non_const_x_ = NULL;
info->jacval_called_with_current_x_ = false;
// Look at nonlinear
if (nzc) {
n_conjac[1] = nlc; // just nonlinear
int * rowStart = new int [nlc+1];
info->rowStart_ = rowStart;
// See how many
int current_nz = 0;
for (int i = 0; i < nlc; i++) {
for (cgrad* cg = Cgrad[i]; cg; cg = cg->next) {
current_nz++;
}
}
// setup the structure
int * column = new int [current_nz];
info->column_ = column;
current_nz = 0;
rowStart[0] = 0;
for (int i = 0; i < nlc; i++) {
for (cgrad* cg = Cgrad[i]; cg; cg = cg->next) {
cg->goff = current_nz;
//iRow[cg->goff] = i ;
//jCol[cg->goff] = cg->varno + 1;
column[cg->goff] = cg->varno ;
current_nz++;
}
rowStart[i+1] = current_nz;
}
info->gradient_ = new double [nzc];
info->constraintValues_ = new double [nlc];
}
/* objective*/
objective = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++)
objective[i] = 0.0;
if (n_obj) {
for (og = Ograd[0]; og; og = og->next)
objective[og->varno] = og->coef;
}
if (objtype[0])
direction = -1.0;
else
direction = 1.0;
objectiveOffset_ = objconst(0);
/* Column bounds*/
columnLower = (double *) malloc(n_var * sizeof(double));
columnUpper = (double *) malloc(n_var * sizeof(double));
for (i = 0; i < n_var; i++) {
columnLower[i] = LUv[2*i];
if (columnLower[i] <= negInfinity)
columnLower[i] = -COIN_DBL_MAX;
columnUpper[i] = LUv[2*i+1];
if (columnUpper[i] >= Infinity)
columnUpper[i] = COIN_DBL_MAX;
}
// Build by row from scratch
//matrixByRow.reserve(n_var,nzc,true);
// say row orderded
matrixByRow.transpose();
CoinBigIndex * rowStart = new CoinBigIndex [n_con+1];
int * column = new int [nzc];
double * element = new double [nzc];
rowStart[0] = 0;
numberElements = 0;
/* Row bounds*/
rowLower = (double *) malloc(n_con * sizeof(double));
rowUpper = (double *) malloc(n_con * sizeof(double));
for (i = 0; i < n_con; i++) {
rowLower[i] = LUrhs[2*i];
if (rowLower[i] <= negInfinity)
rowLower[i] = -COIN_DBL_MAX;
rowUpper[i] = LUrhs[2*i+1];
if (rowUpper[i] >= Infinity)
rowUpper[i] = COIN_DBL_MAX;
for (cgrad * cg = Cgrad[i]; cg; cg = cg->next) {
column[numberElements] = cg->varno;
double value = cg->coef;
if (!value)
value = -1.2345e-29;
element[numberElements++] = value;
}
rowStart[i+1] = numberElements;
}
assert (numberElements == nzc);
matrixByRow.appendRows(n_con, rowStart, column, element);
delete [] rowStart;
delete [] column;
delete [] element;
numberRows = n_con;
numberColumns = n_var;
numberElements = nzc;
numberBinary = nbv;
numberIntegers = niv;
numberAllNonLinearBoth = nlvb;
numberIntegerNonLinearBoth = nlvbi;
numberAllNonLinearConstraints = nlvc;
numberIntegerNonLinearConstraints = nlvci;
numberAllNonLinearObjective = nlvo;
numberIntegerNonLinearObjective = nlvoi;
/* say we want primal solution */
want_xpi0 = 1;
//double * dualSolution=NULL;
} else {
abort();
}
// set problem name
problemName_ = "???";
// Build by row from scratch
const double * element = matrixByRow.getElements();
const int * column = matrixByRow.getIndices();
const CoinBigIndex * rowStart = matrixByRow.getVectorStarts();
const int * rowLength = matrixByRow.getVectorLengths();
for (i = 0; i < numberRows; i++) {
addRow(rowLength[i], column + rowStart[i],
element + rowStart[i], rowLower[i], rowUpper[i]);
}
// Now do column part
for (i = 0; i < numberColumns; i++) {
setColumnBounds(i, columnLower[i], columnUpper[i]);
setColumnObjective(i, objective[i]);
}
for ( i = numberColumns - numberBinary - numberIntegers;
i < numberColumns; i++) {
setColumnIsInteger(i, true);
}
// and non linear
for (i = numberAllNonLinearBoth - numberIntegerNonLinearBoth;
i < numberAllNonLinearBoth; i++) {
setColumnIsInteger(i, true);
}
for (i = numberAllNonLinearConstraints - numberIntegerNonLinearConstraints;
i < numberAllNonLinearConstraints; i++) {
setColumnIsInteger(i, true);
}
for (i = numberAllNonLinearObjective - numberIntegerNonLinearObjective;
i < numberAllNonLinearObjective; i++) {
setColumnIsInteger(i, true);
}
free(columnLower);
free(columnUpper);
free(rowLower);
free(rowUpper);
free(objective);
// do names
int iRow;
for (iRow = 0; iRow < numberRows_; iRow++) {
char name[9];
sprintf(name, "r%7.7d", iRow);
setRowName(iRow, name);
}
int iColumn;
for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
char name[9];
sprintf(name, "c%7.7d", iColumn);
setColumnName(iColumn, name);
}
if (colqp) {
// add in quadratic
int nz = 1 + n_con;
int nOdd = 0;
fint ** rowqp = colqp + nz;
double ** delsqp = (double **)(rowqp + nz);
for (i = 0; i <= n_con; i++) {
int nels = z[i];
if (nels) {
double * element = delsqp[i];
int * start = (int *) colqp[i];
int * row = (int *) rowqp[i];
if (!element) {
// odd row - probably not quadratic
nOdd++;
continue;
}
#ifdef JJF_ZERO
printf("%d quadratic els\n", nels);
for (int j = 0; j < n_var; j++) {
for (int k = start[j]; k < start[j+1]; k++)
printf("%d %d %g\n", j, row[k], element[k]);
}
#endif
if (i) {
int iRow = i - 1;
for (int j = 0; j < n_var; j++) {
for (int k = start[j]; k < start[j+1]; k++) {
int kColumn = row[k];
double value = element[k];
// ampl gives twice with assumed 0.5
if (kColumn < j)
continue;
else if (kColumn == j)
value *= 0.5;
const char * expr = getElementAsString(iRow, j);
double constant = 0.0;
bool linear;
if (expr && strcmp(expr, "Numeric")) {
linear = false;
} else {
constant = getElement(iRow, j);
linear = true;
}
char temp[1000];
char temp2[30];
if (value == 1.0)
sprintf(temp2, "c%7.7d", kColumn);
else
sprintf(temp2, "%g*c%7.7d", value, kColumn);
if (linear) {
if (!constant)
strcpy(temp, temp2);
else if (value > 0.0)
sprintf(temp, "%g+%s", constant, temp2);
else
sprintf(temp, "%g%s", constant, temp2);
} else {
if (value > 0.0)
sprintf(temp, "%s+%s", expr, temp2);
else
sprintf(temp, "%s%s", expr, temp2);
}
assert (strlen(temp) < 1000);
setElement(iRow, j, temp);
if (amplInfo->logLevel > 1)
printf("el for row %d column c%7.7d is %s\n", iRow, j, temp);
}
}
} else {
// objective
for (int j = 0; j < n_var; j++) {
for (int k = start[j]; k < start[j+1]; k++) {
int kColumn = row[k];
double value = element[k];
// ampl gives twice with assumed 0.5
if (kColumn < j)
continue;
else if (kColumn == j)
value *= 0.5;
const char * expr = getColumnObjectiveAsString(j);
double constant = 0.0;
bool linear;
if (expr && strcmp(expr, "Numeric")) {
linear = false;
} else {
constant = getColumnObjective(j);
linear = true;
}
char temp[1000];
char temp2[30];
if (value == 1.0)
sprintf(temp2, "c%7.7d", kColumn);
else
sprintf(temp2, "%g*c%7.7d", value, kColumn);
if (linear) {
if (!constant)
strcpy(temp, temp2);
else if (value > 0.0)
sprintf(temp, "%g+%s", constant, temp2);
else
sprintf(temp, "%g%s", constant, temp2);
} else {
if (value > 0.0)
sprintf(temp, "%s+%s", expr, temp2);
else
sprintf(temp, "%s%s", expr, temp2);
}
assert (strlen(temp) < 1000);
setObjective(j, temp);
if (amplInfo->logLevel > 1)
printf("el for objective column c%7.7d is %s\n", j, temp);
}
}
}
}
}
if (nOdd) {
printf("%d non-linear constraints could not be converted to quadratic\n", nOdd);
exit(77);
}
}
free(colqp);
free(z);
// see if any sos
{
char *sostype;
int nsosnz, *sosbeg, *sosind, * sospri;
double *sosref;
int nsos;
int i = ASL_suf_sos_explict_free;
int copri[2], **p_sospri;
copri[0] = 0;
copri[1] = 0;
p_sospri = &sospri;
nsos = suf_sos(i, &nsosnz, &sostype, p_sospri, copri,
&sosbeg, &sosind, &sosref);
if (nsos) {
numberSOS_ = nsos;
typeSOS_ = new int [numberSOS_];
prioritySOS_ = new int [numberSOS_];
startSOS_ = new int [numberSOS_+1];
memberSOS_ = new int[nsosnz];
referenceSOS_ = new double [nsosnz];
sos_kludge(nsos, sosbeg, sosref, sosind);
for (int i = 0; i < nsos; i++) {
int ichar = sostype[i];
assert (ichar == '1' || ichar == '2');
typeSOS_[i] = ichar - '0';
}
memcpy(prioritySOS_, sospri, nsos*sizeof(int));
memcpy(startSOS_, sosbeg, (nsos + 1)*sizeof(int));
memcpy(memberSOS_, sosind, nsosnz*sizeof(int));
memcpy(referenceSOS_, sosref, nsosnz*sizeof(double));
}
}
}
#else
#include "Cbc_ampl.h"
int
readAmpl(ampl_info * , int , char **, void ** )
{
return 0;
}
void freeArrays1(ampl_info *)
{
}
void freeArrays2(ampl_info *)
{
}
void freeArgs(ampl_info * )
{
}
int ampl_obj_prec()
{
return 0;
}
void writeAmpl(ampl_info * )
{
}
#endif