A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: sol.c Source File

115

assert(sol !=

NULL

);

154

assert(sol !=

NULL

);

206

assert(sol !=

NULL

);

207

assert(var !=

NULL

);

267

assert(sol !=

NULL

);

268

assert(stat !=

NULL

);

298

assert(sol !=

NULL

);

299

assert(blkmem !=

NULL

);

300

assert(stat !=

NULL

);

308

(*sol)->primalindex = -1;

310

(*sol)->hasinfval =

FALSE

;

336

assert(sol !=

NULL

);

337

assert(blkmem !=

NULL

);

338

assert(stat !=

NULL

);

345

(*sol)->primalindex = -1;

347

(*sol)->hasinfval =

FALSE

;

371

assert(sol !=

NULL

);

372

assert(sourcesol !=

NULL

);

379 switch

( sourcesol->

type

)

385

(*sol)->type = sourcesol->

type

;

397

(*sol)->obj = sourcesol->

obj

;

398

(*sol)->primalindex = -1;

399

(*sol)->time = sourcesol->

time

;

401

(*sol)->lpcount = sourcesol->

lpcount

;

403

(*sol)->nodenum = sourcesol->

nodenum

;

404

(*sol)->solorigin = sourcesol->

solorigin

;

405

(*sol)->runnum = sourcesol->

runnum

;

406

(*sol)->depth = sourcesol->

depth

;

408

(*sol)->hasinfval = sourcesol->

hasinfval

;

438

assert(sol !=

NULL

);

439

assert(transsol !=

NULL

);

445

assert(tsol !=

NULL

);

452

tmpvals = sol->

vals

;

453

tmpvalid = sol->

valid

;

456

tsol->

vals

= tmpvals;

457

tsol->

valid

= tmpvalid;

488

assert(sol !=

NULL

);

489

assert(prob !=

NULL

);

497 if

( nimplvars == 0 )

501

nimplvars = nbinvars + nintvars + nimplvars;

504 for

( v = nbinvars + nintvars; v < nimplvars; ++v )

536 else if

( uselprows )

551 for

(

r

= 0;

r

< nrows && !(roundup && rounddown); ++

r

)

583 if

( roundup == rounddown )

585

rounddown = ndownlocks <= nuplocks;

586

roundup = !rounddown;

620

assert(sol !=

NULL

);

642

assert(sol !=

NULL

);

643

assert(nlp !=

NULL

);

663

assert(sol !=

NULL

);

664

assert(relaxation !=

NULL

);

690

assert(sol !=

NULL

);

715

assert(tree !=

NULL

);

739

assert(sol !=

NULL

);

740

assert(blkmem !=

NULL

);

742

assert(stat !=

NULL

);

743

assert(primal !=

NULL

);

750

(*sol)->primalindex = -1;

752

(*sol)->hasinfval =

FALSE

;

776

assert(sol !=

NULL

);

777

assert(blkmem !=

NULL

);

778

assert(stat !=

NULL

);

785

(*sol)->primalindex = -1;

787

(*sol)->hasinfval =

FALSE

;

807

assert(sol !=

NULL

);

808

assert(*sol !=

NULL

);

829

assert(sol !=

NULL

);

830

assert(stat !=

NULL

);

831

assert(tree !=

NULL

);

857 for

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

885

assert(sol !=

NULL

);

886

assert(stat !=

NULL

);

887

assert(tree !=

NULL

);

888

assert(nlp !=

NULL

);

909 for

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

937

assert(sol !=

NULL

);

938

assert(stat !=

NULL

);

939

assert(tree !=

NULL

);

940

assert(relaxation !=

NULL

);

968

assert(sol !=

NULL

);

969

assert(stat !=

NULL

);

970

assert(tree !=

NULL

);

997

assert(tree !=

NULL

);

1020

assert(sol !=

NULL

);

1037

assert(sol !=

NULL

);

1056

assert(sol !=

NULL

);

1057

assert(prob !=

NULL

);

1065 for

( v = 0; v < prob->

nvars

; ++v )

1088

assert(sol !=

NULL

);

1089

assert(stat !=

NULL

);

1095

assert(var !=

NULL

);

1108 if

( val != oldval )

