assert(oracle !=
NULL);
115assert(newsize >= minsize);
128assert(oracle->
varssize>= minsize);
141assert(oracle !=
NULL);
157assert(cons !=
NULL);
159 if( minsize > cons->
linsize)
164assert(newsize >= minsize);
170assert(cons->
linsize>= minsize);
184assert(intarray !=
NULL);
185assert(len !=
NULL);
188assert(*len >= minsize);
202assert(oracle !=
NULL);
226assert(oracle !=
NULL);
228 SCIPdebugMessage(
"%p invalidate hessian lag sparsity\n", (
void*)oracle);
254assert(oracle !=
NULL);
257assert(factor == 1 || factor == -1);
258assert(nlinidxs == 0 || linidxs !=
NULL);
260 for( j = 0; j < nlinidxs; ++j )
297assert(nidxs !=
NULL);
298assert(idxs !=
NULL|| *nidxs == 0);
299assert(coefs !=
NULL|| *nidxs == 0);
308 while( j+offset < *nidxs )
310assert(idxs[j] >= 0);
315idxs[j] = idxs[j+offset];
316coefs[j] = coefs[j+offset];
320 while( j+offset+1 < *nidxs && idxs[j] == idxs[j+offset+1] )
322coefs[j] += coefs[j+offset+1];
327 if( coefs[j] == 0.0 )
350assert(cons !=
NULL);
351assert(nlinidxs >= 0);
352assert(linidxs !=
NULL|| nlinidxs == 0);
353assert(lincoefs !=
NULL|| nlinidxs == 0);
357assert(*cons !=
NULL);
363(*cons)->linsize = nlinidxs;
364(*cons)->nlinidxs = nlinidxs;
368assert((*cons)->linidxs[0] >= 0);
373(*cons)->expr = expr;
407assert(oracle !=
NULL);
408assert(cons !=
NULL);
409assert(*cons !=
NULL);
414 if( updatevarcount )
422 if( (*cons)->expr !=
NULL)
428 if( (*cons)->name !=
NULL)
434assert(*cons ==
NULL);
451assert(oracle !=
NULL);
455 for( i = 0; i < oracle->
nconss; ++i )
480assert(oracle !=
NULL);
484assert(0 <= fromidx);
486assert(fromidx < oracle->nvars);
487assert(toidx < oracle->nvars);
519assert(oracle !=
NULL);
525 for( i = 0; i < oracle->
nvars; ++i )
552assert(indexmap !=
NULL);
553assert(nindices == 0 || indices !=
NULL);
555 for( ; nindices ; --nindices, ++indices )
557assert(indexmap[*indices] >= 0);
558*indices = indexmap[*indices];
577assert(linidxs !=
NULL);
578assert(*linidxs !=
NULL);
579assert(coefs !=
NULL);
580assert(*coefs !=
NULL);
581assert(nidxs !=
NULL);
585 for( offset = 0; offset < *nidxs; ++offset )
586 if( (*linidxs)[offset] >= 0 )
594 for( i = 0; i < *nidxs - offset; ++i )
596(*linidxs)[i] = (*linidxs)[i+offset];
597(*coefs)[i] = (*coefs) [i+offset];
612assert(oracle !=
NULL);
613assert(cons !=
NULL);
615assert(val !=
NULL);
630assert(linidxs !=
NULL);
631assert(lincoefs !=
NULL);
634 for( ; nlin > 0; --nlin, ++linidxs, ++lincoefs )
635*val += *lincoefs *
x[*linidxs];
667assert(oracle !=
NULL);
669assert(val !=
NULL);
670assert(grad !=
NULL);
683 SCIPdebug(
if( isnewx ) {printf(
"\nx =");
for( i = 0; i < oracle->
nvars; ++i) printf(
" %g",
x[i]); printf(
"\n");} )
687 SCIPdebug( printf(
"g =");
for( i = 0; i < oracle->
nvars; ++i) printf(
" %g", grad[i]); printf(
"\n"); )
692 SCIPdebugMessage(
"gradient evaluation yield invalid function value %g\n", nlval);
695 for( i = 0; i < oracle->
nvars; ++i )
698 SCIPdebugMessage(
"gradient evaluation yield invalid gradient value %g\n", grad[i]);
714assert(linidxs !=
NULL);
715assert(lincoefs !=
NULL);
718 for( ; nlin > 0; --nlin, ++linidxs, ++lincoefs )
720*val += *lincoefs *
x[*linidxs];
721grad[*linidxs] += *lincoefs;
752assert(oracle !=
NULL);
753assert(colnz !=
NULL);
754assert(collen !=
NULL);
755assert(colnnz !=
NULL);
756assert(nzcount !=
NULL);
757assert(expr !=
NULL);
760 SCIPdebugMessage(
"%p hess lag sparsity set nzflag for expr\n", (
void*)oracle);
763 for( i = 0; i < oracle->
nvars; ++i )
768 for( i = 0; i < nnz; ++i )
773assert(row < oracle->nvars);
816assert(oracle !=
NULL);
818assert(expr !=
NULL);
819assert(hesoffset !=
NULL);
820assert(hescol !=
NULL);
821assert(values !=
NULL);
823 SCIP_CALL(
SCIPexprintHessian(
scip, oracle->
exprinterpreter, expr, exprintdata, (
SCIP_Real*)
x, new_x, &val, &rowidxs, &colidxs, &
h, &nnz) );
826 SCIPdebugMessage(
"hessian evaluation yield invalid function value %g\n", val);
830 for( i = 0; i < nnz; ++i )
834 SCIPdebugMessage(
"hessian evaluation yield invalid hessian value %g\n", *
h);
844 if( !
SCIPsortedvecFindInt(&hescol[hesoffset[row]], col, hesoffset[row+1] - hesoffset[row], &pos) )
846 SCIPerrorMessage(
"Could not find entry (%d, %d) in hessian sparsity\n", row, col);
850values[hesoffset[row] + pos] += weight *
h[i];
867assert(idx >= 0 && idx < 100000);
872(void)
SCIPsnprintf(buffer, 64,
"%c%05d%.*s%s", prefix, idx, suffix !=
NULL? (
int)(57-strlen(suffix)) : 57, name, suffix ? suffix :
"");
874(
void)
SCIPsnprintf(buffer, 64,
"%c%05d", prefix, idx);
880assert(strlen(name) + (suffix !=
NULL? strlen(suffix) : 0) <= 64);
881(void)
SCIPsnprintf(buffer, 64,
"%s%s", name, suffix !=
NULL? suffix :
"");
885assert(1 + 5 + (suffix !=
NULL? strlen(suffix) : 0) <= 64);
886(void)
SCIPsnprintf(buffer, 64,
"%c%d%s", prefix, idx, suffix !=
NULL? suffix :
"");
906assert(oracle !=
NULL);
907assert(file !=
NULL);
908assert(cons !=
NULL);
910 for( i = 0; i < cons->
nlinidxs; ++i )
938assert(expr !=
NULL);
939assert(nonsmooth !=
NULL);
948 const char* hdlrname;
955 if( strcmp(hdlrname,
"abs") == 0 )
960 if( strcmp(hdlrname,
"min") == 0 )
965 if( strcmp(hdlrname,
"max") == 0 )
990assert(oracle !=
NULL);
1018assert(oracle !=
NULL);
1019assert(*oracle !=
NULL);
1034 if( (*oracle)->name !=
NULL)
1051assert(oracle !=
NULL);
1073assert(oracle !=
NULL);
1077 returnoracle->
name;
1087 const char** varnames
1092assert(oracle !=
NULL);
1108 for( i = 0; i < nvars; ++i )
1116 for( i = oracle->
nvars; i < oracle->nvars + nvars; ++i )
1126 for( i = 0; i < nvars; ++i )
1129 if( varnames !=
NULL)
1136 for( i = 0; i < nvars; ++i )
1138 if( varnames[i] !=
NULL)
1157oracle->
nvars+= nvars;
1173 const int* nlininds,
1174 int*
const* lininds,
1178 const char** consnames
1185assert(oracle !=
NULL);
1194addednlcon =
FALSE;
1199 for( c = 0; c < nconss; ++c )
1202nlininds !=
NULL? nlininds[c] : 0,
1203lininds !=
NULL? lininds[c] :
NULL,
1204linvals !=
NULL? linvals[c] :
NULL,
1208consnames !=
NULL? consnames[c] :
NULL 1216oracle->
nconss+= nconss;
1218 if( addednlcon ==
TRUE)
1233 const int* lininds,
1238assert(oracle !=
NULL);
1251nlin, lininds, linvals, expr, constant, constant,
NULL) );
1261 const int* indices,
1268assert(oracle !=
NULL);
1269assert(indices !=
NULL|| nvars == 0);
1273 for( i = 0; i < nvars; ++i )
1275assert(indices !=
NULL);
1276assert(indices[i] >= 0);
1277assert(indices[i] < oracle->
nvars);
1282 if( oracle->
varlbs[indices[i]] > oracle->
varubs[indices[i]] )
1286oracle->
varlbs[indices[i]] = oracle->
varubs[indices[i]];
1298 const int* indices,
1305assert(oracle !=
NULL);
1306assert(indices !=
NULL|| nconss == 0);
1310 for( i = 0; i < nconss; ++i )
1312assert(indices !=
NULL);
1313assert(indices[i] >= 0);
1314assert(indices[i] < oracle->
nconss);
1318 if( oracle->
conss[indices[i]]->
lhs> oracle->
conss[indices[i]]->
rhs)
1341assert(oracle !=
NULL);
1348lastgood = oracle->
nvars- 1;
1349 while( lastgood >= 0 && delstats[lastgood] == 1 )
1354assert(oracle->
nconss== 0);
1356 for( c = 0; c < oracle->
nvars; ++c )
1363 for( c = oracle->
nvars- 1; c > lastgood; --c )
1375 for( c = 0; c <= lastgood; ++c )
1377 if( delstats[c] == 0 )
1382assert(delstats[c] == 1);
1392delstats[lastgood] = c;
1396 while( lastgood > c && delstats[lastgood] == 1)
1402delstats[lastgood] = -1;
1406assert(c == lastgood);
1410 for( c = -1; c < oracle->
nconss; ++c )
1413assert(cons !=
NULL);
1465oracle->
nvars= lastgood+1;
1481assert(oracle !=
NULL);
1488lastgood = oracle->
nconss- 1;
1489 while( lastgood >= 0 && delstats[lastgood] == 1)
1494 for( c = 0; c < oracle->
nconss; ++c )
1509 for( c = oracle->
nconss- 1; c > lastgood; --c )
1519 for( c = 0; c <= lastgood; ++c )
1521 if( delstats[c] == 0 )
1527assert(delstats[c] == 1);
1534oracle->
conss[c] = oracle->
conss[lastgood];
1536delstats[lastgood] = c;
1541 while( lastgood > c && delstats[lastgood] == 1)
1544assert(oracle->
conss[lastgood] ==
NULL);
1545delstats[lastgood] = -1;
1549assert(c == lastgood+1);
1551oracle->
nconss= lastgood+1;
1562 const int* varidxs,
1572assert(oracle !=
NULL);
1573assert(varidxs !=
NULL|| nentries == 0);
1574assert(newcoefs !=
NULL|| nentries == 0);
1575assert(considx >= -1);
1576assert(considx < oracle->nconss);
1578 if( nentries == 0 )
1581 SCIPdebugMessage(
"change %d linear coefficients in cons %d\n", nentries, considx);
1585cons = considx < 0 ? oracle->
objective: oracle->
conss[considx];
1606 for( i = 0; i < nentries; ++i )
1608assert(varidxs[i] >= 0);
1609assert(varidxs[i] < oracle->
nvars);
1613 SCIPdebugMessage(
"replace coefficient of var %d at pos %d by %g\n", varidxs[i], pos, newcoefs[i]);
1615cons->
lincoefs[pos] = newcoefs[i];
1618needsort |= (newcoefs[i] == 0.0);
1620 if( newcoefs[i] == 0.0 )
1626 else if( newcoefs[i] != 0.0 )
1664assert(oracle !=
NULL);
1665assert(considx >= -1);
1666assert(considx < oracle->nconss);
1671cons = considx < 0 ? oracle->
objective: oracle->
conss[considx];
1705assert(oracle !=
NULL);
1720assert(oracle !=
NULL);
1722 returnoracle->
nvars;
1730assert(oracle !=
NULL);
1740assert(oracle !=
NULL);
1750assert(oracle !=
NULL);
1760assert(oracle !=
NULL);
1772assert(oracle !=
NULL);
1773assert(varidx >= 0);
1774assert(varidx < oracle->nvars);
1784 const int** lincounts,
1785 const int** nlcounts
1788assert(oracle !=
NULL);
1789assert(lincounts !=
NULL);
1790assert(nlcounts !=
NULL);
1801assert(oracle !=
NULL);
1813assert(oracle !=
NULL);
1814assert(considx >= 0);
1815assert(considx < oracle->nconss);
1817 returnoracle->
conss[considx]->
lhs;
1826assert(oracle !=
NULL);
1827assert(considx >= 0);
1828assert(considx < oracle->nconss);
1830 returnoracle->
conss[considx]->
rhs;
1839assert(oracle !=
NULL);
1840assert(considx >= 0);
1841assert(considx < oracle->nconss);
1843 returnoracle->
conss[considx]->
name;
1854assert(oracle !=
NULL);
1855assert(considx >= -1);
1856assert(considx < oracle->nconss);
1858cons = considx < 0 ? oracle->
objective: oracle->
conss[considx];
1872assert(oracle !=
NULL);
1879 for( c = 0; c < oracle->
nconss; ++c )
1883 returnevalcapability;
1896assert(oracle !=
NULL);
1922assert(oracle !=
NULL);
1924assert(conval !=
NULL);
1948assert(oracle !=
NULL);
1950assert(convals !=
NULL);
1953 for( i = 0; i < oracle->
nconss; ++i )
1978assert(oracle !=
NULL);
2009assert(oracle !=
NULL);
2011assert(conval !=
NULL);
2030 const int** offset,
2043assert(oracle !=
NULL);
2050 if( offset !=
NULL)
2068 if( offset !=
NULL)
2084 for( i = 0; i < oracle->
nconss; ++i )
2088cons = oracle->
conss[i];
2089assert(cons !=
NULL);
2108 for( j = 0; j < cons->
nlinidxs; ++j )
2119 for( j = 0; j < oracle->
nvars; ++j )
2121 if( nzflag[j] ==
FALSE)
2142 if( offset !=
NULL)
2179assert(oracle !=
NULL);
2180assert(jacobi !=
NULL);
2193 for( i = 0; i < oracle->
nconss; ++i )
2195cons = oracle->
conss[i];
2196assert(cons !=
NULL);
2200 if( convals !=
NULL)
2209 if( convals !=
NULL)
2210 for( l = 0; l < cons->
nlinidxs; ++l )
2219 SCIPdebug(
if( isnewx ) {printf(
"\nx =");
for( l = 0; l < oracle->
nvars; ++l) printf(
" %g",
x[l]); printf(
"\n");} )
2223 SCIPdebug( printf(
"g =");
for( l = oracle->
jacoffsets[i]; l < oracle->jacoffsets[i+1]; ++l) printf(
" %g", grad[oracle->
jaccols[l]]); printf(
"\n"); )
2227 SCIPdebugMessage(
"gradient evaluation yield invalid function value %g\n", nlval);
2231 if( convals !=
NULL)
2235 for( l = 0; l < cons->
nlinidxs; ++l )
2237 if( convals !=
NULL)
2251 SCIPdebugMessage(
"gradient evaluation yield invalid gradient value %g\n", grad[l]);
2255jacobi[k++] = grad[oracle->
jaccols[j]];
2257grad[oracle->
jaccols[j]] = 0.0;
2263 for( l = 0; l < oracle->
nvars; ++l )
2264assert(grad[l] == 0.0);
2289 const int** offset,
2301assert(oracle !=
NULL);
2308 if( offset !=
NULL)
2332 for( i = 0; i < oracle->
nconss; ++i )
2344 for( i = 0; i < oracle->
nvars; ++i )
2347 for( j = 0; j < colnnz[i]; ++j )
2362 if( offset !=
NULL)
2394assert(oracle !=
NULL);
2395assert(
x!=
NULL);
2396assert(lambda !=
NULL|| oracle->
nconss== 0);
2397assert(hessian !=
NULL);
2415assert( lambda !=
NULL);
2416 if( lambda[i] == 0.0 || oracle->
conss[i]->
expr==
NULL)
2432assert(oracle !=
NULL);
2448assert(oracle !=
NULL);
2464assert(oracle !=
NULL);
2472 for( i = 0; i < oracle->
nvars; ++i )
2488 for( i = 0; i < oracle->
nconss; ++i )
2531 static const char* nllevelname[4] = {
"LP",
"QCP",
"NLP",
"DNLP"};
2539assert(oracle !=
NULL);
2546havelongvarnames =
FALSE;
2547 for( i = 0; i < oracle->
nvars; ++i )
2550havelongvarnames =
TRUE;
2554havelongequnames =
FALSE;
2555 for( i = 0; i < oracle->
nconss; ++i )
2558havelongequnames =
TRUE;
2566 for( i = 0; i < oracle->
nvars; ++i )
2574 for( i = 0; i < oracle->
nvars; ++i )
2580 printName(namebuf, name, i,
'x',
NULL, havelongvarnames);
2587 printName(namebuf, name, i,
'x',
NULL, havelongvarnames);
2592 printName(namebuf, name, i,
'x',
NULL, havelongvarnames);
2596 if( initval !=
NULL)
2598 printName(namebuf, name, i,
'x',
NULL, havelongvarnames);
2606 for( i = 0; i < oracle->
nconss; ++i )
2628 for( i = 0; i < oracle->
nconss; ++i )
2661 if( nllevel <= 1 && oracle->conss[i]->expr !=
NULL)
2663 if( nllevel <= 2 && oracle->conss[i]->expr !=
NULL)
2677 SCIPinfoMessage(
scip, file,
"Solve %s minimizing NLPIORACLEOBJVAR using %s;\n", problemname, nllevelname[nllevel]);
#define SCIP_DEFAULT_EPSILON
power and signed power expression handlers
handler for variable index expressions
methods to interpret (evaluate) an expression "fast"
int SCIPgetIndexExprVaridx(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprVaridx(SCIP *scip, SCIP_EXPR *expr)
void SCIPsetIndexExprVaridx(SCIP_EXPR *expr, int newindex)
SCIP_Bool SCIPisExprSignpower(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPexprintCompile(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA **exprintdata)
SCIP_RETCODE SCIPexprintFreeData(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA **exprintdata)
SCIP_RETCODE SCIPexprintHessianSparsity(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, SCIP_Real *varvals, int **rowidxs, int **colidxs, int *nnz)
SCIP_RETCODE SCIPexprintFree(SCIP *scip, SCIP_EXPRINT **exprint)
SCIP_RETCODE SCIPexprintEval(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, SCIP_Real *varvals, SCIP_Real *val)
const char * SCIPexprintGetName(void)
SCIP_EXPRINTCAPABILITY SCIPexprintGetExprCapability(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata)
SCIP_RETCODE SCIPexprintHessian(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, SCIP_Real *varvals, SCIP_Bool new_varvals, SCIP_Real *val, int **rowidxs, int **colidxs, SCIP_Real **hessianvals, int *nnz)
SCIP_RETCODE SCIPexprintCreate(SCIP *scip, SCIP_EXPRINT **exprint)
SCIP_RETCODE SCIPexprintGrad(SCIP *scip, SCIP_EXPRINT *exprint, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, SCIP_Real *varvals, SCIP_Bool new_varvals, SCIP_Real *val, SCIP_Real *gradient)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPnlpiOracleEvalObjectiveValue(SCIP *scip, SCIP_NLPIORACLE *oracle, const SCIP_Real *x, SCIP_Real *objval)
SCIP_RETCODE SCIPnlpiOracleChgLinearCoefs(SCIP *scip, SCIP_NLPIORACLE *oracle, int considx, int nentries, const int *varidxs, const SCIP_Real *newcoefs)
SCIP_RETCODE SCIPnlpiOracleChgVarBounds(SCIP *scip, SCIP_NLPIORACLE *oracle, int nvars, const int *indices, const SCIP_Real *lbs, const SCIP_Real *ubs)
SCIP_RETCODE SCIPnlpiOracleAddConstraints(SCIP *scip, SCIP_NLPIORACLE *oracle, int nconss, const SCIP_Real *lhss, const SCIP_Real *rhss, const int *nlininds, int *const *lininds, SCIP_Real *const *linvals, SCIP_EXPR **exprs, const char **consnames)
SCIP_Bool SCIPnlpiOracleIsConstraintNonlinear(SCIP_NLPIORACLE *oracle, int considx)
SCIP_RETCODE SCIPnlpiOracleDelVarSet(SCIP *scip, SCIP_NLPIORACLE *oracle, int *delstats)
SCIP_RETCODE SCIPnlpiOracleEvalConstraintValues(SCIP *scip, SCIP_NLPIORACLE *oracle, const SCIP_Real *x, SCIP_Real *convals)
SCIP_RETCODE SCIPnlpiOracleCreate(SCIP *scip, SCIP_NLPIORACLE **oracle)
SCIP_RETCODE SCIPnlpiOracleGetJacobianSparsity(SCIP *scip, SCIP_NLPIORACLE *oracle, const int **offset, const int **col)
void SCIPnlpiOracleGetVarCounts(SCIP *scip, SCIP_NLPIORACLE *oracle, const int **lincounts, const int **nlcounts)
SCIP_RETCODE SCIPnlpiOracleGetHessianLagSparsity(SCIP *scip, SCIP_NLPIORACLE *oracle, const int **offset, const int **col)
char * SCIPnlpiOracleGetConstraintName(SCIP_NLPIORACLE *oracle, int considx)
SCIP_RETCODE SCIPnlpiOracleEvalObjectiveGradient(SCIP *scip, SCIP_NLPIORACLE *oracle, const SCIP_Real *x, SCIP_Bool isnewx, SCIP_Real *objval, SCIP_Real *objgrad)
SCIP_RETCODE SCIPnlpiOracleResetEvalTime(SCIP *scip, SCIP_NLPIORACLE *oracle)
SCIP_RETCODE SCIPnlpiOraclePrintProblem(SCIP *scip, SCIP_NLPIORACLE *oracle, FILE *file)
SCIP_RETCODE SCIPnlpiOracleSetObjective(SCIP *scip, SCIP_NLPIORACLE *oracle, const SCIP_Real constant, int nlin, const int *lininds, const SCIP_Real *linvals, SCIP_EXPR *expr)
SCIP_Real SCIPnlpiOracleGetConstraintRhs(SCIP_NLPIORACLE *oracle, int considx)
SCIP_Real SCIPnlpiOracleGetEvalTime(SCIP *scip, SCIP_NLPIORACLE *oracle)
SCIP_RETCODE SCIPnlpiOracleChgConsSides(SCIP *scip, SCIP_NLPIORACLE *oracle, int nconss, const int *indices, const SCIP_Real *lhss, const SCIP_Real *rhss)
SCIP_Real SCIPnlpiOracleGetConstraintLhs(SCIP_NLPIORACLE *oracle, int considx)
SCIP_RETCODE SCIPnlpiOracleAddVars(SCIP *scip, SCIP_NLPIORACLE *oracle, int nvars, const SCIP_Real *lbs, const SCIP_Real *ubs, const char **varnames)
SCIP_RETCODE SCIPnlpiOracleEvalConstraintGradient(SCIP *scip, SCIP_NLPIORACLE *oracle, const int considx, const SCIP_Real *x, SCIP_Bool isnewx, SCIP_Real *conval, SCIP_Real *congrad)
int SCIPnlpiOracleGetNVars(SCIP_NLPIORACLE *oracle)
int SCIPnlpiOracleGetNConstraints(SCIP_NLPIORACLE *oracle)
SCIP_EXPRINTCAPABILITY SCIPnlpiOracleGetEvalCapability(SCIP *scip, SCIP_NLPIORACLE *oracle)
SCIP_Real SCIPnlpiOracleGetObjectiveConstant(SCIP_NLPIORACLE *oracle)
SCIP_RETCODE SCIPnlpiOraclePrintProblemGams(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_Real *initval, FILE *file)
SCIP_RETCODE SCIPnlpiOracleEvalHessianLag(SCIP *scip, SCIP_NLPIORACLE *oracle, const SCIP_Real *x, SCIP_Bool isnewx_obj, SCIP_Bool isnewx_cons, SCIP_Real objfactor, const SCIP_Real *lambda, SCIP_Real *hessian)
SCIP_Bool SCIPnlpiOracleIsVarNonlinear(SCIP *scip, SCIP_NLPIORACLE *oracle, int varidx)
SCIP_RETCODE SCIPnlpiOracleEvalJacobian(SCIP *scip, SCIP_NLPIORACLE *oracle, const SCIP_Real *x, SCIP_Bool isnewx, SCIP_Real *convals, SCIP_Real *jacobi)
SCIP_RETCODE SCIPnlpiOracleDelConsSet(SCIP *scip, SCIP_NLPIORACLE *oracle, int *delstats)
SCIP_RETCODE SCIPnlpiOracleSetProblemName(SCIP *scip, SCIP_NLPIORACLE *oracle, const char *name)
SCIP_RETCODE SCIPnlpiOracleChgObjConstant(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_Real objconstant)
SCIP_RETCODE SCIPnlpiOracleEvalConstraintValue(SCIP *scip, SCIP_NLPIORACLE *oracle, int considx, const SCIP_Real *x, SCIP_Real *conval)
char ** SCIPnlpiOracleGetVarNames(SCIP_NLPIORACLE *oracle)
const SCIP_Real * SCIPnlpiOracleGetVarLbs(SCIP_NLPIORACLE *oracle)
const SCIP_Real * SCIPnlpiOracleGetVarUbs(SCIP_NLPIORACLE *oracle)
SCIP_RETCODE SCIPnlpiOracleFree(SCIP *scip, SCIP_NLPIORACLE **oracle)
const char * SCIPnlpiOracleGetProblemName(SCIP_NLPIORACLE *oracle)
SCIP_RETCODE SCIPnlpiOracleChgExpr(SCIP *scip, SCIP_NLPIORACLE *oracle, int considx, SCIP_EXPR *expr)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_EXPR * SCIPexpriterRestartDFS(SCIP_EXPRITER *iterator, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExpriter(SCIP *scip, SCIP_EXPRITER **iterator)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)
void SCIPfreeExpriter(SCIP_EXPRITER **iterator)
void SCIPcaptureExpr(SCIP_EXPR *expr)
SCIP_RETCODE SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)
SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)
#define SCIPfreeCleanBufferArray(scip, ptr)
#define SCIPallocCleanBufferArray(scip, ptr, num)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
#define SCIPallocClearBlockMemoryArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPallocMemory(scip, ptr)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
void SCIPsetClockEnabled(SCIP_CLOCK *clck, SCIP_Bool enable)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPsortedvecFindInt(int *intarray, int val, int len, int *pos)
void SCIPsortedvecInsertInt(int *intarray, int keyval, int *len, int *pos)
void SCIPsortIntReal(int *intarray, SCIP_Real *realarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
#define BMSfreeMemory(ptr)
#define BMSclearMemory(ptr)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
static SCIP_RETCODE moveVariable(SCIP *scip, SCIP_NLPIORACLE *oracle, int fromidx, int toidx)
static SCIP_RETCODE ensureIntArraySize(SCIP *scip, int **intarray, int *len, int minsize)
static SCIP_RETCODE freeConstraint(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_NLPIORACLECONS **cons, SCIP_Bool updatevarcount)
static SCIP_RETCODE hessLagSparsitySetNzFlagForExpr(SCIP *scip, SCIP_NLPIORACLE *oracle, int **colnz, int *collen, int *colnnz, int *nzcount, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, int dim)
static SCIP_RETCODE updateVariableCounts(SCIP *scip, SCIP_NLPIORACLE *oracle, int factor, int nlinidxs, const int *linidxs, SCIP_EXPR *expr)
static void freeVariables(SCIP *scip, SCIP_NLPIORACLE *oracle)
static void clearDeletedLinearElements(int **linidxs, SCIP_Real **coefs, int *nidxs)
static SCIP_RETCODE ensureConssSize(SCIP *scip, SCIP_NLPIORACLE *oracle, int minsize)
static SCIP_RETCODE createConstraint(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_NLPIORACLECONS **cons, int nlinidxs, const int *linidxs, const SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, const char *name)
static void invalidateJacobiSparsity(SCIP *scip, SCIP_NLPIORACLE *oracle)
static void printName(char *buffer, char *name, int idx, char prefix, const char *suffix, SCIP_Bool longnames)
static SCIP_RETCODE exprIsNonSmooth(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *nonsmooth)
static SCIP_RETCODE ensureConsLinSize(SCIP *scip, SCIP_NLPIORACLECONS *cons, int minsize)
static void mapIndices(int *indexmap, int nindices, int *indices)
static SCIP_RETCODE printFunction(SCIP *scip, SCIP_NLPIORACLE *oracle, FILE *file, SCIP_NLPIORACLECONS *cons, SCIP_Bool longvarnames)
static SCIP_RETCODE ensureVarsSize(SCIP *scip, SCIP_NLPIORACLE *oracle, int minsize)
static SCIP_RETCODE evalFunctionValue(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_NLPIORACLECONS *cons, const SCIP_Real *x, SCIP_Real *val)
static void invalidateHessianLagSparsity(SCIP *scip, SCIP_NLPIORACLE *oracle)
static void sortLinearCoefficients(int *nidxs, int *idxs, SCIP_Real *coefs)
static SCIP_RETCODE hessLagAddExpr(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_Real weight, const SCIP_Real *x, SCIP_Bool new_x, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, int *hesoffset, int *hescol, SCIP_Real *values)
static SCIP_RETCODE evalFunctionGradient(SCIP *scip, SCIP_NLPIORACLE *oracle, SCIP_NLPIORACLECONS *cons, const SCIP_Real *x, SCIP_Bool isnewx, SCIP_Real *RESTRICT val, SCIP_Real *RESTRICT grad)
static SCIP_RETCODE freeConstraints(SCIP *scip, SCIP_NLPIORACLE *oracle)
methods to store an NLP and request function, gradient, and Hessian values
SCIP_EXPRINTDATA * exprintdata
SCIP_NLPIORACLECONS * objective
SCIP_EXPRINT * exprinterpreter
SCIP_NLPIORACLECONS ** conss
struct SCIP_ExprIntData SCIP_EXPRINTDATA
#define SCIP_EXPRINTCAPABILITY_ALL
struct SCIP_ExprInt SCIP_EXPRINT
unsigned int SCIP_EXPRINTCAPABILITY
enum SCIP_Retcode SCIP_RETCODE
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