RetroSearch Browse

);

249

assert(constant !=

);

250 return

(

void

*) constant->name;

271 for

( i = nelements - 1; i >= 0; --i )

302 if

( strlen(token) == 1 && *token == c )

316 if

( strlen(name) == 4 && strncmp(name,

"true"

, 4) == 0 )

321 else if

( strlen(name) == 1 && strncmp(name,

"1"

, 1) == 0 )

327 else if

( strlen(name) == 5 && strncmp(name,

"false"

, 5) == 0 )

332 else if

( strlen(name) == 1 && strncmp(name,

"0"

, 1) == 0 )

352 if

( strlen(name) == 0 || !isalpha((

unsigned char

)name[0]) )

358 if

( !isalnum((

unsigned char

)name[i]) && name[i] !=

'_'

)

376

assert(hasdot !=

);

377

assert(exptype !=

);

379 if

( isdigit((

unsigned char

)c) )

381 else if

( firstchar && (c ==

'+'

|| c ==

'-'

) )

383 else if

( (*exptype ==

FZN_EXP_NONE

) && !(*hasdot) && (c ==

'.'

) && (isdigit((

unsigned char

)nextc)))

388 else if

( !firstchar && (*exptype ==

FZN_EXP_NONE

) && (c ==

'e'

|| c ==

'E'

) )

390 if

( nextc ==

'+'

|| nextc ==

'-'

)

395 else if

( isdigit((

unsigned char

)nextc) )

401 else if

( (*exptype ==

FZN_EXP_SIGNED

) && (c ==

'+'

|| c ==

'-'

) )

417

assert(token1 !=

);

418

assert(token2 !=

);

420 if

( strlen(token1) != strlen(token2) )

423 return

!strncmp(token1, token2, strlen(token2) );

437

assert(fzninput !=

);

441

fzninput->linebuf[fzninput->linebufsize - 2] =

'\0'

;

443

fzninput->linepos = 0;

444

fzninput->bufpos = 0;

446 if

(

SCIPfgets

(fzninput->linebuf, fzninput->linebufsize, fzninput->file) ==

)

449

fzninput->linenumber++;

451 while

( fzninput->linebuf[fzninput->linebufsize - 2] !=

'\0'

)

458

fzninput->linebuf[newsize-2] =

'\0'

;

459 if

(

SCIPfgets

(fzninput->linebuf + fzninput->linebufsize - 1, newsize - fzninput->linebufsize + 1, fzninput->file) ==

)

461

fzninput->linebufsize = newsize;

464

fzninput->linebuf[fzninput->linebufsize - 1] =

'\0'

;

465

fzninput->comment =

;

472

commentstart = strchr(fzninput->linebuf,

commentchars

[i]);

473 if

( commentstart !=

)

475

*commentstart =

'\0'

;

476

*(commentstart+1) =

'\0'

;

477

fzninput->comment =

;

498

assert(fzninput !=

);

499

assert(fzninput->bufpos < fzninput->linebufsize);

509 if

( fzninput->npushedtokens > 0 )

511 SCIPswapPointers

((

void

**)&fzninput->token, (

void

**)&fzninput->pushedtokens[fzninput->npushedtokens-1]);

512

fzninput->npushedtokens--;

513 SCIPdebugMsg

(

"(line %d) read token again: '%s'\n"

, fzninput->linenumber, fzninput->token);

518

buf = fzninput->linebuf;

521 if

( buf[fzninput->bufpos] ==

'\0'

)

528

assert(fzninput->bufpos == 0);

530

buf = fzninput->linebuf;

538

assert(fzninput->bufpos < fzninput->linebufsize);

544 if

( buf[fzninput->bufpos] ==

'.'

&& buf[fzninput->bufpos+1] ==

'.'

)

548

fzninput->bufpos += 2;

549

fzninput->linepos += 2;

550

fzninput->token[0] =

'.'

;

551

fzninput->token[1] =

'.'

;

553 else if

(

isValueChar

(buf[fzninput->bufpos], buf[fzninput->bufpos+1],

, &hasdot, &exptype) )

559

assert(tokenlen < fzninput->linebufsize);

561

fzninput->token[tokenlen] = buf[fzninput->bufpos];

565

assert(fzninput->bufpos < fzninput->linebufsize);

567 while

(

isValueChar

(buf[fzninput->bufpos], buf[fzninput->bufpos+1],

, &hasdot, &exptype) );