1121

oldobjcont = (oldval ==

SCIP_UNKNOWN

? 0.0 : obj * oldval);

1142

sol->

obj

-= oldobjcont;

1143

sol->

obj

+= newobjcont;

1170 if

( val != oldval )

1183

oldobjcont = (oldval ==

SCIP_UNKNOWN

? 0.0 : obj * oldval);

1204

sol->

obj

-= oldobjcont;

1205

sol->

obj

+= newobjcont;

1226 if

( val != oldval )

1228 SCIPerrorMessage

(

"cannot set solution value for variable <%s> fixed to %.15g to different value %.15g\n"

,

1262 SCIPerrorMessage

(

"cannot set solution value for variable <%s> fixed to %.15g to different value %.15g\n"

,

1271 return SCIPsolSetVal

(sol,

set

, stat, tree, multaggrvars[0], multaggrscalars[0] > 0 ? val : -val);

1273 return SCIPsolSetVal

(sol,

set

, stat, tree, multaggrvars[0], (val - multaggrconstant)/multaggrscalars[0]);

1276 SCIPerrorMessage

(

"cannot set solution value for multiple aggregated variable\n"

);

1307

assert(sol !=

NULL

);

1308

assert(stat !=

NULL

);

1312

assert(var !=

NULL

);

1317 if

( incval == 0.0 )

1351 SCIPerrorMessage

(

"cannot increase solution value for fixed variable\n"

);

1359 SCIPerrorMessage

(

"cannot increase solution value for multiple aggregated variable\n"

);

1386

assert(sol !=

NULL

);

1392

assert(var !=

NULL

);

1413 if

( origvar ==

NULL

)

1424 return

scalar * solval + constant;

1468 for

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

1475 if

(

scalars

[i] * solval > 0.0 )

1477 if

(

scalars

[i] * solval < 0.0 )

1480

solvalsum +=

scalars

[i] * solval;

1516

assert(sol !=

NULL

);

1518

assert(var !=

NULL

);

1548 for

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

1553

solvalsum +=

scalars

[i] * solval;

1578

assert(sol !=

NULL

);

1597

assert(sol !=

NULL

);

1603

sol->

obj

+= (newobj - oldobj) * solval;

1618

assert(sol !=

NULL

);

1620

assert(nvars == 0 || vars !=

NULL

);

1628 for

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

1638 for

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

1696

assert(sol !=

NULL

);

1698

assert(prob !=

NULL

);

1700

assert(feasible !=

NULL

);

1707

completely =

FALSE

;

1712 for

( v = 0; v < prob->

nvars

; ++v )

1719

var = prob->

vars

[v];

1737 SCIPmessagePrintInfo

(messagehdlr,

"solution violates original bounds of variable <%s> [%g,%g] solution value <%g>\n"

,

1757

oldpriority = INT_MAX;

1760 for

( c = 0; c < prob->

nconss

; ++c )

1770

assert( priority <= oldpriority );

1771

oldpriority = priority;

1781

checkintegrality, checklprows, printreason, completely, &result) );

1811 while

( h < set->nconshdlrs )

1816

checkintegrality, checklprows, printreason, completely, &result) );

1856

assert(sol !=

NULL

);

1859

assert(prob !=

NULL

);

1860

assert(feasible !=

NULL

);

1870

completely =

FALSE

;

1877 for

( v = 0; v < prob->

nvars

&& (*feasible || completely); ++v )

1882

var = prob->

vars

[v];

1923 SCIPmessagePrintInfo

(messagehdlr,

"infinite solution value %g for variable <%s> with obj %g implies objective value +infinity\n"

,

1929 SCIPsetDebugMsgPrint

(

set

,

"infinite solution value %g for variable <%s> with obj %g implies objective value +infinity\n"

,

1940 for

(

h

= 0;

h

<

set

->nconshdlrs && (*feasible || completely); ++

h

)

1943

checkintegrality, checklprows, printreason, completely, &result) );

1949 SCIPdebugPrintf

