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__sto_8c_source.php below:

SCIP Doxygen Documentation: reader_sto.c Source File

60#define READER_NAME "storeader" 61#define READER_DESC "file reader for stochastic information of stochastic programs in the SMPS file format" 62#define READER_EXTENSION "sto" 64#define DEFAULT_USEBENDERS FALSE 70#define STO_MAX_LINELEN 1024 71#define STO_MAX_NAMELEN 256 73#define STO_DEFAULT_ARRAYSIZE 100 74#define STO_DEFAULT_ENTRIESSIZE 20 75#define STO_DEFAULT_BLOCKARRAYSIZE 5 76#define STO_DEFAULT_CHILDRENSIZE 5 173

(*scenariodata)->scip =

NULL

;

174

(*scenariodata)->subproblems =

NULL

;

175

(*scenariodata)->parent =

NULL

;

176

(*scenariodata)->nchildren = 0;

178

(*scenariodata)->nsubproblems = 0;

179

(*scenariodata)->stagenum = -1;

180

(*scenariodata)->scenarionum = -1;

181

(*scenariodata)->stagename =

NULL

;

182

(*scenariodata)->name =

NULL

;

183

(*scenariodata)->probability = 1.0;

185

(*scenariodata)->nentries = 0;

207

assert(scenariotree !=

NULL

);

208

assert(*scenariotree !=

NULL

);

210 SCIPdebugMessage

(

"Freeing scenario <%s> in stage <%s>\n"

, (*scenariotree)->name,

211

(*scenariotree)->stagename);

214

nchildren = (*scenariotree)->nchildren;

216 while

( (*scenariotree)->nchildren > 0 )

219

(*scenariotree)->nchildren--;

222 for

( i = (*scenariotree)->nentries - 1; i >= 0; i-- )

237 for

( i = (*scenariotree)->nsubproblems - 1; i >= 0; i-- )

241 if

( nchildren > 0 && (*scenariotree)->subproblems !=

NULL

)

256

assert(scenario !=

NULL

);

268

assert(scenario !=

NULL

);

270 return

scenario->

scip

;

281

assert(scenario !=

NULL

);

295

assert(scenario !=

NULL

);

296

assert(subproblem !=

NULL

);

310

assert(scenario !=

NULL

);

321

assert(scenario !=

NULL

);

333

assert(scenario !=

NULL

);

334

assert(childnum >= 0 && childnum < scenario->nchildren);

336 return

scenario->

children

[childnum];

345

assert(scenario !=

NULL

);

347 return

scenario->

parent

;

355 const char

* stagename

359

assert(scenario !=

NULL

);

374

assert(scenario !=

NULL

);

388

assert(scenario !=

NULL

);

403

assert(scenario !=

NULL

);

417

assert(scenario !=

NULL

);

430

assert(scenario !=

NULL

);

432 return

scenario->

name

;

444

assert(scenario !=

NULL

);

459

assert(scenario !=

NULL

);

473

assert(scenario !=

NULL

);

488

assert(scenario !=

NULL

);

502

assert(scenario !=

NULL

);

517

assert(scenario !=

NULL

);

527 const char

* rowname,

528 const char

* colname,

533

assert(scenario !=

NULL

);

560

assert(scenario !=

NULL

);

572

assert(scenario !=

NULL

);

573

assert(entry >= 0 && entry < scenario->nentries);

585

assert(scenario !=

NULL

);

586

assert(entry >= 0 && entry < scenario->nentries);

598

assert(scenario !=

NULL

);

599

assert(entry >= 0 && entry < scenario->nentries);

601 return

scenario->

values

[entry];

620

assert(sourcescenario !=

NULL

);

621

assert(targetscenario !=

NULL

);

633 for

( i = 0; i < sourcescenario->

nentries

; i++ )

635

sourcescenario->

values

[i]) );

661

assert(scenario1 !=

NULL

);

662

assert(mergedscenario !=

NULL

);

665 for

( i = 0; i < scenario1->

nentries

; i++ )

667

scenario1->

values

[i]) );

686

assert(parent !=

NULL

);

687

assert((*parent) !=

NULL

);

688

assert(child !=

NULL

);

690 if

( (*parent)->nchildren + 1 > (*parent)->childrensize )

692

(*parent)->nchildren + 1) );

696

scenario->

parent

= (*parent);

698

(*parent)->

children

[(*parent)->nchildren] = scenario;

719

assert(scenariotree !=

NULL

);

720

assert(stage >= 0 && stage < numstages);

723 for

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