569

fzninput->hasdot = hasdot;

577

assert(tokenlen < fzninput->linebufsize);

578

fzninput->token[tokenlen] = buf[fzninput->bufpos];

584 if

(tokenlen == 1 && fzninput->token[0] ==

':'

&& buf[fzninput->bufpos] ==

':'

)

586

fzninput->token[tokenlen] = buf[fzninput->bufpos];

593 if

( tokenlen == 1 &&

isTokenChar

(fzninput->token[0]) )

599

assert(tokenlen < fzninput->linebufsize);

600

fzninput->token[tokenlen] =

'\0'

;

602 SCIPdebugMsg

(

"(line %d) read token: '%s'\n"

, fzninput->linenumber, fzninput->token);

613

assert(fzninput !=

);

616 SCIPswapPointers

((

void

**)&fzninput->pushedtokens[fzninput->npushedtokens], (

void

**)&fzninput->token);

617

fzninput->npushedtokens++;

626

assert(fzninput !=

);

628 return isChar

(fzninput->token,

';'

);

641

assert(value !=

);

643

val = strtod(token, &endptr);

644 if

( endptr != token && *endptr ==

'\0'

)

665

assert(fzninput !=

);

668 SCIPerrorMessage

(

"Syntax error in line %d: %s found <%s>\n"

, fzninput->linenumber, msg, fzninput->token);

671

fzninput->haserror =

;

680

assert(fzninput !=

);

682 return

(fzninput->haserror || !fzninput->valid);

694

(*readerdata)->vararrays =

;

695

(*readerdata)->nvararrays = 0;

696

(*readerdata)->vararrayssize = 0;

711

nvararrays = readerdata->nvararrays;

712

vararrayssize = readerdata->vararrayssize;

714 if

( vararrayssize == nvararrays )

716 if

( vararrayssize == 0 )

728

readerdata->vararrayssize = vararrayssize;

743

nvararrays = fzninput->nvararrays;

744

vararrayssize = fzninput->vararrayssize;

746 if

( vararrayssize == nvararrays )

748 if

( vararrayssize == 0 )

760

fzninput->vararrayssize = vararrayssize;

775

nconstarrays = fzninput->nconstarrays;

776

constarrayssize = fzninput->constarrayssize;

778 if

( constarrayssize == nconstarrays )

780 if

( constarrayssize == 0 )

782

constarrayssize = 100;

787

constarrayssize *= 2;

792

fzninput->constarrayssize = constarrayssize;

849 if

( source !=

)

855

(*target)->ndims = source->ndims;

856

(*target)->size = source->ndims;

887

(*vararray)->nvars = nvars;

888

(*vararray)->type = type;

934 for

( c = 0; c < fzninput->nvararrays; ++c )

936

vararray = fzninput->vararrays[c];

971

(*constarray)->nconstants = nconstants;

972

(*constarray)->type = type;

1007 for

( c = 0; c < fzninput->nconstarrays; ++c )

1009

constarray = fzninput->constarrays[c];

1032

nvararrays = readerdata->nvararrays;

1035

assert(nvararrays < readerdata->vararrayssize);

1055

vararray->info = info;

1056

vararray->nvars = 1;

1057

vararray->type = type;

1059

readerdata->vararrays[nvararrays] = vararray;

1060

readerdata->nvararrays++;

1080

nvararrays = readerdata->nvararrays;

1083

assert(nvararrays < readerdata->vararrayssize);

1088

readerdata->vararrays[nvararrays] = vararray;

1089

readerdata->nvararrays++;

1109

nvararrays = fzninput->nvararrays;

1112

assert(nvararrays < fzninput->vararrayssize);

1117

fzninput->vararrays[nvararrays] = vararray;

1118

fzninput->nvararrays++;

1137

nconstarrays = fzninput->nconstarrays;

1140

assert(nconstarrays < fzninput->constarrayssize);

1145

fzninput->constarrays[nconstarrays] = constarray;

1146

fzninput->nconstarrays++;

1173

quadvars2, quadcoefs, lhs, rhs, initialconss,

, dynamicconss,

1217 const char

* consname,

1237 if

( vars[nvars] !=

)

1242 else if

( !

(name1, &value1) )

1247

assert(constant !=

);

1249

value1 = constant->value;

1253 if