(

" -> infeasibility detected in constraint handler <%s>\n"

,

1971

assert(sol !=

NULL

);

1973

assert(prob !=

NULL

);

1975

assert(success !=

NULL

);

1979 for

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

1986

var = prob->

vars

[v];

2005 if

( mayrounddown && mayroundup )

2013 else if

( mayrounddown )

2015 else if

( mayroundup )

2025

*success = (v == nvars);

2042

assert(sol !=

NULL

);

2044

assert(0.0 <= weight && weight <= 1.0);

2046 for

( v = 0; v < prob->

nvars

; ++v )

2082

assert(sol !=

NULL

);

2084

assert(origprob !=

NULL

);

2085

assert(transprob !=

NULL

);

2086

assert(hasinfval !=

NULL

);

2090

*hasinfval =

FALSE

;

2098

vars = origprob->

vars

;

2099

nvars = origprob->

nvars

;

2100

transvars = transprob->

vars

;

2101

ntransvars = transprob->

nvars

;

2110

assert(transsolvals !=

NULL

);

2111

assert(solvals !=

NULL

);

2114 for

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

2120 for

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

2122

activevars[0] = vars[v];

2123

activevals[0] = 1.0;

2129

&requiredsize,

TRUE

) );

2130

assert(requiredsize <= ntransvars);

2133

solvals[v] = constant;

2134 for

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

2160 for

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

2164 if

( solvals[v] != 0.0 )

2198

assert(sol !=

NULL

);

2200

assert(origprob !=

NULL

);

2202

vars = origprob->

vars

;

2203

nvars = origprob->

nvars

;

2207 for

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

2237

assert(sol1 !=

NULL

);

2238

assert(sol2 !=

NULL

);

2268

assert(prob !=

NULL

);

2271 for

( v = 0; v < prob->

nvars

; ++v )

2301

assert(sol !=

NULL

);

2302

assert(prob !=

NULL

);

2316 if

( printzeros || mipstart

2333 for

( v = 0; v < prob->

nvars

; ++v )

2342 if

( printzeros || mipstart

2365

assert(transprob !=

NULL

);

2366 for

( v = 0; v < transprob->

nfixedvars

; ++v )

2391 for

( v = 0; v < transprob->

nvars

; ++v )

2393

assert(transprob->

vars

[v] !=

NULL

);

2436

assert(sol !=

NULL

);

2437

assert(prob !=

NULL

);

2459 for

( v = 0; v < prob->

nvars

; ++v )

2481

assert(transprob !=

NULL

);

2482 for

( v = 0; v < transprob->

nfixedvars

; ++v )

2503 for

( v = 0; v < transprob->

nvars

; ++v )

2505

assert(transprob->

vars

[v] !=

NULL

);

2538

assert(sol !=

NULL

);

2555

assert(sol !=

NULL

);

2567

assert(sol !=

NULL

);

2580

assert(sol !=

NULL

);

2593

assert(sol !=

NULL

);

2606

assert(sol !=

NULL

);

2617

assert(sol !=

NULL

);

2627

assert(sol !=

NULL

);

2637

assert(sol !=

NULL

);

2647

assert(sol !=

NULL

);

2657

assert(sol !=

NULL

);

2667

assert(sol !=

NULL

);

2677

assert(sol !=

NULL

);

2692#undef SCIPsolGetOrigin 2693#undef SCIPsolIsOriginal 2694#undef SCIPsolGetOrigObj 2695#undef SCIPsolGetTime 2696#undef SCIPsolGetNodenum 2697#undef SCIPsolGetRunnum 2698#undef SCIPsolGetDepth 2699#undef SCIPsolGetHeur 2700#undef SCIPsolGetRelax 2701#undef SCIPsolOrigAddObjval 2702#undef SCIPsolGetPrimalIndex 2703#undef SCIPsolSetPrimalIndex 2704#undef SCIPsolGetIndex 2705#undef SCIPsolGetType 2706#undef SCIPsolSetLPRelaxation 2707#undef SCIPsolSetStrongbranching 2708#undef SCIPsolSetPseudo 2715

assert(sol !=

NULL

);

2725

assert(sol !=

NULL

);

2735

assert(sol !=

NULL

);

2745

assert(sol !=

NULL

);

2757

assert(sol !=

NULL

);

2760

sol->

obj

+= addval;

2768

assert(sol !=

NULL

);

2778

assert(sol !=

NULL

);

2788

assert(sol !=

NULL

);

2798

assert(sol !=

NULL

);

2800 return

sol->

depth

;

2808

assert(sol !=

NULL

);

2818

assert(sol !=

NULL

);

2829

assert(sol !=

NULL

);

2839

assert(sol !=

NULL

);

2841 return

sol->

index

;

2854

assert(sol !=

NULL

);

2870

assert(sol !=

NULL

);

2880

assert(sol !=

NULL

);

2891

assert(sol !=

NULL

);

2892

assert(relax !=

NULL

);

2903

assert(sol !=

NULL

);

2913

assert(sol !=

NULL

);

2923

assert(sol !=

NULL

);

SCIP_Real SCIPclockGetLastTime(SCIP_CLOCK *clck)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

internal methods for clocks and timing issues

SCIP_RETCODE SCIPconsCheck(SCIP_CONS *cons, SCIP_SET *set, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrCheck(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT *result)

internal methods for constraints and constraint handlers

#define SCIP_LONGINT_FORMAT

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

int SCIPcolGetNNonz(SCIP_COL *col)

SCIP_Real * SCIPcolGetVals(SCIP_COL *col)

SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

SCIP_SOLORIGIN SCIPsolGetOrigin(SCIP_SOL *sol)

SCIP_Real SCIPsolGetOrigObj(SCIP_SOL *sol)

void SCIPsolSetLPRelaxation(SCIP_SOL *sol)

void SCIPsolSetStrongbranching(SCIP_SOL *sol)

SCIP_Real SCIPsolGetRelBoundViolation(SCIP_SOL *sol)

SCIP_Real SCIPsolGetAbsConsViolation(SCIP_SOL *sol)

SCIP_Real SCIPsolGetTime(SCIP_SOL *sol)

SCIP_RELAX * SCIPsolGetRelax(SCIP_SOL *sol)

SCIP_Real SCIPsolGetAbsBoundViolation(SCIP_SOL *sol)

SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)

SCIP_Real SCIPsolGetAbsIntegralityViolation(SCIP_SOL *sol)

SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)

SCIP_Real SCIPsolGetAbsLPRowViolation(SCIP_SOL *sol)

void SCIPsolSetRelax(SCIP_SOL *sol, SCIP_RELAX *relax)

SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)

