A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: cons_orbisack.c Source File

77#define CONSHDLR_NAME "orbisack" 78#define CONSHDLR_DESC "symmetry breaking constraint handler for orbisacks" 79#define CONSHDLR_SEPAPRIORITY +40100 80#define CONSHDLR_ENFOPRIORITY -1005200 81#define CONSHDLR_CHECKPRIORITY -1005200 82#define CONSHDLR_SEPAFREQ 5 83#define CONSHDLR_PROPFREQ 5 84#define CONSHDLR_EAGERFREQ -1 86#define CONSHDLR_MAXPREROUNDS -1 87#define CONSHDLR_DELAYSEPA FALSE 88#define CONSHDLR_DELAYPROP FALSE 89#define CONSHDLR_NEEDSCONS TRUE 91#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP 92#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_EXHAUSTIVE 95#define DEFAULT_ORBISEPARATION FALSE 96#define DEFAULT_COVERSEPARATION TRUE 99#define DEFAULT_COEFFBOUND 1000000.0 100#define DEFAULT_PPORBISACK TRUE 101#define DEFAULT_FORCECONSCOPY FALSE 114struct

SCIP_ConshdlrData

148

assert( consdata !=

NULL

);

149

assert( *consdata !=

NULL

);

151

nrows = (*consdata)->nrows;

154 for

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

156

assert( (*consdata)->vars1[i] !=

NULL

);

159

assert( (*consdata)->vars2[i] !=

NULL

);

185

assert( consdata !=

NULL

);

194 for

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

202

(*consdata)->nrows = nrows;

203

(*consdata)->ismodelcons = ismodelcons;

210 for

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

221 for

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

247

assert( vars1 !=

NULL

);

248

assert( vars2 !=

NULL

);

249

assert( success !=

NULL

);

250

assert( isparttype !=

NULL

);

253

*isparttype =

FALSE

;

256 for

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

259

vars[i][0] = vars1[i];

260

vars[i][1] = vars2[i];

273 for

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

302

assert( cons !=

NULL

);

303

assert( infeasible !=

NULL

);

305

*infeasible =

FALSE

;

308

assert( consdata != 0 );

309

assert( consdata->nrows > 0 );

310

assert( consdata->vars1 !=

NULL

);

311

assert( consdata->vars2 !=

NULL

);

313

vars1 = consdata->vars1;

314

vars2 = consdata->vars2;

316

tmpvars[0] = vars1[0];

317

tmpvars[1] = vars2[0];

351

assert( cons !=

NULL

);

352

assert( vars1 !=

NULL

);

353

assert( vars2 !=

NULL

);

354

assert( coeffs1 !=

NULL

);

355

assert( coeffs2 !=

NULL

);

356

assert( infeasible !=

NULL

);

358

*infeasible =

FALSE

;

362 for

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

406

assert( cons !=

NULL

);

408

assert( vars1 !=

NULL

);

409

assert( vars2 !=

NULL

);

410

assert( infeasible !=

NULL

);

411

assert( ngen !=

NULL

);

413

*infeasible =

FALSE

;

421 for

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

428 for

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

452

lhs = lhs - vals1[i];

465

lhs = lhs + vals2[i];

503

assert( cons !=

NULL

);

504

assert( vars1 !=

NULL

);

505

assert( vars2 !=

NULL

);

506

assert( coeffs1 !=

NULL

);

507

assert( coeffs2 !=

NULL

);

508

assert( infeasible !=

NULL

);

510

*infeasible =

FALSE

;

515 for

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

569

assert( cons !=

NULL

);

571

assert( vars1 !=

NULL

);

572

assert( vars2 !=

NULL

);

573

assert( coeffbound >= 0.0 );

574

assert( ngen !=

NULL

);

575

assert( infeasible !=

NULL

);

577

*infeasible =

FALSE

;

591 for

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

599

lhs = - vals1[0] + vals2[0];

605

lhs += - vals1[1] + vals2[1];

617 while

( basement < nrows - 1 && ! *infeasible )

619

valueA = lhs + vals1[basement] - vals1[basement + 1] + vals2[basement + 1] - rhs - 1.0;

