A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: reader_osil.c Source File

35#define _USE_MATH_DEFINES 69#define READER_NAME "osilreader" 70#define READER_DESC "file reader for OS instance language (OSiL) format" 71#define READER_EXTENSION "osil" 97

assert(datanode !=

NULL

);

98

assert(vars !=

NULL

);

99

assert(nvars !=

NULL

);

100

assert(doingfine !=

NULL

);

107 if

( variables ==

NULL

)

115 if

( attrval ==

NULL

)

117 SCIPerrorMessage

(

"Attribute \"numberOfVariables\" not found in <variables> node.\n"

);

122

varssize = (int)strtol(attrval, (

char

**)&attrval, 10);

123 if

( *attrval !=

'\0'

|| varssize < 0 )

129

assert(varssize >= 0);

138 const char

* varname;

144 if

( varssize == *nvars )

146 SCIPerrorMessage

(

"Expected %d variables, got at least %d many.\n"

, varssize, *nvars+1);

156 if

( attrval !=

NULL

&& strcmp(attrval,

"1"

) != 0 )

158 SCIPerrorMessage

(

"Variable attribute 'mult' not supported (while parsing variable <%s>)\n"

, varname);

165 if

( attrval ==

NULL

)

167 else if

( strcmp(attrval,

"-INF"

) == 0 )

169 else if

( strcmp(attrval,

"INF"

) == 0 )

173

varlb = strtod(attrval, (

char

**)&attrval);

174 if

( *attrval !=

'\0'

)

176 SCIPerrorMessage

(

"Error parsing variable lower bound '%s' for variable <%s>\n"

, attrval, varname);

184 if

( attrval ==

NULL

)

186 else if

( strcmp(attrval,

"-INF"

) == 0 )

188 else if

( strcmp(attrval,

"INF"

) == 0 )

192

varub = strtod(attrval, (

char

**)&attrval);

193 if

( *attrval !=

'\0'

)

195 SCIPerrorMessage

(

"Error parsing variable upper bound '%s' for variable <%s>\n"

, attrval, varname);

207 if

( attrval ==

NULL

)

209 else switch

( *attrval )

235 SCIPerrorMessage

(

"Unsupported variable type '%s' for variable <%s>\n"

, attrval, varname);

247 SCIP_CALL

(

SCIPcreateVar

(

scip

, &(*vars)[*nvars], varname, varlb, varub, 0.0, vartype, !dynamiccols, dynamiccols,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

) );

248

assert((*vars)[*nvars] !=

NULL

);

262

consvars[0] = (*vars)[*nvars];

263

consvars[1] = (*vars)[*nvars];

269

bounds[1] = semibound;

281 if

( *nvars < varssize )

283 SCIPerrorMessage

(

"Expected %d variables, but got only %d many.\n"

, varssize, *nvars);

304 const char

* attrval;

307

assert(datanode !=

NULL

);

308

assert(vars !=

NULL

|| nvars == 0);

309

assert(doingfine !=

NULL

);

315 if

( objective ==

NULL

)

320 if

( attrval !=

NULL

&& strcmp(attrval,

"1"

) != 0 )

329 if

( attrval ==

NULL

)

335 else if

( strcmp(attrval,

"min"

) == 0 )

339 else if

( strcmp(attrval,

"max"

) == 0 )

358 if

( attrval ==

NULL

)

360 SCIPerrorMessage

(

"Missing \"idx\" attribute in objective coefficient.\n"

);

364

idx = (int)strtol(attrval, (

char

**)&attrval, 10);

365 if

( *attrval !=

'\0'

)

372 if

( idx < 0 || idx >= nvars )

374 SCIPerrorMessage

(

"Invalid variable index '%d' of objective coefficient.\n"

, idx);

388

val = strtod(attrval, (

char

**)&attrval);

389 if

( *attrval !=

'\0'

)

402 if

( attrval !=

NULL

)

406

objconst = strtod(attrval, (

char

**)&attrval);

407 if

( *attrval !=

'\0'

)

414 if

( objconst != 0.0 )

418 SCIP_CALL

(

SCIPcreateVar

(

scip

, &objconstvar,

"objconstvar"

, objconst, objconst, 1.0,

SCIP_VARTYPE_CONTINUOUS

, !dynamiccols, dynamiccols,

NULL

,

NULL

,

NULL

,

NULL

,

NULL

) );

444 const char

* attrval;

447

assert(datanode !=

NULL

);

448

assert(nconss !=

NULL

);

449

assert(doingfine !=

NULL

);

456 if

( constraints ==

NULL

)

460

attrval =

xmlGetAttrval

(constraints,

"numberOfConstraints"

);

461 if

( attrval ==

NULL

)

463 SCIPerrorMessage

(

"Attribute \"numberOfConstraints\" not found in <constraints> node.\n"

);

468

*nconss = (int)strtol(attrval, (

char

**)&attrval, 10);

469 if

( *attrval !=

'\0'

|| *nconss < 0 )

475

assert(*nconss >= 0);

504

assert(nlinvars >= 0);

505

assert(nquadterms >= 0);

516 if

( nquadterms == 0 && nlexpr ==

NULL

)

519

nlinvars, linvars, lincoefs, lhs, rhs, initialconss,

525

assert(objvar !=

NULL

);

542 if

( nlinvars > 0 || nquadterms > 0 )

546

nquadterms, quadvars1, quadvars2, quadcoefs,

NULL

,

NULL

) );

550 if

( nlexpr !=

NULL

)

556 if

( varexpr !=

NULL

)

572