int SCIPsolGetIndex(SCIP_SOL *sol)

int SCIPsolGetDepth(SCIP_SOL *sol)

SCIP_Real SCIPsolGetRelLPRowViolation(SCIP_SOL *sol)

SCIP_Bool SCIPsolIsPartial(SCIP_SOL *sol)

int SCIPsolGetRunnum(SCIP_SOL *sol)

SCIP_SOLTYPE SCIPsolGetType(SCIP_SOL *sol)

SCIP_Real SCIPsolGetRelConsViolation(SCIP_SOL *sol)

void SCIPsolSetPseudo(SCIP_SOL *sol)

void SCIPsolSetHeur(SCIP_SOL *sol, SCIP_HEUR *heur)

SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)

SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)

SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)

SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)

int SCIPvarGetMultaggrNVars(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

void SCIPvarMarkNotDeletable(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)

SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)

SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)

SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)

SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)

SCIP_Bool SCIPlpDiving(SCIP_LP *lp)

SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)

SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)

int SCIPlpGetNCols(SCIP_LP *lp)

static const SCIP_Real scalars[]

SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

internal methods for LP management

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

struct BMS_BlkMem BMS_BLKMEM

void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)

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

SCIP_Bool SCIPboolarrayGetVal(SCIP_BOOLARRAY *boolarray, int idx)

SCIP_RETCODE SCIPboolarrayFree(SCIP_BOOLARRAY **boolarray)

SCIP_RETCODE SCIPboolarrayCopy(SCIP_BOOLARRAY **boolarray, BMS_BLKMEM *blkmem, SCIP_BOOLARRAY *sourceboolarray)

SCIP_RETCODE SCIPrealarraySetVal(SCIP_REALARRAY *realarray, int arraygrowinit, SCIP_Real arraygrowfac, int idx, SCIP_Real val)