620

valueB = lhs - vals2[basement] - vals1[basement + 1] + vals2[basement + 1] - rhs;

621

valueC = 2.0 * lhs + vals1[basement] - vals2[basement] - vals1[basement + 1] + vals2[basement + 1] - 2.0 * rhs;

624 if

( valueA >= valueB && valueA >= valueC )

627

coeff1[basement] = 0.0;

628

lhs += vals1[basement++];

629

coeff1[basement] = -1.0;

630

coeff2[basement] = 1.0;

631

lhs += - vals1[basement] + vals2[basement];

633 else if

( valueB >= valueA && valueB >= valueC )

635

coeff2[basement] = 0.0;

636

lhs -= vals2[basement++];

637

coeff1[basement] = -1.0;

638

coeff2[basement] = 1.0;

639

lhs += - vals1[basement] + vals2[basement];

645 for

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

647

coeff1[i] = 2.0 * coeff1[i];

648

coeff2[i] = 2.0 * coeff2[i];

649

lhs += coeff1[i] * vals1[i] + coeff2[i] * vals2[i];

651

coeff1[basement] = -1.0;

652

coeff2[basement] = 1.0;

653

lhs -= vals1[basement];

654

lhs += vals2[basement++];

655

coeff1[basement] = -1.0;

656

coeff2[basement] = 1.0;

657

lhs -= vals1[basement];

658

lhs += vals2[basement];

662 if

( rhs > coeffbound || -coeff1[0] > coeffbound || coeff2[0] > coeffbound )

665 if

( ! coverseparation )

715

assert( vars1 !=

NULL

);

716

assert( vars2 !=

NULL

);

717

assert( infeasible !=

NULL

);

718

assert( start >= 0 );

720

*infeasible =

FALSE

;

722 for

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

728

assert( var1 !=

NULL

);

729

assert( var2 !=

NULL

);

789 int

peekinfeasiblerow;

794

assert( cons !=

NULL

);

795

assert( infeasible !=

NULL

);

796

assert( ngen !=

NULL

);

797

assert( found !=

NULL

);

802

*infeasible =

FALSE

;

807

assert( consdata !=

NULL

);

808

assert( consdata->vars1 !=

NULL

);

809

assert( consdata->vars2 !=

NULL

);

810

assert( consdata->nrows > 0 );

812

nrows = consdata->nrows;

813

vars1 = consdata->vars1;

814

vars2 = consdata->vars2;

817 for

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

822

assert( var1 !=

NULL

);

823

assert( var2 !=

NULL

);

866 if

( peekinfeasible )

869 SCIPdebugMsg

(

scip

,

"Making row %d constant is infeasible. Fix to (1, 0).\n"

, i);

871

assert( peekinfeasiblerow > i );

872

assert( peekinfeasiblerow < nrows );

879

assert( ! *infeasible );

881

*found = *found || tightened;

891

assert( ! *infeasible );

893

*found = *found || tightened;

940

assert( ! *infeasible );

942

*found = *found || tightened;

956

assert( ! *infeasible );

958

*found = *found || tightened;

965 SCIPdebugMsg

(

scip

,

"No further fixings possible. Stopping at row %d\n"

, i);

989

assert( result !=

NULL

);

990

assert( cons !=

NULL

);

991

assert( vars1 !=

NULL

);

992

assert( vars2 !=

NULL

);

993

assert( vals1 !=

NULL

);

994

assert( vals2 !=

NULL

);

997

assert( conshdlrdata !=

NULL

);

999 if

( conshdlrdata->orbiseparation )

1001 SCIP_CALL

(

separateOrbisack

(

scip

, cons, nrows, vars1, vars2, vals1, vals2,

FALSE

, conshdlrdata->coeffbound, &ngen1, &infeasible) );

1004 if

( ! infeasible && conshdlrdata->coverseparation )

1015 if

( ngen1 + ngen2 > 0 )

1031

assert(conshdlr !=

NULL

);

1046

assert(

scip

!= 0 );

1047

assert( conshdlr != 0 );

1048

assert( consdata != 0 );

1063

assert(

scip

!= 0 );

1064