assert(nlexpr !=

NULL

);

577 SCIP_EXPR

* children[2] = {nlexpr, varexpr};

580

assert(varexpr !=

NULL

);

603

assert(varexpr !=

NULL

);

615

assert(objvar !=

NULL

);

647 const char

* attrval;

652

assert(datanode !=

NULL

);

653

assert(doingfine !=

NULL

);

654

assert(linvars !=

NULL

);

655

assert(lincoefs !=

NULL

);

656

assert(nlinvars !=

NULL

);

657

assert(quadvars1 !=

NULL

);

658

assert(quadvars2 !=

NULL

);

659

assert(quadcoefs !=

NULL

);

660

assert(nquadterms !=

NULL

);

661

assert(nlexprs !=

NULL

);

666 if

( constraints ==

NULL

)

672 const char

* consname;

678 SCIPerrorMessage

(

"Expected %d constraints, but got at least %d many.\n"

, nconss, c+1);

685 if

( consname ==

NULL

)

693 if

( attrval !=

NULL

&& strcmp(attrval,

"1"

) != 0 )

695 SCIPerrorMessage

(

"Constraint attribute 'mult' not supported (while parsing constraint <%s>).\n"

, consname);

702 if

( attrval ==

NULL

)

704 else if

( strcmp(attrval,

"-INF"

) == 0 )

706 else if

( strcmp(attrval,

"INF"

) == 0 )

710

conslhs = strtod(attrval, (

char

**)&attrval);

711 if

( *attrval !=

'\0'

)

713 SCIPerrorMessage

(

"Error parsing constraint lower bound '%s' for constraint <%s>.\n"

, attrval, consname);

721 if

( attrval ==

NULL

)

723 else if

( strcmp(attrval,

"-INF"

) == 0 )

725 else if

( strcmp(attrval,

"INF"

) == 0 )

729

consrhs = strtod(attrval, (

char

**)&attrval);

730 if

( *attrval !=

'\0'

)

732 SCIPerrorMessage

(

"Error parsing constraint upper bound '%s' for constraint <%s>.\n"

, attrval, consname);

740 if

( attrval !=

NULL

)

744

consconstant = strtod(attrval, (

char

**)&attrval);

745 if

( *attrval !=

'\0'

)

747 SCIPerrorMessage

(

"Error parsing constraint constant '%s' for constraint <%s>.\n"

, attrval, consname);

752

conslhs -= consconstant;

754

consrhs -= consconstant;

759

quadvars1[c], quadvars2[c], quadcoefs[c], nquadterms[c], nlexprs[c],

760

conslhs, consrhs, consname,

FALSE

, initialconss, dynamicconss, dynamicrows) );

767 SCIPerrorMessage

(

"Got %d constraints, but expected %d many.\n"

, c, nconss);

789 const char

* attrval;

791

assert(node !=

NULL

);

792

assert(mult !=

NULL

);

793

assert(doingfine !=

NULL

);

796 if

( incrint !=

NULL

)

798 if

( incrreal !=

NULL

)

802 if

( attrval ==

NULL

)

806

*mult = (int)strtol(attrval, (

char

**)&attrval, 10);

807 if

( *attrval !=

'\0'

|| *mult < 1 )

819 if

( attrval ==

NULL

)

822 if

( incrint !=

NULL

)

824

*incrint = (int)strtol(attrval, (

char

**)&attrval, 10);

825 if

( *attrval !=

'\0'

)

833 if

( incrreal !=

NULL

)

835

*incrreal = strtod(attrval, (

char

**)&attrval);

864 const char

* attrval;

876

assert(datanode !=

NULL

);

877

assert(vars !=

NULL

|| nvars == 0);

878

assert(doingfine !=

NULL

);

882 if

( lincoef ==

NULL

)

887 if

( attrval ==

NULL

)

889 SCIPerrorMessage

(

"Attribute \"numberOfValues\" not found for <linearConstraintCoefficients> node.\n"

);

894

nnz = (int)strtol(attrval, (

char

**)&attrval, 10);

895 if

( *attrval !=

'\0'

|| nnz < 0 )

897 SCIPerrorMessage

(

"Invalid value '%s' for \"numberOfValues\" attribute in <linearConstraintCoefficients> node.\n"

,

xmlGetAttrval

(lincoef,

"numberOfValues"

));

905 if

( startnode ==

NULL

)

907 SCIPerrorMessage

(

"Node <start> not found inside <linearConstraintCoefficients> node.\n"

);

913 if

( idxnode !=

NULL

)

917 SCIPerrorMessage

(

"Both <rowIdx> and <colIdx> found under <linearConstraintCoefficients> node.\n"

);

926 if

( idxnode ==

NULL

)

928 SCIPerrorMessage

(

"Both <rowIdx> and <colIdx> not found under <linearConstraintCoefficients> node.\n"

);

936 if

( valnode ==

NULL

)

938 SCIPerrorMessage

(

"<value> node not found under <linearConstraintCoefficients> node.\n"

);

954 if

( strcmp(

xmlGetName

(elnode),

"el"

) != 0 )

956 SCIPerrorMessage

(

"Expected <el> node under <start> node in <linearConstraintCoefficients>, but got '%s'.\n"

,

xmlGetName

(elnode));

960 if

( count >= (rowmajor ? nconss : nvars) + 1 )

962 SCIPerrorMessage

(

"Too many elements under <start> node in <linearConstraintCoefficients>, expected %d many, got at least %d.\n"

, (rowmajor ? nconss : nvars) + 1, count + 1);

968 SCIPerrorMessage

