A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://scip.zib.de/doc/html/lpi__msk_8c_source.php below:

SCIP Doxygen Documentation: src/lpi/lpi_msk.c Source File

53#include "tinycthread/tinycthread.h" 56#if defined(_WIN32) || defined(_WIN64) 57#define snprintf _snprintf 60#if ( MSK_VERSION_MAJOR < 7 ) 61#error "The MOSEK interface only works for MOSEK versions 7.0.0.0 and newer" 64#define scipmskobjsen MSKobjsensee 65#define SENSE2MOSEK(objsen) (((objsen)==SCIP_OBJSEN_MINIMIZE)?(MSK_OBJECTIVE_SENSE_MINIMIZE):(MSK_OBJECTIVE_SENSE_MAXIMIZE)) 69#define MOSEK_CALL(x) do \ 71 MSKrescodee _restat_; \ 73 if( (_restat_) != MSK_RES_OK && (_restat_ ) != MSK_RES_TRM_MAX_NUM_SETBACKS ) \ 75 SCIPerrorMessage("LP Error: MOSEK returned %d.\n"

, (int)_restat_); \

76

return SCIP_LPERROR; \

82#define SCIP_ABORT_FALSE(x) do \ 84 SCIP_RETCODE _restat_; \ 85 if( (_restat_ = (x)) != SCIP_OKAY ) \ 87 SCIPerrorMessage("LP Error: MOSEK returned %d.\n"

, (int)_restat_); \

94#define IS_POSINF(x) ((x) >= MSK_INFINITY) 95#define IS_NEGINF(x) ((x) <= -MSK_INFINITY) 96#define MOSEK_relDiff(val1, val2) ( ((val1)-(val2))/(MAX3(1.0,REALABS(val1),REALABS(val2))) ) 99 #if defined(_Thread_local) 102 static

_Thread_local

int numlp

= 0;

103 #define SCIP_REUSEENV 109 #define SCIP_REUSEENV 112#if MSK_VERSION_MAJOR >= 9 113#define NEAR_REL_TOLERANCE 1.0 115#define DEBUG_PRINT_STAT 0 116#define DEBUG_PARAM_SETTING 0 117#define DEBUG_CHECK_DATA 0 118#define DEBUG_EASY_REPRODUCE 0 119#define DEBUG_DO_INTPNT_FEAS_CHECK 0 120#define DEBUG_CHECK_STATE_TOL 1e-5 122#define SHOW_RELATIVE_OPTIMAL_GAP 0 123#define ASSERT_ON_NUMERICAL_TROUBLES 0 124#define ASSERT_ON_WARNING 0 125#define FORCE_MOSEK_LOG 0 126#define FORCE_MOSEK_SUMMARY 0 127#define FORCE_NO_MAXITER 0 128#define SETBACK_LIMIT 250 129#define STRONGBRANCH_PRICING MSK_SIM_SELECTION_SE 130#define SUPRESS_NAME_ERROR 1 132#define WRITE_PRIMAL 0 133#define WRITE_INTPNT 0 134#if WRITE_DUAL > 0 || WRITE_PRIMAL > 0 || WRITE_INTPNT > 0 || FORCE_MOSEK_LOG > 0 || FORCE_MOSEK_SUMMARY > 0 137#define DEGEN_LEVEL MSK_SIM_DEGEN_FREE 138#define ALWAYS_SOLVE_PRIMAL_FORM 1 139#if DEBUG_PRINT_STAT > 0 140static int

numstrongbranchmaxiterup = 0;

141static int

numstrongbranchmaxiterdo = 0;

142static int

numprimalmaxiter = 0;

143static int

numdualmaxiter = 0;

144static int

numstrongbranchobjup = 0;

145static int

numstrongbranchobjdo = 0;

146static int

numprimalobj = 0;

147static int

numdualobj = 0;

150#if DEBUG_PRINT_STAT > 0 151static int

numstrongbranchmaxiterup = 0;

152static int

numstrongbranchmaxiterdo = 0;

153static int

numprimalmaxiter = 0;

154static int

numdualmaxiter = 0;

155static int

numstrongbranchobjup = 0;

156static int

numstrongbranchobjdo = 0;

157static int

numprimalobj = 0;

158static int

numdualobj = 0;

198#define COLS_PER_PACKET SCIP_DUALPACKETSIZE 200#define ROWS_PER_PACKET SCIP_DUALPACKETSIZE 225

MSKsoltypee whichsol,

232 if

( prosta !=

NULL

)

234

res = MSK_getprosta(task, whichsol, prosta);

235 if

( res != MSK_RES_OK )

238 if

( solsta !=

NULL

)

240

res = MSK_getsolsta(task, whichsol, solsta);

241 if

( res != MSK_RES_OK )

269

MSKuserhandle_t handle,

273#if SUPRESS_NAME_ERROR 275

(void) snprintf(errstr, 32,

"MOSEK Error %d"

, MSK_RES_ERR_DUP_NAME);

276 if

(0 == strncmp(errstr, str, strlen(errstr)))

280 if

( handle ==

NULL

)

281

printf(

"MOSEK: %s"

, str);

286#if DEBUG_CHECK_DATA > 0 291 const char

* functionname

307

assert(lpi !=

NULL

);

311 MOSEK_CALL

( MSK_solutiondef(lpi->

task

, MSK_SOL_BAS, &gotbasicsol) );

334 for

( i = 0; i < numvar; i++ )

336 MOSEK_CALL

( MSK_getbound(lpi->

task

, MSK_ACC_VAR, i, &tbkx[i], &tblx[i], &tbux[i]) );

339 for

( i = 0; i < numcon; i++ )

341 MOSEK_CALL

( MSK_getbound(lpi->

task

, MSK_ACC_CON, i, &tbkc[i], &tblc[i], &tbuc[i]) );

344 for

( i = 0; i < numcon; ++i )

348 if

( ( tskc[i] == MSK_SK_FIX && tbkc[i] != MSK_BK_FX ) ||

349

( tskc[i] == MSK_SK_LOW && !(tbkc[i] == MSK_BK_FX || tbkc[i] == MSK_BK_LO || tbkc[i] == MSK_BK_RA ) ) ||

350

( tskc[i] == MSK_SK_UPR && !(tbkc[i] == MSK_BK_FX || tbkc[i] == MSK_BK_UP || tbkc[i] == MSK_BK_RA ) ) )

352 SCIPerrorMessage

(

"STATUS KEY ERROR i %d bkc %d skc %d %s\n"

, i, tbkc[i], tskc[i], functionname);

356 if

( tbkc[i] == MSK_BK_LO || tbkc[i] == MSK_BK_FX || tbkc[i] == MSK_BK_RA )

358 if

( isnan(tblc[i]) )

364 if

( tbkc[i] == MSK_BK_UP || tbkc[i] == MSK_BK_FX || tbkc[i] == MSK_BK_RA )

366 if

( isnan(tbuc[i]) )

373 for

( i = 0; i < numvar; ++i )

375 if

( tbkx[i] == MSK_BK_LO || tbkx[i] == MSK_BK_FX || tbkx[i] == MSK_BK_RA )

377 if

( isnan(tblx[i]) )

383 if

( tbkx[i] == MSK_BK_UP || tbkx[i] == MSK_BK_FX || tbkx[i] == MSK_BK_RA )

385 if

( isnan(tbux[i]) )

469

assert(lpi !=

NULL

);

489 for

( i = 0; i < n; i++ )

510 else if

(lb[i] == ub[i])

512

assert(lb[i] - ub[i] == 0);

513

assert(ub[i] - lb[i] == 0);

518

assert(lb[i] < ub[i]);

536

assert(beg !=

NULL

|| nnonz == 0);

540

assert(beg !=

NULL

);

541 for

(i = 0; i < n-1; i++)

544

assert(aptre[i] >= beg[i]);

548

assert(aptre[n-1] >= beg[n-1]);

552 for

( i = 0; i < n; i++ )

569

assert(first <= last);

573 for

( i = first; i <= last; i++ )

593

assert(dstat !=

NULL

);

594

assert(count !=

NULL

);

597 for

( i = 0; i < n; i++ )

613 for

( i = 0; i < n; i++ )

633 for

( i = 0; i < len; i++ )

753#define STR_HELPER(x) #x 754#define STR(x) STR_HELPER(x) 756#if MSK_VERSION_MAJOR < 9 757 #define mskname "MOSEK "

STR(MSK_VERSION_MAJOR) "." STR(MSK_VERSION_MINOR) "." STR(MSK_VERSION_BUILD) "." STR(MSK_VERSION_REVISION)

759 #define mskname "MOSEK "

STR(MSK_VERSION_MAJOR) "." STR(MSK_VERSION_MINOR) "." STR(MSK_VERSION_REVISION)

778 return "Linear Programming Solver developed by MOSEK Optimization Software (www.mosek.com)"

;

786

assert(lpi !=

NULL

);

790 return

(

void

*) lpi->

task

;

800

assert( lpi !=

NULL

);

801

assert( ncols >= 0 );

802

assert( intInfo !=

NULL

);

804 SCIPerrorMessage

(

"SCIPlpiSetIntegralityInformation() has not been implemented yet.\n"

);

850

assert(lpi !=

NULL

);

851

assert(name !=

NULL

);

863#if MSK_VERSION_MAJOR < 8 868

(*lpi)->lpid =

numlp

++;

871

(*lpi)->numlp = &

numlp

;

877 MOSEK_CALL

( MSK_linkfunctoenvstream((*lpi)->mosekenv, MSK_STREAM_LOG, (MSKuserhandle_t) messagehdlr,

printstr

) );

878#if MSK_VERSION_MAJOR < 8 883 MOSEK_CALL

( MSK_makeemptytask((*lpi)->mosekenv, &((*lpi)->task)) );

885 MOSEK_CALL