SCIP_Real SCIPrealarrayGetVal(SCIP_REALARRAY *realarray, int idx)

SCIP_RETCODE SCIPrealarrayIncVal(SCIP_REALARRAY *realarray, int arraygrowinit, SCIP_Real arraygrowfac, int idx, SCIP_Real incval)

SCIP_RETCODE SCIPrealarrayCreate(SCIP_REALARRAY **realarray, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPrealarrayCopy(SCIP_REALARRAY **realarray, BMS_BLKMEM *blkmem, SCIP_REALARRAY *sourcerealarray)

SCIP_RETCODE SCIPboolarrayCreate(SCIP_BOOLARRAY **boolarray, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPboolarrayClear(SCIP_BOOLARRAY *boolarray)

SCIP_RETCODE SCIPrealarrayFree(SCIP_REALARRAY **realarray)

SCIP_RETCODE SCIPboolarraySetVal(SCIP_BOOLARRAY *boolarray, int arraygrowinit, SCIP_Real arraygrowfac, int idx, SCIP_Bool val)

internal miscellaneous methods

SCIP_Bool SCIPnlpIsDivingObjChanged(SCIP_NLP *nlp)

SCIP_Bool SCIPnlpHasSolution(SCIP_NLP *nlp)

SCIP_VAR ** SCIPnlpGetVars(SCIP_NLP *nlp)

int SCIPnlpGetNVars(SCIP_NLP *nlp)

SCIP_Real SCIPnlpGetObjval(SCIP_NLP *nlp)

internal methods for NLP management

void SCIPprimalSolFreed(SCIP_PRIMAL *primal, SCIP_SOL *sol)

SCIP_Bool SCIPprimalUpdateViolations(SCIP_PRIMAL *primal)

SCIP_RETCODE SCIPprimalSolCreated(SCIP_PRIMAL *primal, SCIP_SET *set, SCIP_SOL *sol)

internal methods for collecting primal CIP solutions and primal informations

SCIP_Real SCIPprobGetObjoffset(SCIP_PROB *prob)

int SCIPprobGetNImplVars(SCIP_PROB *prob)

int SCIPprobGetNIntVars(SCIP_PROB *prob)

int SCIPprobGetNBinVars(SCIP_PROB *prob)

SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)

SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

SCIP_RETCODE SCIPprobSortConssCheck(SCIP_PROB *prob)

internal methods for storing and manipulating the main problem

public methods for LP management

public methods for message output

public methods for primal CIP solutions

public methods for problem variables

SCIP_Real SCIPrelaxationGetSolObj(SCIP_RELAXATION *relaxation)

SCIP_RELAX * SCIPrelaxationGetSolRelax(SCIP_RELAXATION *relaxation)

SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)

internal methods for relaxators

SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)

internal methods for global SCIP settings

#define SCIPsetFreeBufferArray(set, ptr)

#define SCIPsetDebugMsgPrint

#define SCIPsetAllocBufferArray(set, ptr, num)

void SCIPsolUpdateVarObj(SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)

SCIP_RETCODE SCIPsolCreateRelaxSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_RELAXATION *relaxation, SCIP_HEUR *heur)

void SCIPsolUpdateConsViolation(SCIP_SOL *sol, SCIP_Real absviolcons, SCIP_Real relviolcons)

SCIP_RETCODE SCIPsolLinkPseudoSol(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)

void SCIPsolSetPrimalIndex(SCIP_SOL *sol, int primalindex)

static void solStamp(SCIP_SOL *sol, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool checktime)

SCIP_RETCODE SCIPsolCreatePartial(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolCreateUnknown(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_HEUR *heur)

void SCIPsolUpdateBoundViolation(SCIP_SOL *sol, SCIP_Real absviolbounds, SCIP_Real relviolbounds)

static SCIP_RETCODE solSetArrayVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_VAR *var, SCIP_Real val)

int SCIPsolGetPrimalIndex(SCIP_SOL *sol)

SCIP_RETCODE SCIPsolCreateNLPSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLP *nlp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolLinkCurrentSol(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)

static SCIP_RETCODE solIncArrayVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_VAR *var, SCIP_Real incval)

SCIP_RETCODE SCIPsolCheck(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)