728

assert(i < numstages);

733 for

( i = 0; i < numscenarios[stageindex]; i++ )

739 if

( stage < numstages - 1 )

757 int

numscenariostages

763

assert(readerdata !=

NULL

);

764

assert(scenarios !=

NULL

);

770 for

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

771

readerdata->numscenarios += numscenarios[i];

781 const char

* scenname

795 if

( retscen !=

NULL

)

816

assert(readerdata !=

NULL

);

817

assert(scenario !=

NULL

);

825

readerdata->numscenarios++;

838 int

* numblocksforscen,

840 int

* numblocksperblock,

853

assert(blocks !=

NULL

);

854

assert(scenarios !=

NULL

);

855

assert(blocksforscen !=

NULL

);

859 while

( !processed && i < numblocks )

866 for

( j = 0; j < numblocksperblock[i]; j++ )

869

(*blocksforscen)[(*numblocksforscen)] = blocks[i][j];

870

(*numblocksforscen)++;

872

numblocksperblock, numscenarios, scenariossize, stage, stagenum + 1, i) );

875

(*numblocksforscen)--;

888 if

( i == numblocks )

893 if

( (*numscenarios) + 1 > (*scenariossize) )

898

(*scenariossize) = newsize;

912 if

( (*numblocksforscen) == 1 )

917 for

( i = 1; i < (*numblocksforscen); i++ )

935 int

* numblocksperblock,

943 int

numblocksforscen;

950

assert(blocks !=

NULL

);

956 for

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

969 for

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

971

numblocksforscen = 0;

978

numblocks, numblocksperblock, &numscenarios[stagenum], &scenariossize[stagenum],

991 for

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

993 for

( j = numscenarios[i] - 1; j >= 0; j-- )

1012

assert(readerdata !=

NULL

);

1032

assert(readerdata !=

NULL

);

1035 if

( readerdata->scenariotree !=

NULL

)

1051

assert(stoi !=

NULL

);

1059

(*stoi)->lineno = 0;

1060

(*stoi)->haserror =

FALSE

;

1061

(*stoi)->buf [0] =

'\0'

;

1062

(*stoi)->probname[0] =

'\0'

;

1063

(*stoi)->stochtype[0] =

'\0'

;

1064

(*stoi)->f0 =

NULL

;

1065

(*stoi)->f1 =

NULL

;

1066

(*stoi)->f2 =

NULL

;

1067

(*stoi)->f3 =

NULL

;

1068

(*stoi)->f4 =

NULL

;

1069

(*stoi)->f5 =

NULL

;

1070

(*stoi)->f6 =

NULL

;

1091

assert(stoi !=

NULL

);

1102

assert(stoi !=

NULL

);

1113

assert(stoi !=

NULL

);

1124

assert(stoi !=

NULL

);

1135

assert(stoi !=

NULL

);

1146

assert(stoi !=

NULL

);

1157

assert(stoi !=

NULL

);

1168

assert(stoi !=

NULL

);

1179

assert(stoi !=

NULL

);

1190

assert(stoi !=

NULL

);

1202

assert(stoi !=

NULL

);

1214

assert(stoi !=

NULL

);

1226

assert(stoi !=

NULL

);

1240

assert(stoi !=

NULL

);

1252

assert(stoi !=

NULL

);

1268 for

(i = pos; i < 80; i++)

1288

stoi->

f0

= stoi->

f1

= stoi->

f2

= stoi->

f3

= stoi->

f4

= stoi->

f5

= stoi->

f6

= 0;

1299 while

( *stoi->

buf

==

'*'

);

1302

len = (

unsigned

int) strlen(stoi->

buf

);

1304 for

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

1306 if

( (stoi->

buf

[i] ==

'\t'

) || (stoi->

buf

[i] ==

'\n'

) || (stoi->

buf

[i] ==

'\r'

) )

1315

assert(strlen(stoi->

buf

) >= 80);

1322

assert(stoi->

f0

!= 0);

1329

s = &stoi->

buf

[1];

1377 while

( is_marker || is_empty );

1389

assert(stoi !=

NULL

);

1454 int

* numblocksperblock;

1456 int

* blocksperblocksize;

1529 for

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

1543 if

( numblocksperblock[blocknum] + 1 > blocksperblocksize[blocknum] )

1548

blocksperblocksize[blocknum] = newsize;

1554 if

( numblocks + 1 > blockssize )

1561

blockssize = newsize;

1565

numblocksperblock[blocknum] = 0;

1569