( MSK_linkfunctotaskstream((*lpi)->task, MSK_STREAM_LOG, (MSKuserhandle_t) messagehdlr,

printstr

) );

889 MOSEK_CALL

( MSK_putintparam((*lpi)->task, MSK_IPAR_OPTIMIZER, MSK_OPTIMIZER_FREE_SIMPLEX) );

891 MOSEK_CALL

( MSK_putintparam((*lpi)->task, MSK_IPAR_SIM_SWITCH_OPTIMIZER, MSK_ON) );

892 MOSEK_CALL

( MSK_puttaskname((*lpi)->task, (

char

*) name) );

893 MOSEK_CALL

( MSK_putobjname((*lpi)->task,

"obj"

) );

896 MOSEK_CALL

( MSK_putdouparam((*lpi)->task, MSK_DPAR_DATA_TOL_AIJ_HUGE, MSK_INFINITY * 2));

897 MOSEK_CALL

( MSK_putdouparam((*lpi)->task, MSK_DPAR_DATA_TOL_C_HUGE, MSK_INFINITY));

900 MOSEK_CALL

( MSK_putdouparam((*lpi)->task, MSK_DPAR_DATA_TOL_AIJ_LARGE, MSK_INFINITY * 2));

901 MOSEK_CALL

( MSK_putdouparam((*lpi)->task, MSK_DPAR_DATA_TOL_CJ_LARGE, MSK_INFINITY));

904 MOSEK_CALL

( MSK_putdouparam((*lpi)->task, MSK_DPAR_DATA_TOL_BOUND_WRN, MSK_INFINITY));

906

(*lpi)->termcode = MSK_RES_OK;

907

(*lpi)->itercount = 0;

910

(*lpi)->lastalgo = MSK_OPTIMIZER_FREE;

915

(*lpi)->aptre =

NULL

;

920

(*lpi)->aptresize = 0;

921

(*lpi)->lastsolvetype = (MSKsoltypee) -1;

922

(*lpi)->lpinfo =

FALSE

;

923

(*lpi)->restrictselectdef = 50;

924

(*lpi)->fromscratch =

FALSE

;

925

(*lpi)->clearstate =

FALSE

;

926

(*lpi)->messagehdlr = messagehdlr;

930 MOSEK_CALL

( MSK_putintparam((*lpi)->task, MSK_IPAR_LOG, MSK_OFF) );

931 MOSEK_CALL

( MSK_putintparam((*lpi)->task, MSK_IPAR_LOG_SIM, MSK_OFF) );

941

assert(lpi !=

NULL

);

942

assert(*lpi !=

NULL

);

956

assert(*(*lpi)->numlp > 0);

959 if

( *(*lpi)->numlp == 0 )

962 MOSEK_CALL

( MSK_deleteenv((*lpi)->reusemosekenv) );

963

*(*lpi)->reusemosekenv =

NULL

;

966 MOSEK_CALL

( MSK_deleteenv(&(*lpi)->mosekenv) );

1001 for

( j = 0; j < nnonz; j++ )

1002

assert( val[j] != 0.0 );

1006

assert(lpi !=

NULL

);

1009

assert(lhs !=

NULL

);

1010

assert(rhs !=

NULL

);

1011

assert(obj !=

NULL

);

1012

assert(lb !=

NULL

);

1013

assert(ub !=

NULL

);

1014

assert(beg !=

NULL

);

1015

assert(ind !=

NULL

);

1016

assert(val !=

NULL

);

1022#if DEBUG_CHECK_DATA > 0 1023 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiLoadColLP"

) );

1041 MOSEK_CALL

( MSK_inputdata(lpi->

task

, nrows, ncols, nrows, ncols, obj, 0.0, beg, lpi->

aptre

, ind, val,

1042

lpi->

bkc

, lhs, rhs, lpi->

bkx

, lb, ub) );

1046 if

( colnames !=

NULL

)

1050 for

( c = 0; c < ncols; c++ )

1056 if

( rownames !=

NULL

)

1060 for

(

r

= 0;

r

< nrows;

r

++ )

1066#if DEBUG_CHECK_DATA > 0 1067 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiLoadColLP"

) );

1087#if MSK_VERSION_MAJOR < 7 1093

assert(lpi !=

NULL

);

1096

assert(obj !=

NULL

);

1097

assert(lb !=

NULL

);

1098

assert(ub !=

NULL

);

1099

assert(nnonz == 0 || beg !=

NULL

);

1100

assert(nnonz == 0 || ind !=

NULL

);

1101

assert(nnonz == 0 || val !=

NULL

);

1109#if DEBUG_CHECK_DATA > 0 1110 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiAddCols"

) );

1122 MOSEK_CALL

( MSK_putcslice(lpi->

task

, oldcols, oldcols+ncols, obj) );

1123 MOSEK_CALL

( MSK_putvarboundslice(lpi->

task

, oldcols, oldcols+ncols, lpi->

bkx

, lb, ub) );

1133 for

(j = 0; j < nnonz; ++j)

1135

assert( 0 <= ind[j] && ind[j] < nrows );

1136

assert( val[j] != 0.0 );

1142 MOSEK_CALL

( MSK_putacolslice(lpi->

task

, oldcols, oldcols+ncols, beg, lpi->

aptre

, ind, val) );

1145 if

( colnames !=

NULL

)

1149 for

( c = 0; c < ncols; c++ )

1155#if DEBUG_CHECK_DATA > 0 1156 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiAddCols"

) );

1171

assert(lpi !=

NULL

);

1174

assert(firstcol >= 0);

1175

assert(firstcol <= lastcol + 1);

1180

assert(lastcol < ncols);

1187 if

( firstcol > lastcol )

1192#if DEBUG_CHECK_DATA > 0 1193 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelCols"

) );

1198 MOSEK_CALL

( MSK_removevars(lpi->

task

, lastcol-firstcol+1, sub) );

1202#if DEBUG_CHECK_DATA > 0 1203 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelCols"

) );

1223

assert(lpi !=

NULL

);

1226

assert(dstat !=

NULL

);

1232#if DEBUG_CHECK_DATA > 0 1233 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelColset"

) );

1241 for

( i = 0; i < ncols; i++)

1261#if DEBUG_CHECK_DATA > 0 1262 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelColset"

) );

1283

assert(lpi !=

NULL

);

1286

assert(nnonz == 0 || beg !=

NULL

);

1287

assert(nnonz == 0 || ind !=

NULL

);

1288

assert(nnonz == 0 || val !=

NULL

);

1294#if DEBUG_CHECK_DATA > 0 1295 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiAddRows"

) );

1308 MOSEK_CALL

( MSK_putconboundslice(lpi->

task

, oldrows, oldrows+nrows, lpi->

bkc

, lhs, rhs) );

1318 for

(j = 0; j < nnonz; ++j)

1320

assert( val[j] != 0.0 );

1321

assert( 0 <= ind[j] && ind[j] < ncols );

1327 MOSEK_CALL

( MSK_putarowslice(lpi->

task

, oldrows, oldrows+nrows, beg, lpi->

aptre

, ind, val) );

1330 if

( rownames !=

NULL

)

1334 for

(

r

= 0;

r

< nrows;

r

++ )

1340#if DEBUG_CHECK_DATA > 0 1341 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiAddRows"

) );

1356

assert(lpi !=

NULL

);

1359

assert(firstrow >= 0);

1360

assert(firstrow <= lastrow + 1);

1365

assert(lastrow < nrows);

1372 if

( firstrow > lastrow )

1377#if DEBUG_CHECK_DATA > 0 1378 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelRows"

) );

1385 MOSEK_CALL

( MSK_removecons(lpi->

task

, lastrow-firstrow+1, sub) );

1389#if DEBUG_CHECK_DATA > 0 1390 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelRows"

) );

1410

assert(lpi !=

NULL

);

1418#if DEBUG_CHECK_DATA > 0 1419 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelRowset"

) );

1428 for

( i = 0; i < nrows; i++ )

1448#if DEBUG_CHECK_DATA > 0 1449 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiDelRowset end"

) );

1463

assert(lpi !=

NULL

);

1491

assert(lpi !=

NULL

);

1494

assert(ncols == 0 || (ind !=

NULL

&& lb !=

NULL

&& ub !=

NULL

));

1502#if DEBUG_CHECK_DATA > 0 1503 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgBounds"

) );

1508 for

(i = 0; i < ncols; ++i)

1512 SCIPerrorMessage

(

"LP Error: fixing lower bound for variable %d to infinity.\n"

, ind[i]);

1517 SCIPerrorMessage

(

"LP Error: fixing upper bound for variable %d to -infinity.\n"

, ind[i]);

1525#if MSK_VERSION_MAJOR < 9 1526 MOSEK_CALL

( MSK_putboundlist(lpi->

task

, MSK_ACC_VAR, ncols, ind, lpi->

bkx

, lb, ub) );

1528 MOSEK_CALL

( MSK_putvarboundlist(lpi->

task

, ncols, ind, lpi->

bkx

, lb, ub) );

1531#if DEBUG_CHECK_DATA > 0 1532 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgBounds"

) );

1547

assert(lpi !=

NULL

);

1550

assert(ind !=

NULL

);

1559#if DEBUG_CHECK_DATA > 0 1560 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgSides"

) );

1566#if MSK_VERSION_MAJOR < 9 1567 MOSEK_CALL

( MSK_putboundlist(lpi->

task

, MSK_ACC_CON, nrows, ind, lpi->

bkc

, lhs, rhs) );

1569 MOSEK_CALL

( MSK_putconboundlist(lpi->

task

, nrows, ind, lpi->

bkc

, lhs, rhs) );

1572#if DEBUG_CHECK_DATA > 0 1573 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgSides"

) );

1587

assert(lpi !=

NULL

);

1595#if DEBUG_CHECK_DATA > 0 1596 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgCoef"

) );

1601#if DEBUG_CHECK_DATA > 0 1602 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgCoef"

) );