(

"No data in <el> node in <linearConstraintCoefficients>.\n"

);

975 if

( *attrval !=

'\0'

|| start[count] < 0 || (start[count] > nnz) )

977 SCIPerrorMessage

(

"Invalid value '%s' in <el> node under <start> node in <linearConstraintCoefficients>.\n"

,

xmlGetData

(elnode));

987 for

( --mult; mult > 0; --mult )

990 if

( count >= (rowmajor ? nconss : nvars) + 1 )

992 SCIPerrorMessage

(

"Too many elements under <start> node in <linearConstraintCoefficients>, expected %d many, got at least %d.\n"

, (rowmajor ? nconss : nvars) + 1, count + 1);

996

start[count] = start[count-1] + incrint;

999 if

( count != (rowmajor ? nconss : nvars) + 1 )

1001 SCIPerrorMessage

(

"Got only %d <start> entries in <linearConstraintCoefficients>, but expected %d many.\n"

, count, (rowmajor ? nconss : nvars) + 1);

1002

*doingfine =

FALSE

;

1013 if

( strcmp(

xmlGetName

(elnode),

"el"

) != 0 )

1015 SCIPerrorMessage

(

"Expected <el> node under <%s> node in <linearConstraintCoefficients>, but got '%s'.\n"

, rowmajor ?

"colIdx"

:

"rowIdx"

,

xmlGetName

(elnode));

1016

*doingfine =

FALSE

;

1021 SCIPerrorMessage

(

"Too many elements under <%s> node in <linearConstraintCoefficients>, expected %d many, but got at least %d.\n"

, rowmajor ?

"colIdx"

:

"rowIdx"

, nnz, count + 1);

1022

*doingfine =

FALSE

;

1027 SCIPerrorMessage

(

"No data in <el> node under <%s> node in <linearConstraintCoefficients>.\n"

, rowmajor ?

"colIdx"

:

"rowIdx"

);

1028

*doingfine =

FALSE

;

1034 if

( *attrval !=

'\0'

|| idx[count] < 0 || (idx[count] >= (rowmajor ? nvars : nconss)) )

1036 SCIPerrorMessage

(

"Invalid value '%s' in <el> node under <%s> node in <linearConstraintCoefficients>.\n"

,

xmlGetData

(elnode), rowmajor ?

"colIdx"

:

"rowIdx"

);

1037

*doingfine =

FALSE

;

1046 for

( --mult; mult > 0; --mult )

1051 SCIPerrorMessage

(

"Too many elements under <%s> node in <linearConstraintCoefficients>, expected %d many, got at least %d.\n"

, rowmajor ?

"colIdx"

:

"rowIdx"

, nnz, count + 1);

1052

*doingfine =

FALSE

;

1055

idx[count] = idx[count-1] + incrint;

1060 SCIPerrorMessage

(

"Got only %d entries in <%s> node in <linearConstraintCoefficients>, expected %d many.\n"

, count, rowmajor ?

"colIdx"

:

"rowIdx"

, nnz);

1061

*doingfine =

FALSE

;

1072 if

( strcmp(

xmlGetName

(elnode),

"el"

) != 0 )

1074 SCIPerrorMessage

(

"Expected <el> node under <value> node in <linearConstraintCoefficients>, but got '%s'.\n"

,

xmlGetName

(elnode));

1075

*doingfine =

FALSE

;

1080 SCIPerrorMessage

(

"Too many elements under <value> node in <linearConstraintCoefficients>, expected %d many, got at least %d.\n"

, nnz, count + 1);

1081

*doingfine =

FALSE

;

1086 SCIPerrorMessage

(

"No data in <el> node under <value> node in <linearConstraintCoefficients>.\n"

);

1087

*doingfine =

FALSE

;

1095 SCIPerrorMessage

(

"Invalid value '%s' in <el> node under <value> node in <linearConstraintCoefficients>.\n"

,

xmlGetData

(elnode));

1096

*doingfine =

FALSE

;

1105 for

( --mult; mult > 0; --mult )

1110 SCIPerrorMessage

(

"Too many elements under <value> node in <linearConstraintCoefficients>, expected %d many, got at least %d.\n"

, nnz, count + 1);

1111

*doingfine =

FALSE

;

1114

val[count] = val[count-1] + incrreal;

1119 SCIPerrorMessage

(

"Got only %d entries under <value> node in <linearConstraintCoefficients>, expected %d many.\n"

, count, nnz);

1120

*doingfine =

FALSE

;

1129 for

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

1134

assert(start[row] >= 0);

1135

assert(start[row+1] >= 0);

1136

assert(start[row] <= nnz);

1137

assert(start[row+1] <= nnz);

1139

assert(linvars[row] ==

NULL

);

1140

assert(lincoefs[row] ==

NULL

);

1141

assert(nlinvars[row] == 0);

1143 nterms

= start[row+1] - start[row];

1147 for

( pos = start[row]; pos < start[row+1]; ++pos )

1152

assert(idx[pos] >= 0);

1153

assert(idx[pos] < nvars);

1155

linvars[row][nlinvars[row]] = vars[idx[pos]];

1156

lincoefs[row][nlinvars[row]] = val[pos];

1159

assert(nlinvars[row] ==

nterms

);

1169 for

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

1171 for

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

1174

assert(start[col] >= 0);

1175

assert(start[col+1] >= 0);

1176

assert(start[col] <= nnz);

1177

assert(start[col+1] <= nnz);

1178 for

( pos = start[col]; pos < start[col+1]; ++pos )

1180 int

considx = idx[pos];