assert( conshdlr != 0 );

1068

assert( conshdlrdata !=

NULL

);

1084

assert( conshdlr !=

NULL

);

1086

assert( sourcecons !=

NULL

);

1087

assert( targetcons !=

NULL

);

1096

sourcedata->nrows, sourcedata->ismodelcons) );

1116

assert( infeasible !=

NULL

);

1117

*infeasible =

FALSE

;

1119

assert(

scip

!= 0 );

1120

assert( conshdlr != 0 );

1124 for

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

1126

assert( conss[c] != 0 );

1149

assert( conshdlr !=

NULL

);

1154

assert( conshdlrdata !=

NULL

);

1156

conshdlrdata->maxnrows = 0;

1159 for

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

1163

assert( conss[c] !=

NULL

);

1166

assert( consdata !=

NULL

);

1169 if

( consdata->nrows > conshdlrdata->maxnrows )

1170

conshdlrdata->maxnrows = consdata->nrows;

1187

assert( conshdlr !=

NULL

);

1189

assert( result !=

NULL

);

1204

assert( conshdlrdata !=

NULL

);

1206

nvals = conshdlrdata->maxnrows;

1207

assert( nvals > 0 );

1213 for

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

1216

assert( conss[c] !=

NULL

);

1249

assert( conshdlr !=

NULL

);

1251

assert( result !=

NULL

);

1263

assert( conshdlrdata !=

NULL

);

1265

nvals = conshdlrdata->maxnrows;

1266

assert( nvals > 0 );

1272 for

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

1275

assert( conss[c] !=

NULL

);

1279

assert( consdata->nrows <= nvals );

1312

assert(

scip

!= 0 );

1313

assert( conshdlr != 0 );

1315

assert( result != 0 );

1330

assert( conshdlrdata !=

NULL

);

1332

nvals = conshdlrdata->maxnrows;

1333

assert( nvals > 0 );

1339 for

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

1342

assert( conss[c] != 0 );

1344

assert( consdata !=

NULL

);

1347 if

( !consdata->ismodelcons )

1351

assert( consdata->nrows <= nvals );

1391

assert( conshdlr !=

NULL

);

1393

assert( result !=

NULL

);

1395 SCIPdebugMsg

(

scip

,

"Enforcing method for orbisack constraints (pseudo solutions) ...\n"

);

1399 if

( objinfeasible || solinfeasible )

1403 for

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

1406

assert( conss[c] !=

NULL

);

1408

assert( consdata !=

NULL

);

1409

assert( consdata->nrows > 0 );

1410

assert( consdata->vars1 !=

NULL

);

1411

assert( consdata->vars2 !=

NULL

);

1414 if

( !consdata->ismodelcons )

1441

assert(

scip

!= 0 );

1442

assert( conshdlr != 0 );

1444

assert( result != 0 );

1459

assert( conshdlrdata !=

NULL

);

1461

nvals = conshdlrdata->maxnrows;

1462

assert( nvals > 0 );

1468 for

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

1471

assert( conss[c] != 0 );

1473

assert( consdata !=

NULL

);

1476 if

( !consdata->ismodelcons )

1480

assert( consdata->nrows <= nvals );

1520

assert( conshdlr !=

NULL

);

1522

assert( result !=

NULL

);

1527 for

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

1530

assert( conss[c] !=

NULL

);

1532

assert( consdata !=

NULL

);

1533

assert( consdata->nrows > 0 );

1534

assert( consdata->vars1 !=

NULL

);

1535

assert( consdata->vars2 !=

NULL

);

1540 if

( !consdata->ismodelcons )

1567

assert( conshdlr !=

NULL

);

1569

assert( result !=

NULL

);

1573 SCIPdebugMsg

(

scip

,

"Propagation method of orbisack constraint handler.\n"

);

1576 for

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

1582

assert( conss[c] !=

NULL

);

1608

assert( conshdlr !=

NULL

);

1610

assert( result !=

NULL

);

1612 SCIPdebugMsg

(

scip

,

"Presolving method of orbisack constraint handler. Propagating orbisack inequalities.\n"

);

1617 for

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

1623

assert( conss[c] !=

NULL

);