1614

assert(lpi !=

NULL

);

1635

assert(lpi !=

NULL

);

1638

assert(ind !=

NULL

);

1639

assert(obj !=

NULL

);

1645#if DEBUG_CHECK_DATA > 0 1646 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgObj"

) );

1651#if DEBUG_CHECK_DATA > 0 1652 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiChgObj"

) );

1672

assert(lpi !=

NULL

);

1680#if DEBUG_CHECK_DATA > 0 1681 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiScaleRow"

) );

1684

assert(scaleval != 0);

1701#if MSK_VERSION_MAJOR < 9 1702 MOSEK_CALL

( MSK_getbound(lpi->

task

, MSK_ACC_CON, row, &bkc, &blc, &buc) );

1704 MOSEK_CALL

( MSK_putbound(lpi->

task

, MSK_ACC_CON, row, bkc, blc, buc) );

1706 MOSEK_CALL

( MSK_getconbound(lpi->

task

, row, &bkc, &blc, &buc) );

1711#if DEBUG_CHECK_DATA > 0 1712 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiScaleRow"

) );

1729 double

*val =

NULL

;

1733

assert(lpi !=

NULL

);

1741#if DEBUG_CHECK_DATA > 0 1742 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiScaleCol"

) );

1745

assert(scaleval != 0);

1761#if MSK_VERSION_MAJOR < 9 1762 MOSEK_CALL

( MSK_getbound(lpi->

task

, MSK_ACC_VAR, col, &bkx, &blx, &bux) );

1764 MOSEK_CALL

( MSK_putbound(lpi->

task

, MSK_ACC_VAR, col, bkx, blx, bux) );

1766 MOSEK_CALL

( MSK_getvarbound(lpi->

task

, col, &bkx, &blx, &bux) );

1774#if DEBUG_CHECK_DATA > 0 1775 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiScaleCol"

) );

1793

assert(lpi !=

NULL

);

1796

assert(nrows !=

NULL

);

1811

assert(lpi !=

NULL

);

1814

assert(ncols !=

NULL

);

1829

assert(lpi !=

NULL

);

1832

assert(nnonz !=

NULL

);

1854

assert(lpi !=

NULL

);

1857

assert(first <= last);

1861#if DEBUG_CHECK_DATA > 0 1862 SCIP_CALL

( scip_checkdata(lpi,

"getASlice"

) );

1867#if MSK_VERSION_MAJOR <= 9 1871

assert(beg !=

NULL

);

1872

assert(ind !=

NULL

);

1873

assert(val !=

NULL

);

1877#if MSK_VERSION_MAJOR < 9 1878 MOSEK_CALL

( MSK_getaslicenumnz(lpi->

task

, iscon ? MSK_ACC_CON : MSK_ACC_VAR, first, last+1, nnonz) );

1880 MOSEK_CALL

( MSK_getaslice(lpi->

task

, iscon ? MSK_ACC_CON : MSK_ACC_VAR, first, last+1, *nnonz, &surplus, beg, lpi->

aptre

, ind, val) );

1881

assert(surplus == 0);

1885 MOSEK_CALL

( MSK_getarowslicenumnz(lpi->

task

, first, last+1, nnonz) );

1886#if MSK_VERSION_MAJOR == 9 1888 MOSEK_CALL

( MSK_getarowslice(lpi->

task

, first, last+1, *nnonz, &surplus, beg, lpi->

aptre

, ind, val) );

1889

assert(surplus == 0);

1891 MOSEK_CALL

( MSK_getarowslice(lpi->

task

, first, last+1, *nnonz, beg, lpi->

aptre

, ind, val) );

1896 MOSEK_CALL

( MSK_getacolslicenumnz(lpi->

task

, first, last+1, nnonz) );

1897#if MSK_VERSION_MAJOR == 9 1899 MOSEK_CALL

( MSK_getacolslice(lpi->

task

, first, last+1, *nnonz, &surplus, beg, lpi->

aptre

, ind, val) );

1900

assert(surplus == 0);

1902 MOSEK_CALL

( MSK_getacolslice(lpi->

task

, first, last+1, *nnonz, beg, lpi->

aptre

, ind, val) );

1908#if DEBUG_CHECK_DATA > 0 1909 SCIP_CALL

( scip_checkdata(lpi,

"getASlice"

) );

1931

assert(lpi !=

NULL

);

1936

assert(firstcol >= 0);

1937

assert(firstcol <= lastcol + 1);

1942

assert(lastcol < ncols);

1970

assert(lpi !=

NULL

);

1975

assert(firstrow >= 0);

1976

assert(firstrow <= lastrow + 1);

1981

assert(lastrow < nrows);

1987#if DEBUG_CHECK_DATA > 0 1988 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetRows"

) );

1994#if DEBUG_CHECK_DATA > 0 1995 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetRows"

) );

2008 int

namestoragesize,

2012

assert(lpi !=

NULL

);

2015

assert(colnames !=

NULL

|| namestoragesize == 0);

2016

assert(namestorage !=

NULL

|| namestoragesize == 0);

2017

assert(namestoragesize >= 0);

2018

assert(storageleft !=

NULL

);

2019

assert(firstcol >= 0);

2020

assert(firstcol <= lastcol + 1);

2025

assert(lastcol < ncols);

2029 SCIPerrorMessage

(

"SCIPlpiGetColNames() has not been implemented yet.\n"

);

2041 int

namestoragesize,

2045

assert(lpi !=

NULL

);

2048

assert(rownames !=

NULL

|| namestoragesize == 0);

2049

assert(namestorage !=

NULL

|| namestoragesize == 0);

2050

assert(namestoragesize >= 0);

2051

assert(storageleft !=

NULL

);

2052

assert(firstrow >= 0);

2053

assert(firstrow <= lastrow + 1);

2058

assert(lastrow < nrows);

2062 SCIPerrorMessage

(

"SCIPlpiGetRowNames() has not been implemented yet.\n"

);

2073

MSKobjsensee mskobjsen;

2075

assert(lpi !=

NULL

);

2078

assert(objsen !=

NULL

);

2096

assert(lpi !=

NULL

);

2099

assert(vals !=

NULL

);

2100

assert(firstcol >= 0);

2101

assert(firstcol <= lastcol + 1);

2106

assert(lastcol < ncols);

2112 MOSEK_CALL

( MSK_getcslice(lpi->

task

, firstcol, lastcol+1, vals) );

2126

assert(lpi !=

NULL

);

2129

assert(firstcol >= 0);

2130

assert(firstcol <= lastcol + 1);

2135

assert(lastcol < ncols);

2141#if DEBUG_CHECK_DATA > 0 2142 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetBounds"

) );

2145#if MSK_VERSION_MAJOR < 9 2146 MOSEK_CALL

( MSK_getboundslice(lpi->

task

, MSK_ACC_VAR, firstcol, lastcol+1,

NULL

, lbs, ubs) );

2148 MOSEK_CALL

( MSK_getvarboundslice(lpi->

task

, firstcol, lastcol+1,

NULL

, lbs, ubs) );

2163

assert(lpi !=

NULL

);

2166

assert(firstrow >= 0);

2167

assert(firstrow <= lastrow + 1);

2172

assert(lastrow < nrows);

2178#if DEBUG_CHECK_DATA > 0 2179 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetSides"

) );

2182#if MSK_VERSION_MAJOR < 9 2183 MOSEK_CALL

( MSK_getboundslice(lpi->

task

, MSK_ACC_CON, firstrow, lastrow+1,

NULL

, lhss, rhss) );

2185 MOSEK_CALL

( MSK_getconboundslice(lpi->

task

, firstrow, lastrow+1,

NULL

, lhss, rhss) );

2188#if DEBUG_CHECK_DATA > 0 2189 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetSides"

) );

2203

assert(lpi !=

NULL

);

2206

assert(val !=

NULL

);

2210#if DEBUG_CHECK_DATA > 0 2211 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetCoef"

) );

2216#if DEBUG_CHECK_DATA > 0 2217 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiGetCoef"

) );

2236

assert(lpi !=

NULL

);

2249

MSKrescodee* termcode,

2253

assert( termcode !=

NULL

);

2255#if ASSERT_ON_NUMERICAL_TROUBLES > 0 2256 if

( res == MSK_RES_TRM_MAX_NUM_SETBACKS || res == MSK_RES_TRM_NUMERICAL_PROBLEM )

2267 if

( res == MSK_RES_TRM_MAX_ITERATIONS || res == MSK_RES_TRM_MAX_TIME

2268

|| res == MSK_RES_TRM_OBJECTIVE_RANGE || res == MSK_RES_TRM_STALL )

2274

*termcode = MSK_RES_OK;

2285 int

itercount_primal;

2294

assert(lpi !=

NULL

);

2303 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, &maxiter) );

2306#if DEBUG_EASY_REPRODUCE 2307 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_AUTO_SORT_A_BEFORE_OPT, MSK_ON) );

2308 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_OFF) );

2310 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_ON) );

2313 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_AUTO_UPDATE_SOL_INFO, MSK_OFF) );

2318 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_LOG_SIM, 4) );

2319 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_LOG_SIM_FREQ, 1) );

2323 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_LOG_SIM, 4) );

2327 MOSEK_CALL

( MSK_solutiondef(lpi->

task

, MSK_SOL_BAS, &gotbasicsol) );

2331 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_PRESOLVE_USE, MSK_PRESOLVE_MODE_OFF) );

2335 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_PRESOLVE_USE, MSK_PRESOLVE_MODE_ON) );

2338#if ALWAYS_SOLVE_PRIMAL_FORM > 0 2340 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SOLVE_FORM, MSK_SOLVE_PRIMAL) );

2343#if DEBUG_CHECK_DATA > 0 2344 SCIP_CALL

( scip_checkdata(lpi,

"SolveWSimplex"

) );

2347 if