1185

assert(considx >= 0);

1186

assert(considx < nconss);

1190

++(nlinvars[considx]);

1194

linvars[considx][nlinvars[considx]] = vars[col];

1195

lincoefs[considx][nlinvars[considx]] = val[pos];

1196

++(nlinvars[considx]);

1206 for

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

1244 const char

* attrval;

1253

assert(datanode !=

NULL

);

1254

assert(quadvars1 !=

NULL

);

1255

assert(quadvars2 !=

NULL

);

1256

assert(quadcoefs !=

NULL

);

1257

assert(nquadterms !=

NULL

);

1258

assert(doingfine !=

NULL

);

1262 if

( quadcoef ==

NULL

)

1266

attrval =

xmlGetAttrval

(quadcoef,

"numberOfQuadraticTerms"

);

1267 if

( attrval ==

NULL

)

1269 SCIPerrorMessage

(

"Attribute \"numberOfQuadraticTerms\" not found for <quadraticCoefficients> node.\n"

);

1270

*doingfine =

FALSE

;

1274

nqterms = (int)strtol(attrval, (

char

**)&attrval, 10);

1275 if

( *attrval !=

'\0'

|| nqterms < 0 )

1277 SCIPerrorMessage

(

"Invalid value '%s' for \"numberOfQuadraticTerms\" attribute of <quadraticCoefficients> node.\n"

,

xmlGetAttrval

(quadcoef,

"numberOfQuadraticTerms"

));

1278

*doingfine =

FALSE

;

1281

assert(nqterms >= 0);

1286

assert(vars !=

NULL

);

1292 if

( strcmp(

xmlGetName

(qterm),

"qTerm"

) != 0 )

1295

*doingfine =

FALSE

;

1298 if

( count >= nqterms )

1300 SCIPerrorMessage

(

"Too many quadratic terms under <quadraticCoefficients> node, expected %d many, but got at least %d.\n"

, nqterms, count + 1);

1301

*doingfine =

FALSE

;

1307 if

( attrval ==

NULL

)

1309 SCIPerrorMessage

(

"Missing \"idx\" attribute in %d'th <qTerm> node under <quadraticCoefficients> node.\n"

, count);

1310

*doingfine =

FALSE

;

1314

considx = (int)strtol(attrval, (

char

**)&attrval, 10);

1315 if

( *attrval !=

'\0'

|| considx < -1 || considx >= nconss )

1317 SCIPerrorMessage

(

"Invalid value '%s' in \"idx\" attribute of %d'th <qTerm> node under <quadraticCoefficients> node.\n"

,

xmlGetAttrval

(qterm,

"idx"

), count);

1318

*doingfine =

FALSE

;

1324 if

( attrval ==

NULL

)

1326 SCIPerrorMessage

(

"Missing \"idxOne\" attribute in %d'th <qTerm> node under <quadraticCoefficients> node.\n"

, count);

1327

*doingfine =

FALSE

;

1331

varidx1 = (int)strtol(attrval, (

char

**)&attrval, 10);

1332 if

( *attrval !=

'\0'

|| varidx1 < 0 || varidx1 >= nvars )

1334 SCIPerrorMessage

(

"Invalid value '%s' in \"idxOne\" attribute of %d'th <qTerm> node under <quadraticCoefficients> node.\n"

,

xmlGetAttrval

(qterm,

"idxOne"

), count);

1335

*doingfine =

FALSE

;

1341 if

( attrval ==

NULL

)

1343 SCIPerrorMessage

(

"Missing \"idxTwo\" attribute in %d'th <qTerm> node under <quadraticCoefficients> node.\n"

, count);

1344

*doingfine =

FALSE

;

1348

varidx2 = (int)strtol(attrval, (

char

**)&attrval, 10);

1349 if

( *attrval !=

'\0'

|| varidx2 < 0 || varidx2 >= nvars )

1351 SCIPerrorMessage

(

"Invalid value '%s' in \"idxTwo\" attribute of %d'th <qTerm> node under <quadraticCoefficients> node.\n"

,

xmlGetAttrval

(qterm,

"idxTwo"

), count);

1352

*doingfine =

FALSE

;

1358 if

( attrval !=

NULL

)

1360

coef = strtod(attrval, (

char

**)&attrval);

1361 if

( *attrval !=

'\0'

|| (coef != coef) )

1363 SCIPerrorMessage

(

"Invalid value '%s' in \"coef\" attribute of %d'th <qTerm> node under <quadraticCoefficients> node.\n"

,

xmlGetAttrval

(qterm,

"coef"

), count);

1364

*doingfine =

FALSE

;

1379 if

( considx == -1 )

1382 if

( nquadterms[considx] + 1 > termssize[considx] )

1390

termssize[considx] = newsize;

1393

quadvars1[considx][nquadterms[considx]] = vars[varidx1];

1394

quadvars2[considx][nquadterms[considx]] = vars[varidx2];

1395

quadcoefs[considx][nquadterms[considx]] = coef;

1396

++nquadterms[considx];

1399 if

( count != nqterms )

1401 SCIPerrorMessage

(

"Got only %d quadratic terms under <quadraticCoefficients> node, but expected %d many.\n"

, count, nqterms);

1402

*doingfine =

FALSE

;

1419 const char

* exprname;

1422

assert(expr !=

NULL

);

1423

assert(node !=

NULL

);

1424

assert(vars !=

NULL

);

1425

assert(doingfine !=

NULL

);

1428

assert(exprname !=

NULL

);

1433 if

( strcmp(exprname,

"variable"

) == 0 )