1637

*nfixedvars += ngen;

1657

assert( conshdlr !=

NULL

);

1659

assert( cons !=

NULL

);

1660

assert( infervar !=

NULL

);

1661

assert( bdchgidx !=

NULL

);

1662

assert( result !=

NULL

);

1664 SCIPdebugMsg

(

scip

,

"Propagation resolution method of orbisack constraint handler.\n"

);

1669

assert( consdata !=

NULL

);

1670

assert( consdata->nrows > 0 );

1671

assert( consdata->vars1 !=

NULL

);

1672

assert( consdata->vars2 !=

NULL

);

1674

vars1 = consdata->vars1;

1675

vars2 = consdata->vars2;

1678

varrow = inferinfo % consdata->nrows;

1679

infrow = inferinfo / consdata->nrows;

1681

assert( varrow >= 0 );

1682

assert( varrow < consdata->nrows );

1683

assert( infrow >= 0 );

1684

assert( infrow < consdata->nrows );

1687 for

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

1702 for

(i = varrow + 1; i < infrow; ++i)

1728

assert( infervar == vars1[varrow] );

1740

assert( infervar == vars2[varrow] );

1775

assert( conshdlr !=

NULL

);

1777

assert( cons !=

NULL

);

1779 SCIPdebugMsg

(

scip

,

"Locking method for orbisack constraint handler.\n"

);

1783

assert( consdata !=

NULL

);

1784

assert( consdata->nrows > 0 );

1785

assert( consdata->vars1 !=

NULL

);

1786

assert( consdata->vars2 !=

NULL

);

1788

nrows = consdata->nrows;

1789

vars1 = consdata->vars1;

1790

vars2 = consdata->vars2;

1792 for

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

1816

assert( cons !=

NULL

);

1817

assert( sourcescip !=

NULL

);

1818

assert( sourceconshdlr !=

NULL

);

1820

assert( sourcecons !=

NULL

);

1821

assert( varmap !=

NULL

);

1822

assert( valid !=

NULL

);

1826 SCIPdebugMsg

(

scip

,

"Copying method for orbisack constraint handler.\n"

);

1829

assert( sourcedata !=

NULL

);

1830

assert( sourcedata->vars1 !=

NULL

);

1831

assert( sourcedata->vars2 !=

NULL

);

1832

assert( sourcedata->nrows > 0 );

1835

assert( conshdlrdata !=

NULL

);

1838 if

( !sourcedata->ismodelcons && !conshdlrdata->forceconscopy )

1845

sourcevars1 = sourcedata->vars1;

1846

sourcevars2 = sourcedata->vars2;

1847

nrows = sourcedata->nrows;

1851 for

(i = 0; i < nrows && *valid; ++i)

1854

assert( !(*valid) || vars1[i] !=

NULL

);

1867 for

(i = 0; i < nrows && *valid; ++i)

1870

assert( !(*valid) || vars2[i] !=

NULL

);

1881

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode) );

1906

assert( success !=

NULL

);

1914 if

( strncmp(s,

"partOrbisack("

, 13) == 0 )

1916

ispporbisack =

TRUE

;

1919 else if

( strncmp(s,

"packOrbisack("

, 13) == 0 )

1920

ispporbisack =

TRUE

;

1923 if

( strncmp(s,

"fullOrbisack("

, 13) != 0 )

1925 SCIPerrorMessage

(

"Syntax error - expected \"fullOrbisack(\", \"partOrbisack\" or \"packOrbisacj\": %s\n"

, s);

1943

endptr = strchr(endptr,

')'

);

1945 if

( endptr ==

NULL

|| !firstcolumn )

1955

assert( s !=

NULL

);

1960 if

( firstcolumn == ( *s ==

'.'

|| *s ==

')'

) )

1972 if

( nrows > maxnrows )

1977

assert( nrows <= maxnrows );

1980

vars1[nrows-1] = var;

1983

vars2[nrows-1] = var;

1985

firstcolumn = !firstcolumn;

1988 if

( *s ==

','

|| *s ==

'.'

)

1991 while

( *s !=

')'

);

2017