( vars[nvars] !=

)

1258 else if

( !

(name2, &value2) )

1263

assert(constant !=

);

1265

value2 = constant->value;

1269

lhs += (value2 - value1);

1272

rhs += (value2 - value1);

1274 SCIP_CALL

(

(

, consname, nvars, vars, vals, lhs, rhs, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

1291

assert(

(fzninput->token,

'['

) );

1307 if

( constant ==

)

1311

assert(constant->type ==

FZN_INT

);

1312

*idx = (int) constant->value;

1315 else if

(

(fzninput->token, &value) )

1317

assert( fzninput->hasdot ==

);

1333

assert(fzninput !=

);

1352 syntaxError

(

, fzninput,

"expecting at least a semicolon to close the statement"

);

1357 if

(

(fzninput->token,

'['

) )

1415

*lhs = sidevalue + 1.0;

1420

*rhs = sidevalue - 1.0;

1423 syntaxError

(

, fzninput,

"unknown relation in constraint identifier name"

);

1439

assert(selements > 0);

1450 if

(selements == *nelements)

1497 if

( !

(fzninput->token, lb) )

1524 if

( fzninput->hasdot != (*type ==

FZN_FLOAT

) )

1526 SCIPwarningMessage

(

"lower bound and upper bound mismatch in value type, assume %s variable type\n"

1527

fzninput->hasdot ?

"an integer"

"a continuous"

);

1551

(*info)->size = size;

1556 syntaxError

(

, fzninput,

"expecting <(> after <output_array>"

);

1564 if

( fzninput->haserror )

1569 if

( nelements == size )

1574

(*info)->size = size;

1578

(*info)->lbs[nelements] = (int) lb;

1579

(*info)->ubs[nelements] = (int) ub;

1583

(*info)->ndims = nelements;

1602 if

( output !=

)

1627 syntaxError

(

, fzninput,

"expected at least a semicolon to close statement"

);

1634 else if

(

(fzninput->token,

"output_array"

) && output !=

)

1637

assert(info !=

);

1644 while

( !

(fzninput->token,

'='

) );

1678 else if

(

(fzninput->token,

"float"

) )

1682 else if

(

(fzninput->token,

"set"

) ||

(fzninput->token,

'{'

) )

1685

fzninput->valid =

;

1696 if

( fzninput->haserror )

1712 const char

* assignment

1728 if

( linkVar ==

)

1733

fixvalue = realvalue;

1734 else if

( constant !=

)

1735

fixvalue = constant->value;

1743 SCIP_CALL

(

(

"fixing"

, 1, &var, vals, fixvalue, fixvalue, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

1753 SCIP_CALL

(

(

"link"

, 2, vars, vals, 0.0, 0.0, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

1769 const char

* assignment

1780 if

( *constant !=

)

1783 if

( type != (*constant)->type )

1789

value = (*constant)->value;

1808

(*constant)->type = type;

1810

(*constant)->value = value;

1813 if

( fzninput->sconstants == fzninput->nconstants )

1815

assert(fzninput->sconstants > 0);

1816

fzninput->sconstants *= 2;

1820

assert(fzninput->sconstants > fzninput->nconstants);

1821

fzninput->constants[fzninput->nconstants] = *constant;

1822

fzninput->nconstants++;

1854

*isvararray =

;

1859

*isvararray =

;

1877

assert(fzninput !=

);

1878

assert(*nelements >= 0);

1879

assert(selements >= *nelements);

1914 syntaxError

(

, fzninput,

"expected token <[> for array dimension"

);

1921 if

( fzninput->haserror )

1924 if

( type !=

FZN_INT

|| left != 1.0 || right <= 0.0 )

1930

*nelements = (int) right;

1934 syntaxError

(

, fzninput,

"expected token <]> for array dimension"

);

1955

assert(fzninput !=

);

1975 SCIP_CALL

(

SCIPcreateVar

(

, &varcopy, name, lb, ub, 0.0, vartype, !(fzninput->dynamiccols), fzninput->dynamiccols,

) );

2019 for

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

2033 if

(

(fzninput->token,

'='

) )

2045 for

( v = 0; v < nvars && !

(fzninput); ++v )

2105 for

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

2131

fzninput->comment =

;

2154

assert(fzninput !=

);

2157

isvararray =

;

2164

assert(

(fzninput) || nelements > 0);

2177

assert(!output || info !=

);

2182 SCIPdebugMsg

(

"found <%s> array named <%s> of type <%s> and size <%d> with bounds [%g,%g] (output %u)\n"

2183

isvararray ?

"variable"

"constant"

, name,

2184

type ==

FZN_BOOL

"bool"

: type ==

FZN_INT

"integer"

"float"

, nelements, lb, ub, output);

2213

assert(fzninput !=

);

2246 if

(

(fzninput->token,

'='

) )

2273

assert(fzninput !=

);

2305 const char

* assignment

2308 if

(

(assignment, value) )

2319 if

( constant ==

)

2336

(*value) = constant->value;

2354

assert(*nvals <= sizevals);

2364 if

(

(fzninput->token,

'['

) )

2381 if

( sizevals <= *nvals + nelements )

2386 for

( c = 0; c < nelements && !

(fzninput); ++c )

2391

(*vals)[(*nvals)] = value;

2407 if

( constarray !=

)

2410 if

( sizevals <= *nvals + constarray->nconstants )

2415 for

( c = 0; c < constarray->nconstants; ++c )

2417

(*vals)[(*nvals)] = constarray->constants[c]->value;

2431 if

( vararray ==

)

2438 if

( sizevals <= *nvals + vararray->nvars )

2443 for

( c = 0; c < vararray->nvars; ++c )

2447

var = vararray->vars[c];

2448

assert(var !=

);

2457 syntaxError

(

, fzninput,

"variable array contains unfixed variable"

);

2480

assert(*nvars <= sizevars);

2489 if

(

(fzninput->token,

'['

) )

2502 if

( sizevars <= *nvars + nelements )

2507 for

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

2511 if

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

)

2523 if

( constant !=

)

2526

value = constant->value;

2528 else if

(elements[v], &value) )

2532

tmptoken = fzninput->token;

2533

fzninput->token = elements[v];

2534 syntaxError

(

, fzninput,

"expected variable name or constant"

);

2536

fzninput->token = tmptoken;

2555 if

( vararray !=

)

2557

assert(vararray !=

);

2560 if

( sizevars <= *nvars + vararray->nvars )

2565 for

( v = 0; v < vararray->nvars; ++v )

2567

(*vars)[(*nvars)] = vararray->vars[v];

2594

assert(nelements == 3);

2608 for

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

2614 if

( vars[v] ==

)

2624 if

( vars[0] !=

&& vars[1] !=

)

2630 if

( vars[2] !=

)

2635 SCIP_CALL

(

createQuadraticCons

(

, name, 1, &vars[2], &linval, 1, &vars[0], &vars[1], &quadval, rhs, rhs,

2636

fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

2641 SCIP_CALL

(

createQuadraticCons

(

, name, 0,

, 1, &vars[0], &vars[1], &quadval, rhs, rhs,

2642

fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows));

2645 else if

( vars[0] !=

|| vars[1] !=

)

2651 if

( vars[0] ==

)

2660 if

( vars[2] !=

)

2672 SCIP_CALL

(

(

, name, nvars, vars, vals, rhs, rhs, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

2679

rhs = rhs - vals[0]*vals[1];

2682 if

( vars[2] !=

)

2686 SCIP_CALL

(

(

, name, 1, &vars[2], &val, rhs, rhs, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

2730

assert(nelements == 3 || nelements == 2);

2748 if

( vars[nvars] ==

)

2763 if

( vars[nvars] ==

)

2790 if

( vars[nvars] ==

)

2804 SCIP_CALL

(

(

, name, nvars, vars, vals, rhs, rhs, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

2835

assert(nnames == 2);

2859

assert(fzninput !=

);

2877

assert(fzninput !=

);

2883

fzninput->valid =

;

2894

assert(fzninput !=

);

2900

fzninput->valid =

;

2901 SCIPwarningMessage

(

"Line %d: array operations are not supported yet.\n"

, fzninput->linenumber);

2911

assert(fzninput !=

);

2917 if

(

(ftokens[0],

"bool"

) && nftokens == 2 )

2947 for

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

2951 if

( vars[v] ==

)

2993

fzninput->valid =

;

3010 else if

(

(ftokens[1],

"bool"

) && nftokens == 3 )

3022

fzninput->valid =

;

3091

fzninput->valid =

;

3106

assert(fzninput !=

);

3109 if

(

(ftokens[nftokens - 1],

"reif"

) )

3112

fzninput->valid =

;

3131 if

( strlen(ftokens[nftokens - 1]) != 2 && nftokens != 2 )

3138

fzninput->valid =

;

3146

fzninput->valid =

;

3154 SCIPwarningMessage

(

"constraints with '<' or '>' relation and continuous variables are not supported\n"

);

3155

fzninput->valid =

;

3168

assert(nftokens == 3);

3221 SCIP_CALL

(

(

, fname, nvars, vars, vals, lhs, rhs, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

3230

assert(nftokens == 2);

3236

assert(nftokens == 2);

3241

assert(nftokens == 2);

3266

assert(fzninput !=

);

3283 SCIP_CALL

( SCIPcreateConsAlldifferent(

, &cons, fname, nvars, vars,

3307 int

* durations =

;

3308 int

* demands =

;

3320

assert(fzninput !=

);

3351 for

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

3352

durations[i] = (

int

)vals[i];

3367 for

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

3368

demands[i] = (

int

)vals[i];

3384

capacity = (int)val;

3386

assert(nvars == ndurations);

3387

assert(nvars == ndemads);

3414

createCoercionOpCons,

3416

createLogicalOpCons,

3418

createComparisonOpCons,

3419

createAlldifferentOpCons,

3420

createCumulativeOpCons

3446

assert(fzninput !=

);

3461 SCIP_CALL

(

(

"fixing"

, 1, &var, vals, 1.0, 1.0, fzninput->initialconss, fzninput->dynamicconss, fzninput->dynamicrows) );

3468 syntaxError

(

, fzninput,

"expected constraint identifier name"

);

3485 while

( token !=

)

3496

assert(token ==

|| tokens[0] !=

);

3497 for

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

3508 SCIP_CALL

( constypes[c](

, fzninput, fname, tokens, ntokens, &created) );

3512 if

( !

(fzninput) && !created )

3514

fzninput->valid =

;

3515 SCIPwarningMessage

(

"Line %d: Constraint <%s> is not supported yet.\n"

, fzninput->linenumber, fname);

3519 for

( i = ntokens - 1; i >= 0 ; --i )

3539

assert(fzninput !=

);

3558 while

( !

(fzninput->token,

"satisfy"

)

3560

&& !

(fzninput->token,

"maximize"

) );

3580

assert(

(fzninput->token,

"maximize"

));

3597 else if

( constant !=

)

3599 SCIPdebugMsg

(

"optimizing a constant is equal to a satisfiability problem!\n"

);

3661

assert(nvars <= nvals);

3675

assert( nvars == nvals );

3677 for

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

3688 syntaxError

(

, fzninput,

"unknown identifier expression for a objective function"

);

3701 const char

* filename

3705

assert(readerdata !=

);

3706

assert(fzninput !=

);

3709

fzninput->file =

SCIPfopen

(filename,

"r"

);

3710 if

( fzninput->file ==

)

3730 if

(

(fzninput->token,

"predicate"

) )

3735 else if

(

(fzninput->token,

"array"

) )

3740 else if

(

(fzninput->token,

"constraint"

) )

3750 else if

(

(fzninput->token,

"float"

) )

3755 else if

(

(fzninput->token,

"bool"

) )

3764

fzninput->valid =

;

3767 else if

(

(fzninput->token,

"solve"

) )

3777 else if

(

(fzninput->token,

"output"

) )

3815 if

( fzninput->comment )

3877

assert(vars !=

);

3879

assert(nvars !=

);

3880

assert(*vars !=

|| *nvars == 0);

3882

assert(constant !=

);

3888 if

( requiredsize > *nvars )

3894

assert( requiredsize <= *nvars );

3906 for

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

3916

*constant += (*scalars)[v];

3917

(*scalars)[v] *= -1.0;

3934

assert( buffer !=

);

3936 if

( bufferpos > 0 )

3938

buffer[bufferpos] =

'\0'

;

3951 const char

* extension

3958

assert( buffer !=

);

3959

assert( bufferlen !=

);

3960

assert( bufferpos !=

);

3961

assert( extension !=

);

3964

extlen = (int)strlen(extension);

3965

newpos = (*bufferpos) + extlen;

3966 if

( newpos >= (*bufferlen) )

3968

*bufferlen =

MAX

( newpos, 2 * (*bufferlen) );

3974

(void)

SCIPstrncpy

((*buffer) + (*bufferpos), extension, extlen + 1);

3975

*bufferpos = newpos;

4013

assert( vars !=

|| nvars == 0 );

4014

assert( strcmp(type,

"eq"

) == 0 || strcmp(type,

"le"

) == 0 || strcmp(type,

"ge"

) == 0 );

4017 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos),

"constraint "

) );

4022 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos), buffer) );

4025 for

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

4034 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos), buffer) );

4048 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos), buffer) );

4051 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos),

"], ["

) );

4054 for

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

4057

assert( var !=

);

4063 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos), buffer) );