1435 const char

* attrval;

1441 if

( attrval ==

NULL

)

1443 SCIPerrorMessage

(

"Attribute \"idx\" required for <variable> node in nonlinear expression\n"

);

1444

*doingfine =

FALSE

;

1448

idx = (int)strtol(attrval, (

char

**)&attrval, 10);

1449 if

( *attrval !=

'\0'

|| idx < 0 || idx >= nvars )

1452

*doingfine =

FALSE

;

1458 if

( attrval !=

NULL

)

1460

coef = strtod(attrval, (

char

**)&attrval);

1463 SCIPerrorMessage

(

"Invalid value '%s' in \"coef\" attribute of <variable> node in nonlinear expression.\n"

,

xmlGetAttrval

(node,

"coef"

));

1464

*doingfine =

FALSE

;

1491 if

( strcmp(exprname,

"number"

) == 0 )

1493 const char

* attrval;

1497 if

( attrval !=

NULL

&& (strcmp(attrval,

"real"

) != 0) )

1499 SCIPerrorMessage

(

"Type '%s' for <number> node in nonlinear expression not supported.\n"

, attrval);

1500

*doingfine =

FALSE

;

1505 if

( attrval !=

NULL

)

1507

val = strtod(attrval, (

char

**)&attrval);

1510 SCIPerrorMessage

(

"Invalid value '%s' in \"value\" attribute of <number> node in nonlinear expression.\n"

,

xmlGetAttrval

(node,

"value"

));

1511

*doingfine =

FALSE

;

1529 if

( strcmp(exprname,

"PI"

) == 0 )

1537 if

( strcmp(exprname,

"E"

) == 0 )

1546 if