assert( conshdlr !=

NULL

);

2019

assert( cons !=

NULL

);

2022

assert( consdata !=

NULL

);

2023

assert( consdata->vars1 !=

NULL

);

2024

assert( consdata->vars2 !=

NULL

);

2025

assert( consdata->nrows > 0 );

2027

vars1 = consdata->vars1;

2028

vars2 = consdata->vars2;

2029

nrows = consdata->nrows;

2031 SCIPdebugMsg

(

scip

,

"Printing method for orbisack constraint handler\n"

);

2035 for

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

2066

assert( vars1 !=

NULL

);

2067

assert( vars2 !=

NULL

);

2068

assert( nrows > 0 );

2069

assert( feasible !=

NULL

);

2074 for

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

2087 else if

( val1 == 1 )

2089

assert( val2 == 0 );

2111

assert( cons !=

NULL

);

2112

assert( success !=

NULL

);

2113

assert( vars !=

NULL

);

2116

assert( consdata !=

NULL

);

2118 if

( varssize < 2 * consdata->nrows )

2119

(*success) =

FALSE

;

2125 for

(i = 0; i < consdata->nrows; ++i)

2127

vars[cnt++] = consdata->vars1[i];

2128

vars[cnt++] = consdata->vars2[i];

2143

assert( cons !=

NULL

);

2146

assert( consdata !=

NULL

);

2148

(*nvars) = 2 * consdata->nrows;

2169

consEnfolpOrbisack, consEnfopsOrbisack, consCheckOrbisack, consLockOrbisack,

2171

assert( conshdlr !=

NULL

);

2192 "Separate cover inequalities for orbisacks?"

,

2196 "Separate orbisack inequalities?"

,

2200 "Maximum size of coefficients for orbisack inequalities"

,

2205 "Upgrade orbisack constraints to packing/partioning orbisacks?"

,

2209 "Whether orbisack constraints should be forced to be copied to sub SCIPs."

,

2269 if

( conshdlr ==

NULL

)

2275

assert( nrows > 0 );

2279 if

( ! ispporbisack && conshdlrdata->checkpporbisack )

2284

ispporbisack =

TRUE

;

2292 for

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

2295

vars[i][0] = vars1[i];

2296

vars[i][1] = vars2[i];

2305

2,

FALSE

,

TRUE

,

TRUE

, ismodelcons, initial, separate, enforce, check, propagate, local,

2306

modifiable, dynamic, removable, stickingatnode) );

2308 for

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

2317 SCIP_CALL

(

SCIPcreateCons

(

scip

, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,

2318

local, modifiable, dynamic, removable, stickingatnode) );

static SCIP_RETCODE initLP(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_CONSENFOLP(consEnfolpOrbisack)

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSDELETE(consDeleteOrbisack)

static SCIP_DECL_CONSINITLP(consInitlpOrbisack)

#define DEFAULT_ORBISEPARATION

#define CONSHDLR_PROP_TIMING

static SCIP_DECL_CONSSEPASOL(consSepasolOrbisack)

#define DEFAULT_FORCECONSCOPY

#define CONSHDLR_MAXPREROUNDS

static SCIP_DECL_CONSLOCK(consLockOrbisack)

static SCIP_DECL_CONSRESPROP(consRespropOrbisack)

#define CONSHDLR_SEPAPRIORITY

static SCIP_DECL_CONSPROP(consPropOrbisack)

static SCIP_DECL_CONSPARSE(consParseOrbisack)

static SCIP_DECL_CONSSEPALP(consSepalpOrbisack)

#define DEFAULT_PPORBISACK

static SCIP_DECL_CONSGETNVARS(consGetNVarsOrbisack)

static SCIP_RETCODE separateOrbisackCovers(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *vals1, SCIP_Real *vals2, int *ngen, SCIP_Bool *infeasible)

#define DEFAULT_COVERSEPARATION

static SCIP_RETCODE addOrbisackCover(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *coeffs1, SCIP_Real *coeffs2, SCIP_Real rhs, SCIP_Bool *infeasible)

static SCIP_DECL_CONSTRANS(consTransOrbisack)

static SCIP_RETCODE separateInequalities(SCIP *scip, SCIP_RESULT *result, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *vals1, SCIP_Real *vals2)

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyOrbisack)