4069

assert(vars !=

);

4076 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos),buffer) );

4079 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos),

"], "

) );

4092 SCIP_CALL

(

(

, &(fznoutput->consbuffer), &(fznoutput->consbufferlen), &(fznoutput->consbufferpos),buffer) );

4115 int

nactivevars = 0;

4122

assert( vars !=

|| nvars == 0 );

4123

assert( fznoutput !=

);

4124

assert( lhs <= rhs );

4132

nactivevars = nvars;

4144 for

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

4145

activevals[v] = 1.0;

4154 if

( mayhavefloats )

4163 for

( v = 0; v < nactivevars && !hasfloats; v++ )

4167

assert(activevars != 0);

4168

var = activevars[v];

4177 for

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

4182

assert(activevars != 0);

4183

var = activevars[v];

4188 if

( idx < fznoutput->ndiscretevars && !fznoutput->varhasfloat[idx] )

4193 SCIP_CALL

(

(

, &(fznoutput->varbuffer), &(fznoutput->varbufferlen), &(fznoutput->varbufferpos),buffer) );

4196 SCIP_CALL

(

(

, &(fznoutput->castbuffer), &(fznoutput->castbufferlen), &(fznoutput->castbufferpos),buffer) );

4198

fznoutput->varhasfloat[idx] =