blockindex = numblocksperblock[blocknum];

1577

numblocksperblock[blocknum]++;

1593 for

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

1595 for

( j = numblocksperblock[i] - 1; j >= 0; j-- )

1599 for

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

1619 char

wrongroot[] =

"\'ROOT\'"

;

1642

addscenario =

FALSE

;

1691

assert(scenario ==

NULL

);

1708 if

( strstr(scennames, parentname) ==

NULL

)

1736

addscenario =

TRUE

;

1738 else if

( addscenario )

1762 int

* numblocksperblock;

1764 int

* blocksperblocksize;

1833 if

( strstr(stagenames, currstagename) ==

NULL

)

1841

foundblock =

FALSE

;

1844 for

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

1858 if

( numblocksperblock[blocknum] + 1 > blocksperblocksize[blocknum] )

1863

blocksperblocksize[blocknum] = newsize;

1869 if

( numblocks + 1 > blockssize )

1876

blockssize = newsize;

1880

numblocksperblock[blocknum] = 0;

1884

blockindex = numblocksperblock[blocknum];

1892

numblocksperblock[blocknum]++;

1905 for

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

1907 for

( j = numblocksperblock[i] - 1; j >= 0; j-- )

1911 for

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

1932

assert(scenario !=

NULL

);

1935

checkscen = scenario;

1937 while

( checkscen !=

NULL

)

1950 const char

* varname,

1977

assert(scenario !=

NULL

);

1978

assert(vars !=

NULL

);

1983 for

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

2032

assert(scenario !=

NULL

);

2033

assert(consvar !=

NULL

);

2034

assert(scenariovar !=

NULL

);

2036

(*scenariovar) =

NULL

;

2038

checkscen = scenario;

2043 while

( (*scenariovar) ==

NULL

)

2045

assert(checkscen !=

NULL

);

2057 if

( (*scenariovar) ==

NULL

)

2083

assert(scenario !=

NULL

);

2084

assert(consvar !=

NULL

);

2086

(*varadded) =

FALSE

;

2089

checkscen = scenario;

2092 while

( searchvar ==

NULL

&& checkcount < 2 )

2094

assert(checkscen !=

NULL

);

2103 if

( searchvar !=

NULL

)

2105

(*scenariovar) = searchvar;

2115 if

( searchvar !=

NULL

)

2125

(*scenariovar) = var;

2126

(*varadded) =

TRUE

;

2137 SCIP

* scenarioscip,

2151

assert(scenarioscip !=

NULL

);

2152

assert(scenario !=

NULL

);

2153

assert(conss !=

NULL

);

2157 for

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

2185 if

( !success1 || !success2 )

2187 SCIPerrorMessage