static SCIP_DECL_CONSCHECK(consCheckOrbisack)

static SCIP_DECL_CONSPRESOL(consPresolOrbisack)

static SCIP_DECL_CONSFREE(consFreeOrbisack)

static SCIP_DECL_CONSCOPY(consCopyOrbisack)

static SCIP_DECL_CONSENFORELAX(consEnforelaxOrbisack)

static SCIP_RETCODE addOrbisackInequality(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *coeffs1, SCIP_Real *coeffs2, SCIP_Real rhs, SCIP_Bool *infeasible)

#define CONSHDLR_PROPFREQ

static SCIP_DECL_CONSPRINT(consPrintOrbisack)

static SCIP_DECL_CONSENFOPS(consEnfopsOrbisack)

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)

static SCIP_DECL_CONSINITSOL(consInitsolOrbisack)

static SCIP_RETCODE packingUpgrade(SCIP *scip, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool *success, SCIP_Bool *isparttype)

#define CONSHDLR_EAGERFREQ

static SCIP_RETCODE separateOrbisack(SCIP *scip, SCIP_CONS *cons, int nrows, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, SCIP_Real *vals1, SCIP_Real *vals2, SCIP_Bool coverseparation, SCIP_Real coeffbound, int *ngen, SCIP_Bool *infeasible)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSGETVARS(consGetVarsOrbisack)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ismodelcons)

#define CONSHDLR_DELAYSEPA

static SCIP_RETCODE checkFeasible(SCIP *scip, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, int start, SCIP_Bool *infeasible, int *infeasiblerow)

#define DEFAULT_COEFFBOUND

#define CONSHDLR_DELAYPROP

static SCIP_RETCODE propVariables(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible, SCIP_Bool *found, int *ngen)

constraint handler for orbisack constraints

constraint handler for (partitioning/packing/full) orbitope constraints w.r.t. the full symmetric gro...

Constraint handler for the set partitioning / packing / covering constraints .

SCIP_RETCODE SCIPcheckSolutionOrbisack(SCIP *scip, SCIP_SOL *sol, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool printreason, SCIP_Bool *feasible)

SCIP_RETCODE SCIPcreateConsBasicOrbisack(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR **vars1, SCIP_VAR **vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, SCIP_Bool ismodelcons)

SCIP_RETCODE SCIPcreateConsOrbitope(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR ***vars, SCIP_ORBITOPETYPE orbitopetype, int nspcons, int nblocks, SCIP_Bool usedynamicprop, SCIP_Bool mayinteract, SCIP_Bool resolveprop, SCIP_Bool ismodelcons, 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 SCIPcreateConsOrbisack(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *const *vars1, SCIP_VAR *const *vars2, int nrows, SCIP_Bool ispporbisack, SCIP_Bool isparttype, SCIP_Bool ismodelcons, 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 SCIPincludeConshdlrOrbisack(SCIP *scip)

SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)

SCIP_Bool SCIPisTransformed(SCIP *scip)

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

SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

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)

int SCIPgetNLPBranchCands(SCIP *scip)

SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)

SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))

SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)

SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))

SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)

SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))

SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))

SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))

SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))

SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))

SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))

SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))

SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, 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 SCIPconsIsPropagated(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_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)

SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)

SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)

SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

SCIP_RETCODE SCIPisPackingPartitioningOrbitope(SCIP *scip, SCIP_VAR ***vars, int nrows, int ncols, SCIP_Bool **pprows, int *npprows, SCIP_ORBITOPETYPE *type)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)

SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)

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

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)

SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)

SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPskipSpace(char **s)

memory allocation routines

public methods for managing constraints

public methods for message output

public methods for problem variables

public methods for branching rule plugins and branching

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for cuts and aggregation rows

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for solutions

public methods for SCIP variables

methods for handling symmetries

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_ORBITOPETYPE_PACKING

@ SCIP_ORBITOPETYPE_PARTITIONING

enum SCIP_OrbitopeType SCIP_ORBITOPETYPE

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