;

4209 SCIP_CALL

(

printRow

(

, fznoutput,

"eq"

, activevars, activevals, nactivevars, rhs - activeconstant, hasfloats) );

4216 SCIP_CALL

(

printRow

(

, fznoutput,

"ge"

, activevars, activevals, nactivevars, lhs - activeconstant, hasfloats) );

4222 SCIP_CALL

(

printRow

(

, fznoutput,

"le"

, activevars, activevals, nactivevars, rhs - activeconstant, hasfloats) );

4259 const char

* conshdlrname;

4278 const int

ndiscretevars = nbinvars+nintvars;

4289 SCIPinfoMessage

(

, file,

"%% Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n"

4290

nvars, nbinvars, nintvars, nimplvars, ncontvars);

4301 for

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

4304

assert( var !=

);

4330 if

( v < ndiscretevars )

4360

assert( v >= nbinvars );

4363 if

( v < ndiscretevars )

4371

boundedvars[nboundedvars] = v;

4377

boundedvars[nboundedvars] = v;

4385

fznoutput.ndiscretevars = ndiscretevars;

4386

fznoutput.varbufferpos = 0;

4387

fznoutput.consbufferpos = 0;

4388

fznoutput.castbufferpos = 0;

4398 for

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

4399

fznoutput.varhasfloat[v] =