( strcmp(exprname,

"negate"

) == 0 ||

1547

strcmp(exprname,

"abs"

) == 0 ||

1548

strcmp(exprname,

"squareRoot"

) == 0 ||

1549

strcmp(exprname,

"sqrt"

) == 0 ||

1550

strcmp(exprname,

"square"

) == 0 ||

1551

strcmp(exprname,

"exp"

) == 0 ||

1552

strcmp(exprname,

"ln"

) == 0 ||

1553

strcmp(exprname,

"log10"

) == 0 ||

1554

strcmp(exprname,

"sin"

) == 0 ||

1555

strcmp(exprname,

"cos"

) == 0 ||

1556

strcmp(exprname,

"erf"

) == 0

1564 SCIPerrorMessage

(

"Expected exactly one child in <%s> node in nonlinear expression\n"

, exprname);

1565

*doingfine =

FALSE

;

1574

assert(arg !=

NULL

);

1577 if

( strcmp(exprname,

"negate"

) == 0 )

1585 else if

( strcmp(exprname,

"abs"

) == 0 )

1589 else if

( strcmp(exprname,

"squareRoot"

) == 0 || strcmp(exprname,

"sqrt"

) == 0 )

1593 else if

( strcmp(exprname,

"square"

) == 0 )

1597 else if

( strcmp(exprname,

"exp"

) == 0 )

1601 else if

( strcmp(exprname,

"ln"

) == 0 )

1605 else if

( strcmp(exprname,

"log10"

) == 0 )

1614 else if

( strcmp(exprname,

"sin"

) == 0 )

1618 else if

( strcmp(exprname,

"cos"

) == 0 )

1622 else if

( strcmp(exprname,

"erf"

) == 0 )

1624 SCIPwarningMessage

(

scip

,

"Danger! You're entering a construction area. Implementation of support for 'erf' is incomplete.\n"

);

1635 if

( strcmp(exprname,

"plus"

) == 0 ||

1636

strcmp(exprname,

"minus"

) == 0 ||

1637

strcmp(exprname,

"times"

) == 0 ||

1638

strcmp(exprname,

"divide"

) == 0 ||

1639

strcmp(exprname,

"power"

) == 0 ||

1640

strcmp(exprname,

"signpower"

) == 0 ||

1641

strcmp(exprname,

"log"

) == 0

1651 SCIPerrorMessage

(

"Expected exactly two children in <%s> node in nonlinear expression.\n"

, exprname);

1652

*doingfine =

FALSE

;

1659 goto

TERMINATE_TWO_ARGS;

1660

assert(args[0] !=

NULL

);

1665 goto

TERMINATE_TWO_ARGS;

1666

assert(args[1] !=

NULL

);

1668 if

( strcmp(exprname,

"plus"

) == 0 )

1672 else if

( strcmp(exprname,

"minus"

) == 0 )

1677 else if

( strcmp(exprname,

"times"

) == 0 )

1681 else if

( strcmp(exprname,

"divide"

) == 0 )

1692 else if

( strcmp(exprname,

"power"

) == 0 )

1706 SCIPerrorMessage

(

"Negative base in <power> node with nonconstant exponent not allowed in nonlinear expression.\n"

);

1707

*doingfine =

FALSE

;

1708 goto

TERMINATE_TWO_ARGS;

1736 else if

( strcmp(exprname,

"signpower"

) == 0 )

1742

*doingfine =

FALSE

;

1743 goto

TERMINATE_TWO_ARGS;

1747 SCIPerrorMessage

(

"Signpower only supported for exponents > 1, but got %g.\n"

,

1749

*doingfine =

FALSE

;

1750 goto

TERMINATE_TWO_ARGS;

1756 else if

( strcmp(exprname,

"log"

) == 0 )

1775 else if

( strcmp(exprname,

"min"

) == 0 )

1778

*doingfine =

FALSE

;

1779 goto

TERMINATE_TWO_ARGS;

1783

assert(strcmp(exprname,

"max"

) == 0);

1786

*doingfine =

FALSE

;

1787 goto

TERMINATE_TWO_ARGS;

1793 if

( args[0] !=

NULL

)

1797 if

( args[1] !=

NULL

)

1806 if

( strcmp(exprname,

"sum"

) == 0 || strcmp(exprname,

"product"

) == 0 )

1829 if

( nargs >= argssize )

1834

assert(nargs < argssize);

1839

assert(args[nargs] ==

NULL

);

1864 if

( strcmp(exprname,

"sum"

) == 0 )

1879 for

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

1881

assert(args[i] !=

NULL

);

1890 if

( strcmp(exprname,

"min"

) == 0 || strcmp(exprname,

"max"

) == 0 )

1893

*doingfine =

FALSE

;

1897 if

( strcmp(exprname,

"quadratic"

) == 0 )

1899 const char

* attrval;

1918 if

( strcmp(

xmlGetName

(qterm),

"qpTerm"

) != 0 )

1920 SCIPerrorMessage

(

"Unexpected <%s> node under <quadratic> node in nonlinear expression, expected <qpTerm>.\n"

,

xmlGetName

(qterm));

1921

*doingfine =

FALSE

;

1925 if

( nquadelems >= quadelemssize )

1932

assert(quadelemssize > nquadelems);

1936 if

( attrval ==

NULL

)

1938 SCIPerrorMessage

(

"Missing \"idxOne\" attribute in %d'th <qpTerm> node under <quadratic> node in nonlinear expression.\n"

, nquadelems);

1939

*doingfine =

FALSE

;

1943

idx = (int)strtol(attrval, (

char

**)&attrval, 10);

1944 if

( *attrval !=

'\0'

|| idx < 0 || idx >= nvars )

1946 SCIPerrorMessage

(

"Invalid value '%s' for \"idxOne\" attribute of %d'th <qpTerm> node under <quadratic> node in nonlinear expression.\n"

,

xmlGetAttrval

(qterm,

"idxOne"

), nquadelems);

1947

*doingfine =

FALSE

;

1950

quadvars1[nquadelems] = vars[idx];

1954 if

( attrval ==

NULL

)

1956 SCIPerrorMessage

(

"Missing \"idxTwo\" attribute in %d'th <qpTerm> node under <quadratic> node in nonlinear expression.\n"

, nquadelems);

1957

*doingfine =

FALSE

;

1961

idx = (int)strtol(attrval, (

char

**)&attrval, 10);

1962 if

( *attrval !=

'\0'

|| idx < 0 || idx >= nvars )

1964 SCIPerrorMessage

(

"Invalid value '%s' for \"idxTwo\" attribute of %d'th <qpTerm> node under <quadratic> node in nonlinear expression.\n"

,

xmlGetAttrval

(qterm,

"idxTwo"

), nquadelems);

1965

*doingfine =

FALSE

;

1968

quadvars2[nquadelems] = vars[idx];

1972 if

( attrval !=

NULL

)

1974

quadcoefs[nquadelems] = strtod(attrval, (

char

**)&attrval);

1975 if

( *attrval !=

'\0'

|| !

SCIPisFinite

(quadcoefs[nquadelems]) )

1977 SCIPerrorMessage

(

"Invalid value '%s' for \"coef\" attribute of %d'th <qpTerm> node under <quadratic> node in nonlinear expression.\n"

,

xmlGetAttrval

(qterm,

"coef"

), nquadelems);

1978

*doingfine =

FALSE

;

1984

quadcoefs[nquadelems] = 1.0;

1989 SCIP_CALL

(

SCIPcreateExprQuadratic

(

scip

, expr, 0,

NULL

,

NULL

, nquadelems, quadvars1, quadvars2, quadcoefs,

NULL

,

NULL

) );

1992 SCIPerrorMessage

(

"Expression operand <%s> in nonlinear expression not supported by SCIP so far.\n"

, exprname);

1993

*doingfine =

FALSE

;

2013 const char

* attrval;

2019

assert(datanode !=

NULL

);

2020

assert(vars !=

NULL

|| nvars == 0);

2021

assert(exprs !=

NULL

);

2022

assert(doingfine !=

NULL

);

2026 if

( nlexprs ==

NULL

)

2030

attrval =

xmlGetAttrval

(nlexprs,

"numberOfNonlinearExpressions"

);

2031 if

( attrval ==

NULL

)

2033 SCIPerrorMessage

(

"Attribute \"numberOfNonlinearExpressions\" in <nonlinearExpressions> node not found.\n"

);

2034

*doingfine =

FALSE

;

2038

nnlexprs = (int)strtol(attrval, (

char

**)&attrval, 10);

2039 if

( *attrval !=

'\0'

|| nnlexprs < 0 )

2041 SCIPerrorMessage

(

"Invalid value '%s' for \"numberOfNonlinearExpressions\" attribute in <nonlinearExpressions>.\n"

,

xmlGetAttrval

(nlexprs,

"numberOfNonlinearExpressions"

));

2042

*doingfine =

FALSE

;

2045

assert(nnlexprs >= 0);

2051 if

( strcmp(

xmlGetName

(nlexpr),

"nl"

) != 0 )

2054

*doingfine =

FALSE

;

2057 if

( count >= nnlexprs )

2059 SCIPerrorMessage

(

"Too many nonlinear expressions under <nonlinearExpressions> node, expected %d many, but got at least %d.\n"

, nnlexprs, count + 1);

2060

*doingfine =

FALSE

;

2070 if

( attrval ==

NULL

)

2072 SCIPerrorMessage

(

"Missing \"idx\" attribute in %d'th <nl> node under <nonlinearExpressions> node.\n"

, count);

2073

*doingfine =

FALSE

;

2077

considx = (int)strtol(attrval, (

char

**)&attrval, 10);

2078 if

( *attrval !=

'\0'

|| considx < -1 || considx >= nconss )

2080 SCIPerrorMessage

(

"Invalid value '%s' in \"idx\" attribute of %d'th <nl> node under <nonlinearExpressions> node.\n"

,

xmlGetAttrval

(nlexpr,

"idx"

), count);

2081

*doingfine =

FALSE

;

2124 const char

* attrval;

2143

initial = initialconss;

2149

dynamic = dynamicconss;

2150

removable = dynamicrows;

2154 if

( soscons==

NULL

)

2159 if

( attrval ==

NULL

)

2161 SCIPerrorMessage

(

"Attribute \"numberOfSOS in <specialOrderedSets> node not found.\n"

);

2162

*doingfine =

FALSE

;

2166

nsoscons = (int)strtol(attrval, (

char

**)&attrval, 10);

2167 if

( *attrval !=

'\0'

|| nsoscons < 0 )

2169 SCIPerrorMessage

(

"Invalid value '%s' for \"numberOfSOS\" attribute in <specialOrderedSets>.\n"

,

xmlGetAttrval

(soscons,

"numberOfSOS"

));

2170

*doingfine =

FALSE

;

2173

assert(nsoscons >= 0);

2182 if

( strcmp(

xmlGetName

(soscons),

"sos"

) != 0 )

2185

*doingfine =

FALSE

;

2189 if

( count >= nsoscons)

2191 SCIPerrorMessage

(

"Too many sos under <specialOrderedSets> node, expected %d many, but got at least %d.\n"

, nsoscons, count + 1);

2192

*doingfine =

FALSE

;

2198 if

( attrval ==

NULL

)

2201

*doingfine =

FALSE

;

2205

nsosvars = (int)strtol(attrval, (

char

**)&attrval, 10);

2206 if

( *attrval !=

'\0'

|| nsosvars < 0 )

2209

*doingfine =

FALSE

;

2212

assert(nsosvars >= 0);

2216 if

( attrval ==

NULL

)

2219

*doingfine =

FALSE

;

2223

sosorder = (int)strtol(attrval, (

char

**)&attrval, 10);

2224 if

( *attrval !=

'\0'

|| sosorder < 0 || sosorder > 2 )

2227

*doingfine =

FALSE

;

2230

assert(sosorder == 1 || sosorder == 2);

2240 SCIP_CALL

(

SCIPcreateConsSOS1

(

scip

, &cons, name, 0,

NULL

,

NULL

, initial, separate, enforce, check, propagate,

2241

local, dynamic, removable,

FALSE

) );

2244 SCIP_CALL

(

SCIPcreateConsSOS2

(

scip

, &cons, name, 0,

NULL

,

NULL

, initial, separate, enforce, check, propagate,

2245

local, dynamic, removable,

FALSE

) );

2258 if

( attrval ==

NULL

)

2260 SCIPerrorMessage

(

"Attribute \"idx\" in <var> node below <specialOrderedSets> node not found.\n"

);

2261

*doingfine =

FALSE

;

2265

idx = (int)strtol(attrval, (

char

**)&attrval, 10);

2266 if

( *attrval !=

'\0'

|| idx < 0 || idx > nvars - 1 )

2269

*doingfine =

FALSE

;

2338 int

* nlinvars =

NULL

;

2344 int

* nquadterms =

NULL

;

2345 int

* termssize =

NULL

;

2351

assert(reader !=

NULL

);

2352

assert(result !=

NULL

);

2353

assert(filename !=

NULL

);

2365 if

( start ==

NULL

)

2367 SCIPerrorMessage

(

"Some error occurred when parsing the OSiL XML file '%s'.\n"

, filename);

2376 if

( header !=

NULL

)

2410 SCIP_CALL_TERMINATE

( retcode,

readVariables

(

scip

, data, &vars, &nvars, initialconss, dynamicconss, dynamiccols, dynamicrows, &doingfine), CLEANUP );

2413

assert(vars !=

NULL

|| nvars == 0);

2437 SCIP_CALL_TERMINATE

( retcode,

readLinearCoefs

(

scip

, data, vars, nvars, nconss, linvars, lincoefs, nlinvars, &doingfine), CLEANUP );

2443

nquadterms, termssize, &doingfine), CLEANUP );

2454

quadvars1, quadvars2, quadcoefs, nquadterms, nlexprs, initialconss, dynamicconss, dynamicrows, &doingfine),