( gotbasicsol && maxiter < 20000 )

2350 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_DUAL_RESTRICT_SELECTION, 0) );

2351 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_PRIMAL_RESTRICT_SELECTION, 0) );

2360#if FORCE_NO_MAXITER > 0 2361 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, 2000000000) );

2364#if DEBUG_CHECK_DATA > 0 2365 SCIP_CALL

( scip_checkdata(lpi,

"Begin optimize with simplex"

) );

2368#if FORCE_MOSEK_SUMMARY > 1 2378#if MSK_VERSION_MAJOR < 10 2380 if

( lpi->

termcode

== MSK_RES_TRM_MAX_NUM_SETBACKS )

2384 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, &scaling) );

2385 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, MSK_SCALING_AGGRESSIVE) );

2387 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, scaling) );

2391#if FORCE_MOSEK_SUMMARY 2403#if DEBUG_CHECK_DATA > 0 2404 SCIP_CALL

( scip_checkdata(lpi,

"End optimize with simplex"

) );

2409 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, maxiter) );

2412 MOSEK_CALL

( MSK_getintinf(lpi->

task

, MSK_IINF_SIM_PRIMAL_ITER, &itercount_primal) );

2413 MOSEK_CALL

( MSK_getintinf(lpi->

task

, MSK_IINF_SIM_DUAL_ITER, &itercount_dual) );

2415

lpi->

itercount

= itercount_primal + itercount_dual;

2418 MOSEK_CALL

( MSK_getprimalobj(lpi->

task

, MSK_SOL_BAS, &pobj) );

2423 SCIPdebugMessage

(

"maxiter = %d, termcode = %d, prosta = %d, solsta = %d, objval = %g : %g, iter = %d+%d\n"

,

2424

maxiter, lpi->

termcode

, prosta, solsta, pobj, dobj, itercount_primal, itercount_dual);

2428 case

MSK_SOL_STA_OPTIMAL:

2429 case

MSK_SOL_STA_PRIM_AND_DUAL_FEAS:

2430 case

MSK_SOL_STA_PRIM_FEAS:

2431 case

MSK_SOL_STA_DUAL_FEAS:

2432 case

MSK_SOL_STA_PRIM_INFEAS_CER:

2433 case

MSK_SOL_STA_DUAL_INFEAS_CER:

2438 case

MSK_SOL_STA_UNKNOWN:

2440

assert( lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS || lpi->

termcode

== MSK_RES_TRM_MAX_TIME ||

2441

lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE || lpi->

termcode

== MSK_RES_TRM_STALL ||

2444 if

( lpi->

termcode

!= MSK_RES_TRM_MAX_ITERATIONS && lpi->

termcode

!= MSK_RES_TRM_MAX_TIME &&

2445

lpi->

termcode

!= MSK_RES_TRM_OBJECTIVE_RANGE )

2448

lpi->

termcode

= MSK_RES_TRM_NUMERICAL_PROBLEM;

2449#if ASSERT_ON_WARNING 2455#if MSK_VERSION_MAJOR < 9 2456 case

MSK_SOL_STA_NEAR_OPTIMAL:

2457 case

MSK_SOL_STA_NEAR_PRIM_FEAS:

2458 case

MSK_SOL_STA_NEAR_DUAL_FEAS:

2459 case

MSK_SOL_STA_NEAR_PRIM_AND_DUAL_FEAS:

2460 case

MSK_SOL_STA_NEAR_PRIM_INFEAS_CER:

2461 case

MSK_SOL_STA_NEAR_DUAL_INFEAS_CER:

2463

assert(lpi->

termcode

== MSK_RES_OK);

2466

lpi->

termcode

= MSK_RES_TRM_NUMERICAL_PROBLEM;

2467#if ASSERT_ON_WARNING 2473 case

MSK_SOL_STA_INTEGER_OPTIMAL:

2474#if MSK_VERSION_MAJOR < 9 2475 case

MSK_SOL_STA_NEAR_INTEGER_OPTIMAL:

2482#if ASSERT_ON_WARNING 2492 case

MSK_PRO_STA_PRIM_AND_DUAL_FEAS:

2493 case

MSK_PRO_STA_PRIM_FEAS:

2494 case

MSK_PRO_STA_DUAL_FEAS:

2495 case

MSK_PRO_STA_PRIM_AND_DUAL_INFEAS:

2496 case

MSK_PRO_STA_PRIM_INFEAS:

2497 case

MSK_PRO_STA_DUAL_INFEAS:

2498 case

MSK_PRO_STA_UNKNOWN:

2501#if MSK_VERSION_MAJOR < 9 2502 case

MSK_PRO_STA_NEAR_PRIM_AND_DUAL_FEAS:

2503 case

MSK_PRO_STA_NEAR_PRIM_FEAS:

2504 case

MSK_PRO_STA_NEAR_DUAL_FEAS:

2506 case

MSK_PRO_STA_ILL_POSED:

2507 case

MSK_PRO_STA_PRIM_INFEAS_OR_UNBOUNDED:

2508

assert(lpi->

termcode

== MSK_RES_OK);

2511

lpi->

termcode

= MSK_RES_TRM_NUMERICAL_PROBLEM;

2513#if ASSERT_ON_WARNING 2523#if ASSERT_ON_WARNING 2531#if SHOW_RELATIVE_OPTIMAL_GAP 2532 if

( solsta == MSK_SOL_STA_OPTIMAL && fabs(pobj) + fabs(dobj) > 1.0e-6 && fabs(pobj-dobj) > 0.0001*(fabs(pobj) + fabs(dobj)))

2534 SCIPerrorMessage

(

"Simplex[%d] returned optimal solution with different objvals %g != %g reldiff %.2g%%\n"

,

2535

lpi->

optimizecount

, pobj, dobj, 100.0 * fabs(pobj-dobj)/

MAX

(fabs(pobj), fabs(dobj)));

2540 if

(lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE)

2542 if

(solsta != MSK_SOL_STA_DUAL_FEAS && solsta != MSK_SOL_STA_OPTIMAL && solsta != MSK_SOL_STA_PRIM_AND_DUAL_FEAS)

2552 if

(maxiter >= 2000000000)

2554 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, maxiter) );

2556 if

(lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS)

2565#if DEBUG_DO_INTPNT_FEAS_CHECK 2566 if

(solsta == MSK_SOL_STA_PRIM_INFEAS_CER || solsta == MSK_SOL_STA_DUAL_INFEAS_CER)

2574 if

(solsta == MSK_SOL_STA_PRIM_INFEAS_CER || solsta == MSK_SOL_STA_DUAL_INFEAS_CER)

2585#if DEBUG_PRINT_STAT > 0 2586 SCIPdebugMessage

(

"Max iter stat : Count %d branchup = %d branchlo = %d primal %d dual %d\n"

,

2587

lpi->

optimizecount

, numstrongbranchmaxiterup, numstrongbranchmaxiterdo, numprimalmaxiter, numdualmaxiter);

2588 SCIPdebugMessage

(

"Objcut iter stat : Count %d branchup = %d branchlo = %d primal %d dual %d\n"

,

2589

lpi->

optimizecount

, numstrongbranchobjup, numstrongbranchobjdo, numprimalobj, numdualobj);

2592#if DEBUG_CHECK_DATA > 0 2593 SCIP_CALL

( scip_checkdata(lpi,

"SolveWSimplex"

) );

2604

assert(lpi !=

NULL

);

2612 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_ON) );

2616

MSK_SIM_HOTSTART_NONE : MSK_SIM_HOTSTART_STATUS_KEYS) );

2619#if DEBUG_CHECK_DATA > 0 2620 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiSolvePrimal"

) );

2623 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_OPTIMIZER, MSK_OPTIMIZER_PRIMAL_SIMPLEX) );

2624

lpi->

lastalgo

= MSK_OPTIMIZER_PRIMAL_SIMPLEX;

2633

MSK_writedata(lpi->

task

, fname);

2639#ifdef SCIP_DISABLED_CODE 2641 if

( lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE )

2647 if

( solsta != MSK_SOL_STA_PRIM_FEAS )

2654#if DEBUG_PRINT_STAT > 0 2655 if

(lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE)

2659#if DEBUG_PRINT_STAT > 0 2660 if

(lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS)

2664#if DEBUG_CHECK_DATA > 0 2665 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiSolvePrimal"

) );

2676

assert(lpi !=

NULL

);

2685#if (MSK_VERSION_MAJOR < 8) || (MSK_VERSION_MAJOR == 8 && MSK_VERSION_MINOR == 0) 2686 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_INTEGER, MSK_ON) );

2688 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_ON) );

2692

MSK_SIM_HOTSTART_NONE : MSK_SIM_HOTSTART_STATUS_KEYS) );

2695 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_OPTIMIZER, MSK_OPTIMIZER_DUAL_SIMPLEX) );

2696

lpi->

lastalgo

= MSK_OPTIMIZER_DUAL_SIMPLEX;

2704

MSK_writedata(lpi->

task

, fname);

2710#ifdef SCIP_DISABLED_CODE 2712 if

( lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE )

2718 if

( solsta != MSK_SOL_STA_DUAL_FEAS )

2725#if DEBUG_PRINT_STAT > 0 2726 if

(lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE)

2730#if DEBUG_PRINT_STAT > 0 2731 if

(lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS)

2747

assert(lpi !=

NULL

);

2754

lpi->

lastsolvetype

= crossover ? MSK_SOL_BAS : MSK_SOL_ITR;

2769#if DEBUG_CHECK_DATA > 0 2770 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiSolveBarrier"

) );

2773#ifdef SCIP_DISABLED_CODE 2776

MSK_SIM_HOTSTART_NONE : MSK_INTPNT_HOTSTART_PRIMAL_DUAL) );

2780 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_INTPNT_BASIS, crossover ? MSK_BI_ALWAYS : MSK_BI_NEVER) );