;

4400

fznoutput.varbuffer[0] =

'\0'

;

4401

fznoutput.consbuffer[0] =

'\0'

;

4402

fznoutput.castbuffer[0] =

'\0'

;

4405 for

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

4408

assert( cons !=

);

4414

assert( conshdlr !=

);

4422 if

( strcmp(conshdlrname,

"linear"

) == 0 )

4428 else if

( strcmp(conshdlrname,

"setppc"

) == 0 )

4438

consvars,

, nconsvars, 1.0, 1.0, transformed,

) );

4450 else if

( strcmp(conshdlrname,

"logicor"

) == 0 )

4456 else if

( strcmp(conshdlrname,

"knapsack"

) == 0 )

4466 for

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

4474 else if

( strcmp(conshdlrname,

"varbound"

) == 0 )

4487

consvars, consvals, 2,

4493 else if

( strcmp(conshdlrname,

"cumulative"

) == 0 )

4500 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos),

"cumulative(["

) );

4502 for

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

4504 if

( v < nconsvars - 1)

4509 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos), varname) );

4512 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos),

"], ["

) );

4516 for

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

4518 if

( v < nconsvars - 1)

4523 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos), buffy) );

4526 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos),

"], ["

) );

4530 for

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

4532 if

( v < nconsvars - 1)