(

"It is not possible to copy constraint <%s>. The stochastic program can not be built.\n"

,

2193

assert(consvars !=

NULL

);

2194 for

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

2198

scenariovar =

NULL

;

2207 if

( scenariovar !=

NULL

)

2240 SCIPerrorMessage

(

"It is not possible to copy constraint <%s>. The stochastic program can not be built.\n"

,

2260 SCIP

* scenarioscip;

2275

assert(scenario !=

NULL

);

2280 SCIPerrorMessage

(

"Unable to build stochastic program - stage <%s> was not found\n"

,

2321

scenarioscip =

scip

;

2367 for

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

2371 char RHS

[] =

"RHS"

;

2372 char

rhs[] =

"rhs"

;

2373 char RIGHT

[] =

"RIGHT"

;

2374 char

MINI[] =

"MINI"

;

2375 char

obj[] =

"obj"

;

2376 char

OBJ[] =

"OBJ"

;

2390 SCIPerrorMessage

(

"There is no constraint <%s> in the current scenario.\n"

, name);

2417 SCIPerrorMessage

(

"There is no variable <%s> in the current scenario.\n"

, name);

2430 SCIPerrorMessage

(

"There is no constraint <%s> in the current scenario.\n"

, name);

2448 SCIPerrorMessage

(

"There is no variable <%s> in the current scenario.\n"

, name);

2482 for

( i = 1; i < numstages; i++ )

2490 for

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

2497 for

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

2521

assert(readerdata !=

NULL

);

2546

assert(readerdata !=

NULL

);

2599 const char

* filename,

2610

assert(filename !=

NULL

);

2628 SCIPinfoMessage

(

scip

,

NULL

,

"\nSorry, currently only STO files with the stochastic information as DISCRETE are supported.\n\n"

);

2629 SCIPinfoMessage

(

scip

,

NULL

,

"NOTE: The problem provided by the COR file is loaded without stochastic information.\n\n"

);

2630

unsupported =

TRUE

;

2645 SCIPinfoMessage

(

scip

,

NULL

,

"\nThe scenarios for the stochastic programs are defined in <%s> as SCENARIOS\n"

, filename);

2646 SCIPinfoMessage

(

scip

,

NULL

,

"Sorry, currently only two-stage stochastic programs are supported when scenarios are defined as SCENARIOS.\n\n"

);

2647 SCIPinfoMessage

(

scip

,

NULL

,

"NOTE: The problem provided by the COR file is loaded without stochastic information.\n\n"

);

2648

unsupported =

TRUE

;

2667 if

( !error && !unsupported )

2669 if

( readerdata->usebenders )

2700

assert(reader !=

NULL

);

2717

assert(readerdata !=

NULL

);

2731

assert(reader !=

NULL

);

2737 if

( correader ==

NULL

)

2744 if

( timreader ==

NULL

)

2786

readerdata->scenariotree =

NULL

;

2787

readerdata->numscenarios = 0;

2800 "should Benders' decomposition be used?"

,

2810 const char

* filename,

2819

assert(result !=

NULL

);

2822

assert(reader !=

NULL

);

2850

assert(reader !=

NULL

);

2854

assert(readerdata !=

NULL

);

2856 return

readerdata->numscenarios;

default Benders' decomposition plugin

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

#define SCIP_CALL_TERMINATE(retcode, x, TERM)

#define SCIP_CALL_FINALLY(x, y)

SCIP_FILE * SCIPfopen(const char *path, const char *mode)

int SCIPfclose(SCIP_FILE *fp)

char * SCIPfgets(char *s, int size, SCIP_FILE *stream)

SCIP_RETCODE SCIPcreateBendersDefault(SCIP *scip, SCIP **subproblems, int nsubproblems)

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)

SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)

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

SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, 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_Bool global, SCIP_Bool *valid)

void SCIPenableDebugSol(SCIP *scip)

int SCIPstoGetNScenarios(SCIP *scip)

SCIP_Bool SCIPcorHasRead(SCIP_READER *reader)

SCIP_RETCODE SCIPreadSto(SCIP *scip, const char *filename, SCIP_RESULT *result)

SCIP_RETCODE SCIPincludeReaderSto(SCIP *scip)

SCIP_RETCODE SCIPfree(SCIP **scip)

SCIP_RETCODE SCIPcreate(SCIP **scip)

SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)

const char * SCIPgetProbName(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)

SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)

SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)

SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)

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

SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)

SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)

SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

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

SCIP_BENDERS * SCIPfindBenders(SCIP *scip, const char *name)

void SCIPbendersUpdateSubproblemLowerbound(SCIP_BENDERS *benders, int probnumber, SCIP_Real lowerbound)

SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

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

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)

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_READERDATA * SCIPreaderGetData(SCIP_READER *reader)

SCIP_READER * SCIPfindReader(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))

const char * SCIPreaderGetName(SCIP_READER *reader)

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

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)

SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)

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

SCIP_Bool SCIPvarIsRemovable(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,...)

void SCIPprintSysError(const char *message)

char * SCIPstrtok(char *s, const char *delim, char **ptrptr)

int SCIPmemccpy(char *dest, const char *src, char stop, unsigned int cnt)

memory allocation routines

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for managing constraints

wrapper functions to map file i/o to standard or zlib file i/o

struct SCIP_File SCIP_FILE

public methods for message output

public data structures and miscellaneous methods

public methods for input file readers

public methods for problem variables

COR file reader (MPS format of the core problem for stochastic programs)

#define DEFAULT_USEBENDERS

static SCIP_RETCODE readStoch(SCIP *scip, STOINPUT *stoi)

static SCIP_RETCODE readScenarios(STOINPUT *stoi, SCIP *scip, SCIP_READERDATA *readerdata)

static SCIP_RETCODE createScenarioData(SCIP *scip, STOSCENARIO **scenariodata)

static SCIP_RETCODE setScenarioProbability(SCIP *scip, STOSCENARIO *scenario, SCIP_Real probability)

static SCIP_Real getScenarioProbability(SCIP *scip, STOSCENARIO *scenario)

static void stoinputFree(SCIP *scip, STOINPUT **stoi)

static void stoinputSyntaxerror(STOINPUT *stoi)

static SCIP_Bool stoinputHasError(const STOINPUT *stoi)

static const char * getScenarioName(STOSCENARIO *scenario)