2781 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_OPTIMIZER, MSK_OPTIMIZER_INTPNT) );

2782

lpi->

lastalgo

= MSK_OPTIMIZER_INTPNT;

2784#if MSK_VERSION_MAJOR >= 9 2785 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_INTPNT_CO_TOL_NEAR_REL, NEAR_REL_TOLERANCE) );

2795

MSK_writedata(lpi->

task

, fname);

2801#if DEBUG_PRINT_STAT > 0 2802 if

(lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS)

2809 SCIPdebugMessage

(

"termcode = %d, prosta = %d, solsta = %d, iter = %d\n"

,

2814 case

MSK_SOL_STA_OPTIMAL:

2815 case

MSK_SOL_STA_PRIM_AND_DUAL_FEAS:

2816 case

MSK_SOL_STA_PRIM_FEAS:

2817 case

MSK_SOL_STA_DUAL_FEAS:

2818 case

MSK_SOL_STA_PRIM_INFEAS_CER:

2819 case

MSK_SOL_STA_DUAL_INFEAS_CER:

2823 case

MSK_SOL_STA_UNKNOWN:

2824#if MSK_VERSION_MAJOR < 9 2825 case

MSK_SOL_STA_NEAR_OPTIMAL:

2826 case

MSK_SOL_STA_NEAR_PRIM_FEAS:

2827 case

MSK_SOL_STA_NEAR_DUAL_FEAS:

2828 case

MSK_SOL_STA_NEAR_PRIM_AND_DUAL_FEAS:

2829 case

MSK_SOL_STA_NEAR_PRIM_INFEAS_CER:

2830 case

MSK_SOL_STA_NEAR_DUAL_INFEAS_CER:

2835

lpi->

termcode

= MSK_RES_TRM_NUMERICAL_PROBLEM;

2837#if ASSERT_ON_WARNING 2841 case

MSK_SOL_STA_INTEGER_OPTIMAL:

2842#if MSK_VERSION_MAJOR < 9 2843 case

MSK_SOL_STA_NEAR_INTEGER_OPTIMAL:

2850#if ASSERT_ON_WARNING 2859 case

MSK_PRO_STA_PRIM_AND_DUAL_FEAS:

2860 case

MSK_PRO_STA_PRIM_FEAS:

2861 case

MSK_PRO_STA_DUAL_FEAS:

2862 case

MSK_PRO_STA_PRIM_AND_DUAL_INFEAS:

2863 case

MSK_PRO_STA_PRIM_INFEAS:

2864 case

MSK_PRO_STA_DUAL_INFEAS:

2866 case

MSK_PRO_STA_UNKNOWN:

2867#if MSK_VERSION_MAJOR < 9 2868 case

MSK_PRO_STA_NEAR_PRIM_AND_DUAL_FEAS:

2869 case

MSK_PRO_STA_NEAR_PRIM_FEAS:

2870 case

MSK_PRO_STA_NEAR_DUAL_FEAS:

2872 case

MSK_PRO_STA_ILL_POSED:

2873 case

MSK_PRO_STA_PRIM_INFEAS_OR_UNBOUNDED:

2877

lpi->

termcode

= MSK_RES_TRM_NUMERICAL_PROBLEM;

2881#if ASSERT_ON_WARNING 2890#if ASSERT_ON_WARNING 2897#if DEBUG_CHECK_DATA > 0 2898 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiSolveBarrier"

) );

2909

assert(lpi !=

NULL

);

2922

assert(lpi !=

NULL

);

2949

MSKobjsensee objsen;

2963

assert(lpi !=

NULL

);

2969#if DEBUG_CHECK_DATA > 0 2970 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiStrongbranch"

) );

2984 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, &olditerlim) );

2985 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_DUAL_SELECTION, &oldselection) );

2986 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART, &oldhotstart) );

2988 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, itlim) );

2991 if

(objsen == MSK_OBJECTIVE_SENSE_MINIMIZE)

3000#if MSK_VERSION_MAJOR < 9 3001 MOSEK_CALL

( MSK_getbound(lpi->

task

, MSK_ACC_VAR, col, &bkx, &blx, &bux) );

3003 MOSEK_CALL

( MSK_getvarbound(lpi->

task

, col, &bkx, &blx, &bux) );

3008

newub =

EPSCEIL

(psol-1.0, 1e-06);

3010 if

(newub < blx - 0.5)

3021 else if

(

EPSEQ

(blx, newub,1.0e-6))

3029#if MSK_VERSION_MAJOR < 9 3030 MOSEK_CALL

( MSK_putbound(lpi->

task

, MSK_ACC_VAR, col, newbk, blx, newub) );

3032 MOSEK_CALL

( MSK_putvarbound(lpi->

task

, col, newbk, blx, newub) );

3042

*downvalid =

FALSE

;

3049

*downvalid =

FALSE

;

3067

*downvalid =

FALSE

;

3075#if DEBUG_PRINT_STAT > 0 3076 if

(lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE)

3077

++numstrongbranchobjup;

3079 if

(lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS)

3080

++numstrongbranchmaxiterup;

3085#if MSK_VERSION_MAJOR < 9 3086 MOSEK_CALL

( MSK_putbound(lpi->

task

, MSK_ACC_VAR, col, bkx, blx, bux) );

3092

newlb =

EPSFLOOR

(psol+1.0, 1e-06);

3093 if

(newlb > bux + 0.5)

3104 else if

(

EPSEQ

(bux, newlb,1.0e-6))

3112#if MSK_VERSION_MAJOR < 9 3113 MOSEK_CALL

( MSK_putbound(lpi->

task

, MSK_ACC_VAR, col, newbk, newlb, bux) );

3115 MOSEK_CALL

( MSK_putvarbound(lpi->

task

, col, newbk, newlb, bux) );

3155#if DEBUG_PRINT_STAT > 0 3156 if

(lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE)

3157

++numstrongbranchobjdo;

3159 if

(lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS)

3160

++numstrongbranchmaxiterdo;

3164#if MSK_VERSION_MAJOR < 9 3165 MOSEK_CALL

( MSK_putbound(lpi->

task

, MSK_ACC_VAR, col, bkx, blx, bux) );

3169 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, olditerlim) );

3170 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_DUAL_SELECTION, oldselection) );

3171 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART, oldhotstart) );

3180#if DEBUG_CHECK_DATA > 0 3181 SCIP_CALL

( scip_checkdata(lpi,

"SCIPlpiStrongbranch"

) );

3234

assert( cols !=

NULL

);

3235

assert( psols !=

NULL

);

3236

assert( down !=

NULL

);

3237

assert( up !=

NULL

);

3238

assert( downvalid !=

NULL

);

3239

assert( upvalid !=

NULL

);

3240

assert( down !=

NULL

);

3245 for

(j = 0; j < ncols; ++j)

3298

assert( cols !=

NULL

);

3299

assert( psols !=

NULL

);

3300

assert( down !=

NULL

);

3301

assert( up !=

NULL

);

3302

assert( downvalid !=

NULL

);

3303

assert( upvalid !=

NULL

);

3304

assert( down !=

NULL

);

3309 for

(j = 0; j < ncols; ++j)

3328

assert(lpi !=

NULL

);

3351

assert( lpi !=

NULL

);

3354

assert( primalfeasible !=

NULL

);

3355

assert( dualfeasible !=

NULL

);

3363 case

MSK_PRO_STA_PRIM_AND_DUAL_FEAS:

3364

*primalfeasible =

TRUE

;

3365

*dualfeasible =

TRUE

;

3367 case

MSK_PRO_STA_PRIM_FEAS:

3368

*primalfeasible =

TRUE

;

3369

*dualfeasible =

FALSE

;

3371 case

MSK_PRO_STA_DUAL_FEAS:

3372

*primalfeasible =

FALSE

;

3373

*dualfeasible =

TRUE

;

3375 case

MSK_PRO_STA_DUAL_INFEAS:

3377

*primalfeasible = (lpi->

lastalgo

== MSK_OPTIMIZER_PRIMAL_SIMPLEX);

3378

*dualfeasible =

FALSE

;

3380 case

MSK_PRO_STA_UNKNOWN:

3381 case

MSK_PRO_STA_PRIM_INFEAS:

3382 case

MSK_PRO_STA_PRIM_AND_DUAL_INFEAS:

3383 case

MSK_PRO_STA_ILL_POSED:

3384#if MSK_VERSION_MAJOR < 9 3385 case

MSK_PRO_STA_NEAR_PRIM_AND_DUAL_FEAS:

3386 case

MSK_PRO_STA_NEAR_PRIM_FEAS:

3387 case

MSK_PRO_STA_NEAR_DUAL_FEAS:

3389 case

MSK_PRO_STA_PRIM_INFEAS_OR_UNBOUNDED:

3390

*primalfeasible =

FALSE

;

3391

*dualfeasible =

FALSE

;

3410

assert(lpi !=

NULL

);

3418 return

( solsta == MSK_SOL_STA_DUAL_INFEAS_CER

3419

|| prosta == MSK_PRO_STA_DUAL_INFEAS

3420

|| prosta == MSK_PRO_STA_PRIM_AND_DUAL_INFEAS );

3432

assert(lpi !=

NULL

);

3440 return

(solsta == MSK_SOL_STA_DUAL_INFEAS_CER);

3450

assert(lpi !=

NULL

);

3457 return

(solsta == MSK_SOL_STA_DUAL_INFEAS_CER && lpi->

lastalgo

== MSK_OPTIMIZER_PRIMAL_SIMPLEX);

3465

assert(lpi !=

NULL

);

3479

assert(lpi !=

NULL

);

3487 return

(prosta == MSK_PRO_STA_PRIM_FEAS || prosta == MSK_PRO_STA_PRIM_AND_DUAL_FEAS || (prosta == MSK_PRO_STA_DUAL_INFEAS && lpi->

lastalgo

== MSK_OPTIMIZER_PRIMAL_SIMPLEX));