4537 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos), buffy) );

4541 SCIP_CALL

(

(

, &(fznoutput.consbuffer), &(fznoutput.consbufferlen), &(fznoutput.consbufferpos), buffy) );

4555 for

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

4567

intobjvars[nintobjvars] = v;

4568 SCIPdebugMsg

(

"variable <%s> at pos <%d,%d> has an integral obj: %f=%f*%f\n"

4575 if

( v < ndiscretevars && !fznoutput.varhasfloat[v] )

4580 SCIP_CALL

(

(

, &(fznoutput.varbuffer), &(fznoutput.varbufferlen), &(fznoutput.varbufferpos),buffer) );

4583 SCIP_CALL

(

(

, &(fznoutput.castbuffer), &(fznoutput.castbufferlen), &(fznoutput.castbufferpos),buffer) );

4585

fznoutput.varhasfloat[v] =

;

4588

floatobjvars[nfloatobjvars] = v;

4595 if

( fznoutput.varbufferpos > 0 )

4598 writeBuffer

(

, file, fznoutput.varbuffer, fznoutput.varbufferpos );

4602 if

( fznoutput.castbufferpos > 0 )

4605 writeBuffer

(

, file, fznoutput.castbuffer, fznoutput.castbufferpos );

4608 if

( nboundedvars > 0 )

4612 for

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

4614

var = vars[boundedvars[v]];

4647 if

( fznoutput.consbufferpos > 0 )

4650 writeBuffer

(

, file, fznoutput.consbuffer, fznoutput.consbufferpos );

4656 if

( nintobjvars > 0 || nfloatobjvars > 0 || !

SCIPisZero

(

, objoffset) )

4661 for

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

4664

var = vars[intobjvars[v]];

4675 for

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

4694 for

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

4699 for

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

4700 SCIPinfoMessage

(

, file,

"%s%s%s"

SCIPvarGetName

(vars[floatobjvars[v]]), floatobjvars[v] < ndiscretevars ?

"_float"

""

, v < nfloatobjvars-1 ?

", "

""

);

4734

assert(reader !=

);

4752

assert(readerdata !=

);

4755 for

( v = 0; v < readerdata->nvararrays; ++v )

4777

fzninput.file =

;

4779

fzninput.linebuf[0] =

'\0'

;

4782

fzninput.token[0] =

'\0'

;

4789

fzninput.npushedtokens = 0;

4790

fzninput.linenumber = 1;

4791

fzninput.bufpos = 0;

4792

fzninput.linepos = 0;

4794

fzninput.comment =

;

4795

fzninput.haserror =

;

4796

fzninput.valid =

;

4797

fzninput.vararrays =

;

4798

fzninput.nvararrays = 0;

4799

fzninput.vararrayssize = 0;

4800

fzninput.constarrays =

;

4801

fzninput.nconstarrays = 0;

4802

fzninput.constarrayssize = 0;

4810

hashGetKeyVar, SCIPhashKeyEqString, SCIPhashKeyValString,

) );

4813

hashGetKeyConstant, SCIPhashKeyEqString, SCIPhashKeyValString,

) );

4816

fzninput.nconstants = 0;

4817

fzninput.sconstants = 10;

4823 for

( i = fzninput.nconstants - 1; i >= 0; --i )

4841 for

( i = 0; i < fzninput.nvararrays; ++i )

4848 for

( i = 0; i < fzninput.nconstarrays; ++i )

4857 if

( fzninput.haserror || ! fzninput.valid )

4873

nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) );

4883 for

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

4885 const char

* varname;

4889

length = strlen(varname);

4893 SCIPwarningMessage

(

"The name of variable <%d>: \"%s\" is not conform to the fzn standard.\n"

, i, varname);

4898

legal = (strncmp(&varname[length-6],

"_float"

,6) != 0);

4901 SCIPwarningMessage

(

"The name of variable <%d>: \"%s\" ends with \"_float\" which is not supported.\n"

, i, varname);

4910

nvars, nbinvars, nintvars, nimplvars, ncontvars, conss, nconss, result) );

4912 else if

( transformed )

4977

assert(reader !=

);

4980

assert(readerdata !=