static SCIP_RETCODE removeCoreVariablesAndConstraints(SCIP *scip)

static void getScenarioEntityName(char *name, const char *varname, int stagenum, int scenarionum)

static SCIP_RETCODE readSto(SCIP *scip, const char *filename, SCIP_READERDATA *readerdata)

static void clearFrom(char *buf, unsigned int pos)

static void stoinputSetSection(STOINPUT *stoi, STOSECTION section)

static STOSTOCHINFO stoinputStochInfoType(const STOINPUT *stoi)

static SCIP ** getScenarioSubproblemArray(STOSCENARIO *scenario)

#define STO_DEFAULT_CHILDRENSIZE

static int getScenarioNChildren(STOSCENARIO *scenario)

static SCIP_RETCODE insertScenarioInReaderdata(SCIP *scip, SCIP_READERDATA *readerdata, STOSCENARIO *scenario, char *parentname)

static SCIP_RETCODE readBlocks(STOINPUT *stoi, SCIP *scip, SCIP_READERDATA *readerdata)

static SCIP_RETCODE createReaderdata(SCIP *scip, SCIP_READERDATA *readerdata)

static const char * stoinputField5(const STOINPUT *stoi)

static SCIP_RETCODE addScenarioConsToProb(SCIP *scip, SCIP *scenarioscip, STOSCENARIO *scenario, SCIP_HASHMAP *varmap, SCIP_CONS **conss, int nconss, SCIP_Bool decomp)

static SCIP_DECL_READERREAD(readerReadSto)

static SCIP_Real getScenarioEntryValue(STOSCENARIO *scenario, int entry)

static SCIP_RETCODE buildScenariosFromBlocks(SCIP *scip, STOSCENARIO ***blocks, STOSCENARIO ***scenarios, STOSCENARIO ***blocksforscen, int *numblocksforscen, int numblocks, int *numblocksperblock, int *numscenarios, int *scenariossize, const char *stage, int stagenum, int blocknum)

static int getScenarioStageNum(SCIP *scip, STOSCENARIO *scenario)

enum StoSection STOSECTION

static SCIP_RETCODE createScenarioSubproblemArray(SCIP *scip, STOSCENARIO *scenario)

enum StoStochInfo STOSTOCHINFO

static void setScenarioScip(STOSCENARIO *scenario, SCIP *scip)

static int getScenarioNum(SCIP *scip, STOSCENARIO *scenario)

static SCIP_RETCODE setScenarioStageName(SCIP *scip, STOSCENARIO *scenario, const char *stagename)

#define STO_DEFAULT_ARRAYSIZE

static SCIP_Bool stoinputReadLine(STOINPUT *stoi)

static const char * getScenarioEntryCol(STOSCENARIO *scenario, int entry)

static SCIP_RETCODE addScenarioVarsToProb(SCIP *scip, STOSCENARIO *scenario, SCIP_HASHMAP *varmap, SCIP_VAR **vars, int nvars)

static SCIP_RETCODE addScenarioEntry(SCIP *scip, STOSCENARIO *scenario, const char *rowname, const char *colname, SCIP_Real value)

#define STO_DEFAULT_ENTRIESSIZE

#define STO_DEFAULT_BLOCKARRAYSIZE

static const char * stoinputField4(const STOINPUT *stoi)

static void stoinputSetStochtype(STOINPUT *stoi, const char *stochtype)

static SCIP_RETCODE setScenarioLowerbound(SCIP *scip, STOSCENARIO *scenario, SCIP_Real lowerbound)

static SCIP_RETCODE stoinputCreate(SCIP *scip, STOINPUT **stoi, SCIP_FILE *fp)

static SCIP_RETCODE scenarioAddChild(SCIP *scip, STOSCENARIO **parent, STOSCENARIO *child)

static void addScenarioSubproblem(STOSCENARIO *scenario, SCIP *subproblem)

static const char * stoinputField2(const STOINPUT *stoi)

static SCIP_RETCODE createScenariosFromBlocks(SCIP *scip, SCIP_READERDATA *readerdata, STOSCENARIO ***blocks, int numblocks, int *numblocksperblock, int numstages)

static SCIP_RETCODE buildScenarioTree(SCIP *scip, STOSCENARIO **scenariotree, STOSCENARIO ***scenarios, int *numscenarios, int numstages, int stage)

static STOSECTION stoinputSection(const STOINPUT *stoi)

static void stoinputSetStochInfoType(STOINPUT *stoi, STOSTOCHINFO stochinfotype)