3500

assert(lpi !=

NULL

);

3508 return

( solsta == MSK_SOL_STA_PRIM_INFEAS_CER

3509

|| prosta == MSK_PRO_STA_PRIM_INFEAS

3510

|| prosta == MSK_PRO_STA_PRIM_AND_DUAL_INFEAS );

3522

assert(lpi !=

NULL

);

3530 return

(solsta == MSK_SOL_STA_PRIM_INFEAS_CER);

3538

assert(lpi !=

NULL

);

3550

assert(lpi !=

NULL

);

3564

assert(lpi !=

NULL

);

3572 return

(prosta == MSK_PRO_STA_DUAL_FEAS || prosta == MSK_PRO_STA_PRIM_AND_DUAL_FEAS);

3582

assert(lpi !=

NULL

);

3590 return

(solsta == MSK_SOL_STA_OPTIMAL);

3604

assert(lpi !=

NULL

);

3612

MSKobjsensee objsen;

3617

res = MSK_getobjsense(lpi->

task

, &objsen);

3618 if

( res != MSK_RES_OK )

3621 if

( objsen == MSK_OBJECTIVE_SENSE_MINIMIZE )

3623

res = MSK_getdouparam(lpi->

task

, MSK_DPAR_UPPER_OBJ_CUT, &objlimit);

3627

res = MSK_getdouparam(lpi->

task

, MSK_DPAR_LOWER_OBJ_CUT, &objlimit);

3629 if

( res != MSK_RES_OK )

3632 if

( lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE )

3635

res = MSK_getdouparam(lpi->

task

, MSK_DPAR_UPPER_OBJ_CUT, &objvalue);

3642 if

( res != MSK_RES_OK )

3645 if

( objsen == MSK_OBJECTIVE_SENSE_MAXIMIZE )

3654 return

( lpi->

termcode

== MSK_RES_OK

3655

|| lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS

3656

|| lpi->

termcode

== MSK_RES_TRM_MAX_TIME

3657

|| lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE );

3665

assert(lpi !=

NULL

);

3669 return

( lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE );

3677

assert(lpi !=

NULL

);

3681 return

( lpi->

termcode

== MSK_RES_TRM_MAX_ITERATIONS );

3689

assert(lpi !=

NULL

);

3693 return

( lpi->

termcode

== MSK_RES_TRM_MAX_TIME );

3704

assert(lpi !=

NULL

);

3714 return

(

int

) solsta;

3723

assert(lpi !=

NULL

);

3726

assert(success !=

NULL

);

3741

assert(lpi !=

NULL

);

3744

assert(objval !=

NULL

);

3750 if

( lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE )

3753 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_UPPER_OBJ_CUT, objval) );

3779 double

* sux =

NULL

;

3783

assert(lpi !=

NULL

);

3789 if

( objval !=

NULL

)

3791 if

( lpi->

termcode

== MSK_RES_TRM_OBJECTIVE_RANGE )

3794 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_UPPER_OBJ_CUT, objval) );

3809 if

( primsol !=

NULL

&& lpi->

lastalgo

== MSK_OPTIMIZER_PRIMAL_SIMPLEX )

3815 if

( solsta == MSK_SOL_STA_DUAL_INFEAS_CER )

3824 for

(j = 0; j < ncols; ++j)

3852

primsol, dualsol,

NULL

,

NULL

, redcost, sux,

NULL

) );

3858

primsol, dualsol,

NULL

,

NULL

, redcost, sux,

NULL

) );

3864 for

( i = 0; i < ncols; i++ )

3866

assert(sux !=

NULL

);

3867

redcost[i] -= sux[i];

3881

assert(lpi !=

NULL

);

3884

assert(ray !=

NULL

);

3900

assert(lpi !=

NULL

);

3903

assert(dualfarkas !=

NULL

);

3907 MOSEK_CALL

( MSK_getsolution(lpi->

task

, lpi->

lastsolvetype

,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

, dualfarkas,

3919

assert(lpi !=

NULL

);

3922

assert(iterations !=

NULL

);

3942

assert(lpi !=

NULL

);

3945

assert(quality !=

NULL

);

3961 if

(res == MSK_RES_ERR_BASIS_SINGULAR)

3997 for

( i = 0; i < n; i++ )

4011#if MSK_VERSION_MAJOR < 9 4012 MOSEK_CALL

( MSK_getsolutioni(lpi->

task

, iscon ? MSK_ACC_CON : MSK_ACC_VAR, i, MSK_SOL_BAS,

NULL

,

NULL

, &sl, &su,

NULL

) );

4016 MOSEK_CALL

( MSK_getslcslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &sl ) );

4017 MOSEK_CALL

( MSK_getsucslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &su ) );

4021 MOSEK_CALL

( MSK_getslxslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &sl ) );

4022 MOSEK_CALL

( MSK_getsuxslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &su ) );

4043#if MSK_VERSION_MAJOR < 10 4073 for

( i = 0; i < m; i++ )

4086#if MSK_VERSION_MAJOR < 9 4087 MOSEK_CALL

( MSK_getsolutioni(lpi->

task

, iscon ? MSK_ACC_CON : MSK_ACC_VAR, i, MSK_SOL_BAS,

NULL

,

NULL

, &sl, &su,

NULL

) );

4091 MOSEK_CALL

( MSK_getslcslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &sl ) );

4092 MOSEK_CALL

( MSK_getsucslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &su ) );

4096 MOSEK_CALL

( MSK_getslxslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &sl ) );

4097 MOSEK_CALL

( MSK_getsuxslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &su ) );

4114#if MSK_VERSION_MAJOR < 10 4135 for

( i = 0; i < n; i++ )

4140

resstat[i] = MSK_SK_LOW;

4143

resstat[i] = MSK_SK_BAS;

4146

resstat[i] = MSK_SK_UPR;

4149

resstat[i] = MSK_SK_SUPBAS;

4168 for

( i = 0; i < n; i++ )

4173

resstat[i] = MSK_SK_UPR;

4176

resstat[i] = MSK_SK_BAS;

4179

resstat[i] = MSK_SK_LOW;

4182

resstat[i] = MSK_SK_SUPBAS;

4203

assert(lpi !=

NULL

);

4238

assert(lpi !=

NULL

);

4245

assert(cstat !=

NULL

|| ncols == 0);

4246

assert(rstat !=

NULL

|| nrows == 0);

4271

assert(lpi !=

NULL

);

4274

assert(bind !=

NULL

);

4282 for

(i = 0; i < nrows; i++ )

4284 if

(bind[i] < nrows)

4285

bind[i] = -1 - bind[i];

4287

bind[i] = bind[i] - nrows;

4315

assert(lpi !=

NULL

);

4318

assert(coef !=

NULL

);

4325 MOSEK_CALL

( MSK_putnaintparam(lpi->

task

, MSK_IPAR_BASIS_SOLVE_USE_PLUS_ONE_, MSK_ON) );

4331 for

(i = 0; i < nrows; ++i)

4336 if

( ninds !=

NULL

&& inds !=

NULL

)

4342#if MSK_VERSION_MAJOR < 10 4343 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 1, ninds, inds, coef) );

4345 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 1, *ninds, inds, coef, ninds) );

4347

assert( *ninds <= nrows );

4360#if MSK_VERSION_MAJOR < 10 4361 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 1, &numnz, sub, coef) );

4363 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 1, numnz, sub, coef, &numnz) );

4365

assert( numnz <= nrows );

4369 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_ON) );

4402

assert(lpi !=

NULL

);

4405

assert(coef !=

NULL

);

4412 MOSEK_CALL

( MSK_putnaintparam(lpi->

task

, MSK_IPAR_BASIS_SOLVE_USE_PLUS_ONE_, MSK_ON) );

4418 for

(i = 0; i < nrows; ++i)

4423 if

( ninds !=

NULL

&& inds !=

NULL

)

4428#if MSK_VERSION_MAJOR < 10 4429 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, ninds, inds, coef) );

4431 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, *ninds, inds, coef, ninds) );

4433

assert( *ninds <= nrows );

4445#if MSK_VERSION_MAJOR < 10 4446 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, &numnz, sub, coef) );

4448 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, numnz, sub, coef, &numnz) );

4450

assert( numnz <= nrows );

4454 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_ON) );

4489

assert(lpi !=

NULL

);

4492

assert(coef !=

NULL

);

4498 if

( ninds !=

NULL

)

4507 if

( binvrow ==

NULL

)

4519 for

(i = 0; i < ncols; ++i)

4525 for

(k = 0; k < numnz; ++k)

4527

assert( 0 <= csub[k] && csub[k] < nrows );

4528

coef[i] += binv[csub[k]] * cval[k];

4562

assert(lpi !=

NULL

);

4565

assert(coef !=

NULL

);

4574 MOSEK_CALL

( MSK_putnaintparam(lpi->

task

, MSK_IPAR_BASIS_SOLVE_USE_PLUS_ONE_, MSK_ON) );

4580 for

(i = 0; i < nrows; ++i)

4584 if

( ninds !=

NULL

&& inds !=

NULL

)

4588 for

(i = 0; i < numnz; ++i)

4590

assert( 0 <= inds[i] && inds[i] < nrows );

4591

coef[inds[i]] = val[i];

4596#if MSK_VERSION_MAJOR < 10 4597 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, ninds, inds, coef) );

4599 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, *ninds, inds, coef, ninds) );

4601

assert( *ninds <= nrows );

4610 for

(i = 0; i < numnz; ++i)

4612

assert( 0 <= sub[i] && sub[i] < nrows );

4613

coef[sub[i]] = val[i];

4616#if MSK_VERSION_MAJOR < 10 4617 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, &numnz, sub, coef) );

4619 MOSEK_CALL

( MSK_solvewithbasis(lpi->

task

, 0, numnz, sub, coef, &numnz) );