SCIP_RETCODE SCIPsolMarkPartial(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **vars, int nvars)

SCIP_RETCODE SCIPsolCreateOriginal(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_HEUR *heur)

static SCIP_RETCODE solUnlinkVar(SCIP_SOL *sol, SCIP_SET *set, SCIP_VAR *var)

SCIP_RETCODE SCIPsolAdjustImplicitSolVals(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool uselprows)

SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)

void SCIPsolRecomputeObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob)

void SCIPsolUpdateIntegralityViolation(SCIP_SOL *sol, SCIP_Real absviolintegrality)

void SCIPsolUpdateLPRowViolation(SCIP_SOL *sol, SCIP_Real absviollprows, SCIP_Real relviollprows)

SCIP_RETCODE SCIPsolIncVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real incval)

SCIP_RETCODE SCIPsolLinkNLPSol(SCIP_SOL *sol, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_NLP *nlp)

SCIP_RETCODE SCIPsolRetransform(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_Bool *hasinfval)

static SCIP_Real solGetArrayVal(SCIP_SOL *sol, SCIP_VAR *var)

SCIP_RETCODE SCIPsolCreateCurrentSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolRound(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool *success)

SCIP_RETCODE SCIPsolTransform(SCIP_SOL *sol, SCIP_SOL **transsol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal)

SCIP_RETCODE SCIPsolSetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real val)

static SCIP_RETCODE solClearArrays(SCIP_SOL *sol)

SCIP_RETCODE SCIPsolCreatePseudoSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolClear(SCIP_SOL *sol, SCIP_STAT *stat, SCIP_TREE *tree)

SCIP_RETCODE SCIPsolCreateLPSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolSetUnknown(SCIP_SOL *sol, SCIP_STAT *stat, SCIP_TREE *tree)

SCIP_RETCODE SCIPsolLinkRelaxSol(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_RELAXATION *relaxation)

SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)

SCIP_RETCODE SCIPsolUnlink(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *prob)

SCIP_Real SCIPsolGetRayVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)

SCIP_RETCODE SCIPsolPrintRay(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PROB *transprob, FILE *file, SCIP_Bool printzeros)

void SCIPsolResetViolations(SCIP_SOL *sol)

SCIP_RETCODE SCIPsolLinkLPSol(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)

SCIP_Bool SCIPsolsAreEqual(SCIP_SOL *sol1, SCIP_SOL *sol2, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob)

SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)

SCIP_RETCODE SCIPsolPrint(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PROB *transprob, FILE *file, SCIP_Bool mipstart, SCIP_Bool printzeros)

void SCIPsolUpdateVarsum(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real weight)

SCIP_RETCODE SCIPsolCopy(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_SOL *sourcesol)

SCIP_RETCODE SCIPsolCheckOrig(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool checkmodifiable, SCIP_Bool *feasible)

SCIP_RETCODE SCIPsolCreate(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_HEUR *heur)

void SCIPsolUpdateLPConsViolation(SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)

void SCIPsolOrigAddObjval(SCIP_SOL *sol, SCIP_Real addval)

internal methods for storing primal CIP solutions

internal methods for problem statistics

SCIP_CONS ** origcheckconss

union SCIP_Sol::@18 creator

SCIP_Real absviolintegrality

data structures for LP management

datastructures for storing and manipulating the main problem

datastructures for global SCIP settings

datastructures for storing primal CIP solutions

datastructures for problem statistics

datastructures for problem variables

SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)

SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)

int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)

internal methods for branch and bound tree

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_SOLTYPE_STRONGBRANCH

@ SCIP_SOLORIGIN_RELAXSOL

@ SCIP_SOLORIGIN_PSEUDOSOL

@ SCIP_SOLORIGIN_ORIGINAL

enum SCIP_SolType SCIP_SOLTYPE

enum SCIP_SolOrigin SCIP_SOLORIGIN

@ SCIP_VARSTATUS_ORIGINAL

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

SCIP_Real SCIPvarGetRelaxSolTransVar(SCIP_VAR *var)

SCIP_RETCODE SCIPvarGetActiveRepresentatives(SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)

internal methods for problem variables

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