2460 if

( nlinvars[nconss] > 0 || nquadterms[nconss] > 0 || nlexprs[nconss] !=

NULL

)

2463

quadvars1[nconss], quadvars2[nconss], quadcoefs[nconss], nquadterms[nconss], nlexprs[nconss],

2479 if

( start !=

NULL

)

2483

assert(termssize !=

NULL

);

2484 for

( c = nconss; c >= 0; --c )

2487 if

( nlexprs !=

NULL

&& nlexprs[c] !=

NULL

)

2512 for

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

constraint handler for bound disjunction constraints

Constraint handler for linear constraints in their most general form, .

constraint handler for nonlinear constraints specified by algebraic expressions

constraint handler for SOS type 1 constraints

constraint handler for SOS type 2 constraints

#define SCIP_CALL_TERMINATE(retcode, x, TERM)

absolute expression handler

SCIP_RETCODE SCIPcreateExprErf(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

handler for Gaussian error function expressions

exponential expression handler

logarithm expression handler

power and signed power expression handlers

product expression handler

handler for sin expressions

constant value expression handler

variable expression handler

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPaddVarSOS1(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)

SCIP_RETCODE SCIPcreateConsBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsSOS1(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)

SCIP_RETCODE SCIPcreateConsSOS2(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *weights, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_RETCODE SCIPaddVarSOS2(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real weight)

SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprSin(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprCos(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprAbs(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)

SCIP_RETCODE SCIPcreateExprSignpower(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprLog(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprExp(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprSum(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real *coefficients, SCIP_Real constant, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprValue(SCIP *scip, SCIP_EXPR **expr, SCIP_Real value, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprPow(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPincludeReaderOsil(SCIP *scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)

SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)

SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)

void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)

SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)

SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)

SCIP_RETCODE SCIPcreateExprQuadratic(SCIP *scip, SCIP_EXPR **expr, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)

SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

void SCIPcaptureExpr(SCIP_EXPR *expr)

#define SCIPallocClearBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPfreeBufferArrayNull(scip, ptr)

SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)

SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))

SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)

SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)

SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)

int SCIPsnprintf(char *t, int len, const char *s,...)

static volatile int nterms

memory allocation routines

public methods for managing constraints

public methods for message output

public data structures and miscellaneous methods

public methods for NLP management

public methods for problem variables

static SCIP_RETCODE readConstraints(SCIP *scip, const XML_NODE *datanode, int nconss, SCIP_VAR ***linvars, SCIP_Real **lincoefs, int *nlinvars, SCIP_VAR ***quadvars1, SCIP_VAR ***quadvars2, SCIP_Real **quadcoefs, int *nquadterms, SCIP_EXPR **nlexprs, SCIP_Bool initialconss, SCIP_Bool dynamicconss, SCIP_Bool dynamicrows, SCIP_Bool *doingfine)

static SCIP_RETCODE readExpression(SCIP *scip, SCIP_EXPR **expr, const XML_NODE *node, SCIP_VAR **vars, int nvars, SCIP_Bool *doingfine)

static SCIP_DECL_READERREAD(readerReadOsil)

static SCIP_RETCODE readQuadraticCoefs(SCIP *scip, const XML_NODE *datanode, SCIP_VAR **vars, int nvars, int nconss, SCIP_VAR ***quadvars1, SCIP_VAR ***quadvars2, SCIP_Real **quadcoefs, int *nquadterms, int *termssize, SCIP_Bool *doingfine)

static SCIP_RETCODE readLinearCoefs(SCIP *scip, const XML_NODE *datanode, SCIP_VAR **vars, int nvars, int nconss, SCIP_VAR ***linvars, SCIP_Real **lincoefs, int *nlinvars, SCIP_Bool *doingfine)

static SCIP_RETCODE createConstraint(SCIP *scip, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nlinvars, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, int nquadterms, SCIP_EXPR *nlexpr, SCIP_Real lhs, SCIP_Real rhs, const char *name, SCIP_Bool objcons, SCIP_Bool initialconss, SCIP_Bool dynamicconss, SCIP_Bool dynamicrows)

static SCIP_RETCODE readVariables(SCIP *scip, const XML_NODE *datanode, SCIP_VAR ***vars, int *nvars, SCIP_Bool initialconss, SCIP_Bool dynamicconss, SCIP_Bool dynamiccols, SCIP_Bool dynamicrows, SCIP_Bool *doingfine)

static SCIP_RETCODE readObjective(SCIP *scip, const XML_NODE *datanode, SCIP_VAR **vars, int nvars, SCIP_Bool dynamiccols, SCIP_Bool *doingfine)

static SCIP_RETCODE readNonlinearExprs(SCIP *scip, const XML_NODE *datanode, SCIP_VAR **vars, int nvars, int nconss, SCIP_EXPR **exprs, SCIP_Bool *doingfine)

static SCIP_RETCODE readSOScons(SCIP *scip, const XML_NODE *datanode, SCIP_VAR **vars, int nvars, SCIP_Bool initialconss, SCIP_Bool dynamicconss, SCIP_Bool dynamicrows, SCIP_Bool *doingfine)

static void readMultIncr(const XML_NODE *node, int *mult, int *incrint, SCIP_Real *incrreal, SCIP_Bool *doingfine)

static SCIP_DECL_READERCOPY(readerCopyOsil)

static SCIP_RETCODE readNConstraints(SCIP *scip, const XML_NODE *datanode, int *nconss, SCIP_Bool *doingfine)

OS instance language (OSiL) format file reader.

public methods for constraint handler plugins and constraints

public methods for memory management

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for reader plugins

public methods for SCIP variables

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

enum SCIP_Vartype SCIP_VARTYPE

declarations for XML parsing

const XML_NODE * xmlFirstChild(const XML_NODE *node)

const XML_NODE * xmlFindNodeMaxdepth(const XML_NODE *node, const char *name, int depth, int maxdepth)

const char * xmlGetName(const XML_NODE *node)

const char * xmlGetAttrval(const XML_NODE *node, const char *name)

struct XML_NODE_struct XML_NODE

void xmlShowNode(const XML_NODE *root)

const XML_NODE * xmlNextSibl(const XML_NODE *node)

XML_NODE * xmlProcess(const char *filename)

const char * xmlGetData(const XML_NODE *node)

void xmlFreeNode(XML_NODE *node)

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