4622 if

( ninds !=

NULL

)

4629 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_HOTSTART_LU, MSK_ON) );

4648

assert(lpistate !=

NULL

);

4649

assert(blkmem !=

NULL

);

4657

(*lpistate)->solsta = MSK_SOL_STA_UNKNOWN;

4658

(*lpistate)->num = -1;

4659

(*lpistate)->ncols = ncols;

4660

(*lpistate)->nrows = nrows;

4672

assert(blkmem !=

NULL

);

4673

assert(lpistate !=

NULL

);

4674

assert(*lpistate !=

NULL

);

4697

assert(lpi !=

NULL

);

4708 for

( i = 0; i < n; i++ )

4719#if MSK_VERSION_MAJOR < 9 4720 MOSEK_CALL

( MSK_getsolutioni(lpi->

task

, isrow ? MSK_ACC_CON : MSK_ACC_VAR, i, MSK_SOL_BAS,

NULL

,

NULL

, &sl, &su,

NULL

) );

4724 MOSEK_CALL

( MSK_getslcslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &sl ) );

4725 MOSEK_CALL

( MSK_getsucslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &su ) );

4729 MOSEK_CALL

( MSK_getslxslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &sl ) );

4730 MOSEK_CALL

( MSK_getsuxslice(lpi->

task

, MSK_SOL_BAS, i, i+1, &su ) );

4768

assert(lpi !=

NULL

);

4788 int

*skxi = (

int

*) lpi->

skx

;

4789 int

*skci = (

int

*) lpi->

skc

;

4791

assert(

sizeof

(

int

) ==

sizeof

(MSKstakeye));

4792

assert(lpi !=

NULL

);

4793

assert(lpistate !=

NULL

);

4813

assert(

sizeof

(

int

) ==

sizeof

(MSKstakeye));

4836

assert(lpi !=

NULL

);

4839

assert(lpistate !=

NULL

);

4840

assert(blkmem !=

NULL

);

4847 MOSEK_CALL

( MSK_solutiondef(lpi->

task

, MSK_SOL_BAS, &gotbasicsol) );

4892

assert(lpi !=

NULL

);

4895

assert(blkmem !=

NULL

);

4896#ifdef SCIP_DISABLED_CODE 4900 if

(lpistate ==

NULL

)

4906 if

(lpistate->

nrows

== 0 || lpistate->

ncols

== 0)

4911

assert(lpistate->

nrows

<= nrows);

4912

assert(lpistate->

ncols

<= ncols);

4916#ifdef SCIP_DISABLED_CODE 4923 for

(i = lpistate->

ncols

; i < ncols; ++i)

4927#if MSK_VERSION_MAJOR < 9 4936

lpi->

skx

[i] = MSK_SK_SUPBAS;

4938

lpi->

skx

[i] = MSK_SK_UPR;

4941

lpi->

skx

[i] = MSK_SK_LOW;

4943 for

(i = lpistate->

nrows

; i < nrows; ++i)

4944

lpi->

skc

[i] = MSK_SK_BAS;

4961

assert(lpi !=

NULL

);

4977

assert(lpi !=

NULL

);

4980

assert(lpistate !=

NULL

);

4981

assert(blkmem !=

NULL

);

4985 if

( *lpistate !=

NULL

)

4999

assert(lpi !=

NULL

);

5005 return

( lpistate !=

NULL

&& lpistate->

num

>= 0);

5017

assert(lpi !=

NULL

);

5020

assert(fname !=

NULL

);

5026 MOSEK_CALL

( MSK_readsolution(lpi->

task

, MSK_SOL_BAS, fname) );

5044

assert(lpi !=

NULL

);

5047

assert(fname !=

NULL

);

5054 SCIPdebugMessage

(

"No LP state written, since it was cleared after the last solve \n"

);

5063 for

( v = 0; v < nvars; v++ )

5066 if

( strcmp(name,

""

) == 0 )

5075 for

( c = 0; c < nconss; c++ )

5078 if

( strcmp(name,

""

) == 0 )

5089 " names instead. Note that this state cannot be read back in later!\n"

,

5090

v < nvars ?

"variable"

:

"constraint"

, v < nvars ? v : c);

5094 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_WRITE_SOL_HEAD, MSK_ON) );

5095 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_WRITE_SOL_VARIABLES, MSK_ON) );

5096 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_WRITE_SOL_CONSTRAINTS, MSK_ON) );

5098 MOSEK_CALL

( MSK_writesolution(lpi->

task

, MSK_SOL_BAS, fname) );

5121

assert(lpi !=

NULL

);

5124

assert(lpinorms !=

NULL

);

5125

assert(blkmem !=

NULL

);

5127

(*lpinorms) =

NULL

;

5141

assert(lpi !=

NULL

);

5143

assert(lpinorms ==

NULL

);

5156

assert(lpi !=

NULL

);

5158

assert(lpinorms ==

NULL

);

5172 "SCIP_LPPAR_FROMSCRATCH"

,

5173 "SCIP_LPPAR_FASTMIP"

,

5174 "SCIP_LPPAR_SCALING"

,

5175 "SCIP_LPPAR_PRESOLVING"

,

5176 "SCIP_LPPAR_PRICING"

,

5177 "SCIP_LPPAR_LPINFO"

,

5178 "SCIP_LPPAR_FEASTOL"

,

5179 "SCIP_LPPAR_DUALFEASTOL"

,

5180 "SCIP_LPPAR_BARRIERCONVTOL"

,

5181 "SCIP_LPPAR_OBJLIM"

,

5182 "SCIP_LPPAR_LPITLIM"

,

5183 "SCIP_LPPAR_LPTILIM"

,

5184 "SCIP_LPPAR_MARKOWITZ"

,

5185 "SCIP_LPPAR_ROWREPSWITCH"

,

5187 "SCIP_LPPAR_THREADS"

,

5188 "SCIP_LPPAR_CONDITIONLIMIT"

,

5189 "SCIP_LPPAR_TIMING"

,

5190 "SCIP_LPPAR_RANDOMSEED"

,

5191 "SCIP_LPPAR_POLISHING"

,

5192 "SCIP_LPPAR_REFACTOR" 5234

assert(lpi !=

NULL

);

5237

assert(ival !=

NULL

);

5252 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_PRESOLVE_USE, ival) );

5253

*ival = (*ival != MSK_PRESOLVE_MODE_OFF);

5259

*ival = (int) lpi->

lpinfo

;

5262 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, ival) );

5265 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_NUM_THREADS, ival) );

5268 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_SIM_REFACTOR_FREQ, ival) );

5284 static int

pricing[7] =

5286

(int)MSK_SIM_SELECTION_SE,

5287

(

int

)MSK_SIM_SELECTION_FREE,

5288

(int)MSK_SIM_SELECTION_FULL,

5289

(

int

)MSK_SIM_SELECTION_PARTIAL,

5290

(int)MSK_SIM_SELECTION_SE,

5291

(

int

)MSK_SIM_SELECTION_ASE,

5292

(int)MSK_SIM_SELECTION_DEVEX,

5304

assert(lpi !=

NULL

);

5318

assert( ival >= 0 && ival <= 2 );

5322 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, MSK_SCALING_NONE) );

5323 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_INTPNT_SCALING, MSK_SCALING_NONE) );

5325#if MSK_VERSION_MAJOR < 10 5326 else if

( ival == 1 )

5328 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, MSK_SCALING_FREE) );

5329 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_INTPNT_SCALING, MSK_SCALING_FREE) );

5333 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, MSK_SCALING_AGGRESSIVE) );

5334 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_INTPNT_SCALING, MSK_SCALING_AGGRESSIVE) );

5339 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_SCALING, MSK_SCALING_FREE) );

5340 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_INTPNT_SCALING, MSK_SCALING_FREE) );

5347

ival ? MSK_PRESOLVE_MODE_FREE : MSK_PRESOLVE_MODE_OFF) );

5353 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_PRIMAL_SELECTION, pricing[ival]) );

5354 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_DUAL_SELECTION, pricing[ival]) );

5368 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_LOG, ival ? 4 : MSK_OFF) );

5369 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_LOG_SIM, ival ? 4 : MSK_OFF) );

5374#if DEBUG_PARAM_SETTING 5381

assert( ival >= 0 );

5382 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_MAX_ITERATIONS, ival) );

5386 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_NUM_THREADS, ival) );

5390 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_SIM_REFACTOR_FREQ, ival) );

5406

assert(lpi !=

NULL

);

5409

assert(dval !=

NULL

);

5416 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_BASIS_TOL_X, dval) );

5419 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_BASIS_TOL_S, dval) );

5422 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_INTPNT_TOL_REL_GAP, dval) );

5426

MSKobjsensee objsen;

5428 if

(objsen == MSK_OBJECTIVE_SENSE_MINIMIZE)

5430 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_UPPER_OBJ_CUT, dval) );

5434 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_LOWER_OBJ_CUT, dval) );

5439 MOSEK_CALL

( MSK_getdouparam(lpi->

task

, MSK_DPAR_OPTIMIZER_MAX_TIME, dval) );

5456

assert(lpi !=

NULL

);

5467

assert( dval > 0.0 );

5472 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_BASIS_TOL_X, dval) );

5475

assert( dval > 0.0 );

5480 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_BASIS_TOL_S, dval) );

5484

assert( dval >= 0.0 );

5488 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_INTPNT_TOL_REL_GAP, dval) );

5493

MSKobjsensee objsen;

5495 if

(objsen == MSK_OBJECTIVE_SENSE_MINIMIZE)

5497 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_UPPER_OBJ_CUT, dval) );

5501 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_LOWER_OBJ_CUT, dval) );

5506

assert( dval > 0.0 );

5511 MOSEK_CALL

( MSK_putdouparam(lpi->

task

, MSK_DPAR_OPTIMIZER_MAX_TIME, dval) );