static SCIP_RETCODE buildDecompProblem(SCIP *scip, SCIP_READERDATA *readerdata)

static const char * stoinputField6(const STOINPUT *stoi)

static SCIP_RETCODE getScenarioDecompVar(SCIP *scip, STOSCENARIO *scenario, SCIP_VAR *consvar, SCIP_VAR **scenariovar, SCIP_Bool *varadded)

static SCIP_RETCODE addScenarioVarsAndConsToProb(SCIP *scip, STOSCENARIO *scenario, SCIP_Bool decomp)

static STOSCENARIO * findScenarioInTree(STOSCENARIO *scenariotree, const char *scenname)

static SCIP_RETCODE copyScenario(SCIP *scip, STOSCENARIO *sourcescenario, STOSCENARIO **targetscenario, SCIP_Bool copyname)

static SCIP_RETCODE freeReaderdata(SCIP *scip, SCIP_READERDATA *readerdata)

static const char * stoinputField0(const STOINPUT *stoi)

static SCIP_RETCODE setScenarioName(SCIP *scip, STOSCENARIO *scenario, const char *name)

static SCIP_RETCODE freeScenarioTree(SCIP *scip, STOSCENARIO **scenariotree)

static SCIP_RETCODE readIndep(STOINPUT *stoi, SCIP *scip, SCIP_READERDATA *readerdata)

static SCIP_DECL_READERFREE(readerFreeSto)

static void stoinputSetProbname(STOINPUT *stoi, const char *probname)

static SCIP_Real computeScenarioProbability(SCIP *scip, STOSCENARIO *scenario)

static SCIP_RETCODE setScenarioStageNum(SCIP *scip, STOSCENARIO *scenario, int stagenum)

static SCIP * getScenarioScip(STOSCENARIO *scenario)

static int getScenarioNEntries(STOSCENARIO *scenario)

static SCIP_Real getScenarioLowerbound(SCIP *scip, STOSCENARIO *scenario)

static SCIP_RETCODE findScenarioVar(SCIP *scip, STOSCENARIO *scenario, SCIP_VAR *consvar, SCIP_VAR **scenariovar)

static STOSCENARIO * getScenarioChild(STOSCENARIO *scenario, int childnum)

static const char * getScenarioStageName(SCIP *scip, STOSCENARIO *scenario)

static SCIP_RETCODE mergeScenarios(SCIP *scip, STOSCENARIO *scenario1, STOSCENARIO **mergedscenario)

static SCIP_RETCODE buildFullProblem(SCIP *scip, SCIP_READERDATA *readerdata)

static SCIP_RETCODE addScenariosToReaderdata(SCIP *scip, SCIP_READERDATA *readerdata, STOSCENARIO ***scenarios, int *numscenarios, int numscenariostages)

static const char * stoinputField1(const STOINPUT *stoi)

static SCIP_RETCODE setScenarioNum(SCIP *scip, STOSCENARIO *scenario, int scenarionum)

static SCIP_DECL_READERCOPY(readerCopySto)

static const char * getScenarioEntryRow(STOSCENARIO *scenario, int entry)

static STOSCENARIO * getScenarioParent(STOSCENARIO *scenario)

static const char * stoinputField3(const STOINPUT *stoi)

STO file reader - the stochastic information of an instance in SMPS format.

int SCIPtimFindStage(SCIP *scip, const char *stage)

int SCIPtimGetStageNVars(SCIP *scip, int stagenum)

SCIP_VAR ** SCIPtimGetStageVars(SCIP *scip, int stagenum)

SCIP_Bool SCIPtimHasRead(SCIP_READER *reader)

int SCIPtimGetNStages(SCIP *scip)

const char * SCIPtimGetStageName(SCIP *scip, int stagenum)

SCIP_CONS ** SCIPtimGetStageConss(SCIP *scip, int stagenum)

int SCIPtimGetStageNConss(SCIP *scip, int stagenum)

const char * SCIPtimConsGetStageName(SCIP *scip, const char *consname)

TIM file reader - the stage information for a stochastic programming instance in SMPS format.

public methods for constraint handler plugins and constraints

public methods for debugging

public methods for memory management

public methods for message handling

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

SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)

char buf[STO_MAX_LINELEN]

char probname[STO_MAX_NAMELEN]

STOSTOCHINFO stochinfotype

char stochtype[STO_MAX_NAMELEN]

struct SCIP_ReaderData SCIP_READERDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

enum SCIP_Vartype SCIP_VARTYPE

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