5528

assert(lpi !=

NULL

);

5544

assert(lpi !=

NULL

);

5548 return

MSK_INFINITY;

5557

assert(lpi !=

NULL

);

5576#if MSK_VERSION_MAJOR < 9 5580

assert(lpi !=

NULL

);

5583

assert(fname !=

NULL

);

5587#if MSK_VERSION_MAJOR < 9 5588 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_READ_DATA_FORMAT, &olddataformat) );

5589 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_READ_DATA_FORMAT, MSK_DATA_FORMAT_LP) );

5591 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_READ_DATA_FORMAT, olddataformat) );

5593 MOSEK_CALL

( MSK_readdataformat(lpi->

task

, fname, MSK_DATA_FORMAT_LP, MSK_COMPRESS_FREE) );

5605#if MSK_VERSION_MAJOR < 9 5609

assert(lpi !=

NULL

);

5612

assert(fname !=

NULL

);

5613#if MSK_VERSION_MAJOR >= 9 5615

assert(strstr(fname,

".lp"

) !=

NULL

);

5620#if MSK_VERSION_MAJOR < 9 5621 MOSEK_CALL

( MSK_getintparam(lpi->

task

, MSK_IPAR_WRITE_DATA_FORMAT, &olddataformat) );

5622 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_WRITE_DATA_FORMAT, MSK_DATA_FORMAT_LP) );

5624 MOSEK_CALL

( MSK_putintparam(lpi->

task

, MSK_IPAR_WRITE_DATA_FORMAT, olddataformat) );

void SCIPdecodeDualBit(const SCIP_DUALPACKET *inp, int *out, int count)

void SCIPencodeDualBit(const int *inp, SCIP_DUALPACKET *out, int count)

packing single and dual bit values

unsigned int SCIP_DUALPACKET

SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)

SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)

SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)

static SCIP_RETCODE convertstat_mosek2scip_slack(SCIP_LPI *lpi, SCIP_Bool iscon, MSKstakeye *sk, int m, int *stat)

SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)

SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiChgObjsen(SCIP_LPI *lpi, SCIP_OBJSEN objsen)

static void lpistateUnpack(const SCIP_LPISTATE *lpistate, MSKstakeye *skx, MSKstakeye *skc)

SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)

SCIP_RETCODE SCIPlpiClear(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)

static SCIP_RETCODE getSolutionStatus(SCIP_LPI *lpi, MSKprostae *prosta, MSKsolstae *solsta)

SCIP_Bool SCIPlpiExistsDualRay(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)

SCIP_RETCODE SCIPlpiReadState(SCIP_LPI *lpi, const char *fname)

SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

static MSKrescodee filterTRMrescode(SCIP_MESSAGEHDLR *messagehdlr, MSKrescodee *termcode, MSKrescodee res)

SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)

SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)

SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)

SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)

SCIP_Bool SCIPlpiIsDualInfeasible(SCIP_LPI *lpi)

static SCIP_RETCODE checkState1(SCIP_LPI *lpi, int n, MSKstakeye *sk, SCIP_Bool isrow)

static SCIP_RETCODE lpistatePack(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)

static SCIP_RETCODE SolveWSimplex(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)

static SCIP_RETCODE checkState(SCIP_LPI *lpi, int ncols, int nrows)

SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)

SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)

SCIP_RETCODE SCIPlpiGetNNonz(SCIP_LPI *lpi, int *nnonz)

SCIP_Bool SCIPlpiHasPrimalSolve(void)

SCIP_RETCODE SCIPlpiStrongbranchInt(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)

SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)

SCIP_Bool SCIPlpiHasBarrierSolve(void)

SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)

SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)

SCIP_RETCODE SCIPlpiScaleCol(SCIP_LPI *lpi, int col, SCIP_Real scaleval)

int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)

static void lpistateFree(SCIP_LPISTATE **lpistate, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)

static SCIP_RETCODE getASlice(SCIP_LPI *lpi, SCIP_Bool iscon, int first, int last, int *nnonz, int *beg, int *ind, double *val)

SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)

SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)

SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)

SCIP_RETCODE SCIPlpiWriteState(SCIP_LPI *lpi, const char *fname)

SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)

static SCIP_RETCODE handle_singular(SCIP_LPI *lpi, int *basis, MSKrescodee res)

SCIP_RETCODE SCIPlpiStrongbranchesFrac(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)

SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)

SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiReadLP(SCIP_LPI *lpi, const char *fname)

SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)

SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)

SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)

SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)

const char * SCIPlpiGetSolverName(void)

SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)

SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)

SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)

static SCIP_RETCODE SCIPlpiStrongbranch(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)

SCIP_RETCODE SCIPlpiGetCols(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lb, SCIP_Real *ub, int *nnonz, int *beg, int *ind, SCIP_Real *val)

SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)

SCIP_RETCODE SCIPlpiGetColNames(SCIP_LPI *lpi, int firstcol, int lastcol, char **colnames, char *namestorage, int namestoragesize, int *storageleft)

SCIP_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int row, const SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)

SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)

SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)

const char * SCIPlpiGetSolverDesc(void)

SCIP_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)

static void convertstat_scip2mosek(const int *stat, int n, MSKstakeye *resstat)

SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetRowNames(SCIP_LPI *lpi, int firstrow, int lastrow, char **rownames, char *namestorage, int namestoragesize, int *storageleft)

SCIP_Bool SCIPlpiHasDualSolve(void)

SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)

SCIP_RETCODE SCIPlpiStrongbranchesInt(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)

SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)

SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)

SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)

SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)

SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

static SCIP_RETCODE lpistateCreate(SCIP_LPISTATE **lpistate, BMS_BLKMEM *blkmem, int ncols, int nrows)

SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiLoadColLP(SCIP_LPI *lpi, SCIP_OBJSEN objsen, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)

SCIP_Bool SCIPlpiIsDualUnbounded(SCIP_LPI *lpi)

static SCIP_RETCODE convertstat_mosek2scip(SCIP_LPI *lpi, SCIP_Bool iscon, MSKstakeye *sk, int n, int *stat)

SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)

SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)

SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)

static void convertstat_scip2mosek_slack(const int *stat, int n, MSKstakeye *resstat)

void * SCIPlpiGetSolverPointer(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)

SCIP_RETCODE SCIPlpiGetObjsen(SCIP_LPI *lpi, SCIP_OBJSEN *objsen)

SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)

SCIP_RETCODE SCIPlpiInterrupt(SCIP_LPI *lpi, SCIP_Bool interrupt)

SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)

SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)

SCIP_RETCODE SCIPlpiScaleRow(SCIP_LPI *lpi, int row, SCIP_Real scaleval)

SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)

SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)

SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)

interface methods for specific LP solvers

SCIP_DUALPACKET ROWPACKET

SCIP_DUALPACKET COLPACKET

static SCIP_RETCODE getIndicesRange(int first, int last, int **sub)

static void MSKAPI printstr(MSKuserhandle_t handle, const char *str)

static SCIP_RETCODE getEndptrs(int n, const int *beg, int nnonz, MSKint32t *aptre)

#define MOSEK_relDiff(val1, val2)

static SCIP_RETCODE setbase(SCIP_LPI *lpi)

static void generateMskBoundkeys(int n, const double *lb, const double *ub, MSKboundkeye *bk)

static int rowpacketNum(int nrows)

static const char * paramname[]

static SCIP_RETCODE getbase(SCIP_LPI *lpi, int ncols, int nrows)

static SCIP_RETCODE ensureBkxMem(SCIP_LPI *lpi, int ncols)

#define DEBUG_CHECK_STATE_TOL

static MSKenv_t reusemosekenv

SCIP_DUALPACKET ROWPACKET

static void scale_bound(MSKboundkeye *bk, double *bl, double *bu, double s)

static SCIP_RETCODE ensureAptreMem(SCIP_LPI *lpi, int n)

#define SCIP_ABORT_FALSE(x)

enum MSKoptimizertype_enum MSKoptimizertype

SCIP_DUALPACKET COLPACKET

static SCIP_RETCODE getIndicesFromDense(int *dstat, int n, int *count, int **sub)

#define SENSE2MOSEK(objsen)

static void scale_vec(int len, double *vec, double s)

static int colpacketNum(int ncols)

static const char * paramty2str(SCIP_LPPARAM type)

#define STRONGBRANCH_PRICING

static SCIP_RETCODE ensureStateMem(SCIP_LPI *lpi, int ncols, int nrows)

static MSKrescodee MSK_getsolutionstatus(MSKtask_t task, MSKsoltypee whichsol, MSKprostae *prosta, MSKsolstae *solsta)

static SCIP_RETCODE ensureBkcMem(SCIP_LPI *lpi, int nrows)

static void invalidateSolution(SCIP_LPI *lpi)

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSallocMemoryArray(ptr, num)

#define BMSfreeMemoryArray(ptr)

#define BMSallocBlockMemoryArray(mem, ptr, num)

#define BMSfreeBlockMemoryArray(mem, ptr, num)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

void SCIPmessagePrintInfo(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

public methods for message output

static SCIP_RETCODE presolve(SCIP *scip, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *vanished)

MSKoptimizertype lastalgo

MSKsoltypee lastsolvetype

SCIP_MESSAGEHDLR * messagehdlr

@ SCIP_PRICING_STEEPQSTART

@ SCIP_PRICING_LPIDEFAULT

enum SCIP_Pricing SCIP_PRICING

enum SCIP_LPParam SCIP_LPPARAM

@ SCIP_LPPAR_BARRIERCONVTOL

@ SCIP_LPPAR_CONDITIONLIMIT

@ SCIP_LPPAR_ROWREPSWITCH

enum SCIP_LPSolQuality SCIP_LPSOLQUALITY

enum SCIP_ObjSen SCIP_OBJSEN

enum SCIP_Retcode SCIP_RETCODE

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4