Scippy

SCIP

Solving Constraint Integer Programs

nlpi_all.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7 /* */
8 /* Licensed under the Apache License, Version 2.0 (the "License"); */
9 /* you may not use this file except in compliance with the License. */
10 /* You may obtain a copy of the License at */
11 /* */
12 /* http://www.apache.org/licenses/LICENSE-2.0 */
13 /* */
14 /* Unless required by applicable law or agreed to in writing, software */
15 /* distributed under the License is distributed on an "AS IS" BASIS, */
16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17 /* See the License for the specific language governing permissions and */
18 /* limitations under the License. */
19 /* */
20 /* You should have received a copy of the Apache-2.0 license */
21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22 /* */
23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24 
25 /**@file nlpi_all.c
26  * @ingroup DEFPLUGINS_NLPI
27  * @brief NLP interface that uses all available NLP interfaces
28  * @author Benjamin Mueller
29  */
30 
31 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32 
33 #include "scip/nlpi_all.h"
34 #include "scip/scip_mem.h"
35 #include "scip/scip_numerics.h"
36 #include "scip/scip_nlpi.h"
37 #include "scip/pub_message.h"
38 
39 #include <string.h>
40 
41 #define NLPI_NAME "all" /**< short concise name of solver */
42 #define NLPI_DESC "NLP interface that uses all available NLP interfaces" /**< description of solver */
43 #define NLPI_PRIORITY -3000 /**< priority of NLP solver */
44 
45 /*
46  * Data structures
47  */
48 
49 struct SCIP_NlpiData
50 {
51  SCIP_NLPI** nlpis; /**< array containing all nlpis */
52  int nnlpis; /**< total number of nlpis */
53 };
54 
56 {
57  SCIP_NLPIPROBLEM** nlpiproblems; /**< array containing all nlpi problems */
58  int nnlpiproblems; /**< total number of nlpi problems */
59  int bestidx; /**< index of NLP solver with the best solution */
60 };
61 
62 #ifdef SCIP_STATISTIC
63 static int _nnlps = 0; /**< number of NLPs that have been solved */
64 #endif
65 
66 /*
67  * Local methods
68  */
69 
70 /*
71  * Callback methods of NLP solver interface
72  */
73 
74 /** copy method of NLP interface (called when SCIP copies plugins) */
75 static
76 SCIP_DECL_NLPICOPY(nlpiCopyAll)
77 {
78  /* include NLPI */
80 
81  return SCIP_OKAY; /*lint !e527*/
82 } /*lint !e715*/
83 
84 /** destructor of NLP interface to free nlpi data */
85 static
86 SCIP_DECL_NLPIFREE(nlpiFreeAll)
87 {
88  assert(nlpi != NULL);
89  assert(nlpidata != NULL);
90  assert(*nlpidata != NULL);
91 
92  SCIPfreeBlockMemoryArrayNull(scip, &(*nlpidata)->nlpis, (*nlpidata)->nnlpis);
93  SCIPfreeBlockMemory(scip, nlpidata);
94  assert(*nlpidata == NULL);
95 
96  return SCIP_OKAY; /*lint !e527*/
97 } /*lint !e715*/
98 
99 /** creates a problem instance */
100 static
101 SCIP_DECL_NLPICREATEPROBLEM(nlpiCreateProblemAll)
102 {
103  SCIP_NLPIDATA* data;
104  int i;
105 
106  assert(nlpi != NULL);
107  assert(problem != NULL);
108 
109  data = SCIPnlpiGetData(nlpi);
110  assert(data != NULL);
111 
113 
114  /* initialize problem */
115  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(*problem)->nlpiproblems, data->nnlpis) );
116  (*problem)->nnlpiproblems = data->nnlpis;
117 
118  for( i = 0; i < data->nnlpis; ++i )
119  {
120  assert(data->nlpis[i] != NULL);
121  SCIP_CALL( SCIPcreateNlpiProblem(scip, data->nlpis[i], &((*problem)->nlpiproblems[i]), name) );
122  }
123 
124  return SCIP_OKAY;
125 } /*lint !e715*/
126 
127 /** free a problem instance */
128 static
129 SCIP_DECL_NLPIFREEPROBLEM(nlpiFreeProblemAll)
130 {
131  SCIP_NLPIDATA* data;
132  int i;
133 
134  assert(nlpi != NULL);
135  assert(problem != NULL);
136  assert(*problem != NULL);
137 
138  data = SCIPnlpiGetData(nlpi);
139  assert(data != NULL);
140 
141  for( i = 0; i < data->nnlpis; ++i )
142  {
143  assert(data->nlpis[i] != NULL);
144  SCIP_CALL( SCIPfreeNlpiProblem(scip, data->nlpis[i], &(*problem)->nlpiproblems[i]) );
145  }
146 
147  SCIPfreeBlockMemoryArrayNull(scip, &(*problem)->nlpiproblems, data->nnlpis);
148  SCIPfreeBlockMemory(scip, problem);
149 
150  return SCIP_OKAY;
151 } /*lint !e715*/
152 
153 /** add variables */
154 static
155 SCIP_DECL_NLPIADDVARS(nlpiAddVarsAll)
156 {
157  SCIP_NLPIDATA* nlpidata;
158  int i;
159 
160  nlpidata = SCIPnlpiGetData(nlpi);
161  assert(nlpidata != NULL);
162 
163  for( i = 0; i < nlpidata->nnlpis; ++i )
164  {
165  assert(nlpidata->nlpis[i] != NULL);
166  assert(problem->nlpiproblems[i] != NULL);
167 
168  SCIP_CALL( SCIPaddNlpiVars(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], nvars, lbs, ubs, varnames) );
169  }
170 
171  return SCIP_OKAY;
172 } /*lint !e715*/
173 
174 
175 /** add constraints */
176 static
177 SCIP_DECL_NLPIADDCONSTRAINTS(nlpiAddConstraintsAll)
178 {
179  SCIP_NLPIDATA* nlpidata;
180  int i;
181 
182  nlpidata = SCIPnlpiGetData(nlpi);
183  assert(nlpidata != NULL);
184 
185  for( i = 0; i < nlpidata->nnlpis; ++i )
186  {
187  assert(nlpidata->nlpis[i] != NULL);
188  assert(problem->nlpiproblems[i] != NULL);
189 
190  SCIP_CALL( SCIPaddNlpiConstraints(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], nconss, lhss, rhss,
191  nlininds, lininds, linvals, exprs, names) );
192  }
193 
194  return SCIP_OKAY;
195 } /*lint !e715*/
196 
197 /** sets or overwrites objective, a minimization problem is expected */
198 static
199 SCIP_DECL_NLPISETOBJECTIVE(nlpiSetObjectiveAll)
200 {
201  SCIP_NLPIDATA* nlpidata;
202  int i;
203 
204  nlpidata = SCIPnlpiGetData(nlpi);
205  assert(nlpidata != NULL);
206 
207  for( i = 0; i < nlpidata->nnlpis; ++i )
208  {
209  assert(nlpidata->nlpis[i] != NULL);
210  assert(problem->nlpiproblems[i] != NULL);
211 
212  SCIP_CALL( SCIPsetNlpiObjective(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], nlins, lininds, linvals, expr, constant) );
213  }
214 
215  return SCIP_OKAY;
216 } /*lint !e715*/
217 
218 /** change variable bounds */
219 static
220 SCIP_DECL_NLPICHGVARBOUNDS(nlpiChgVarBoundsAll)
221 {
222  SCIP_NLPIDATA* nlpidata;
223  int i;
224 
225  nlpidata = SCIPnlpiGetData(nlpi);
226  assert(nlpidata != NULL);
227 
228  for( i = 0; i < nlpidata->nnlpis; ++i )
229  {
230  assert(nlpidata->nlpis[i] != NULL);
231  assert(problem->nlpiproblems[i] != NULL);
232 
233  SCIP_CALL( SCIPchgNlpiVarBounds(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], nvars, indices, lbs, ubs) );
234  }
235 
236  return SCIP_OKAY;
237 } /*lint !e715*/
238 
239 /** change constraint bounds */
240 static
241 SCIP_DECL_NLPICHGCONSSIDES(nlpiChgConsSidesAll)
242 {
243  SCIP_NLPIDATA* nlpidata;
244  int i;
245 
246  nlpidata = SCIPnlpiGetData(nlpi);
247  assert(nlpidata != NULL);
248 
249  for( i = 0; i < nlpidata->nnlpis; ++i )
250  {
251  assert(nlpidata->nlpis[i] != NULL);
252  assert(problem->nlpiproblems[i] != NULL);
253 
254  SCIP_CALL( SCIPchgNlpiConsSides(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], nconss, indices, lhss, rhss) );
255  }
256 
257  return SCIP_OKAY;
258 } /*lint !e715*/
259 
260 /** delete a set of variables */
261 static
262 SCIP_DECL_NLPIDELVARSET(nlpiDelVarSetAll)
263 {
264  SCIP_NLPIDATA* nlpidata;
265  int* tmpdstats;
266  int i;
267 
268  nlpidata = SCIPnlpiGetData(nlpi);
269  assert(nlpidata != NULL);
270 
271  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &tmpdstats, dstatssize) );
272 
273  for( i = 0; i < nlpidata->nnlpis; ++i )
274  {
275  assert(nlpidata->nlpis[i] != NULL);
276  assert(problem->nlpiproblems[i] != NULL);
277 
278  if( i < nlpidata->nnlpis -1 )
279  {
280  /* restore dstats entries */
281  BMScopyMemoryArray(tmpdstats, dstats, dstatssize);
282 
283  SCIP_CALL( SCIPdelNlpiVarSet(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], tmpdstats, dstatssize) );
284  }
285  else
286  {
287  /* NOTE this works only when all dstats array are the same after calling the nlpidelvarset callback
288  * As long as all solvers use the SCIP NLPI oracle to store the NLP problem data, this is the case.
289  * @TODO Assert that the returned dstats are all the same?
290  */
291  SCIP_CALL( SCIPdelNlpiVarSet(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], dstats, dstatssize) );
292  }
293  }
294 
295  SCIPfreeBlockMemoryArray(scip, &tmpdstats, dstatssize);
296 
297  return SCIP_OKAY;
298 } /*lint !e715*/
299 
300 /** delete a set of constraints */
301 static
302 SCIP_DECL_NLPIDELCONSSET( nlpiDelConstraintSetAll )
303 {
304  SCIP_NLPIDATA* nlpidata;
305  int* tmpdstats;
306  int i;
307 
308  nlpidata = SCIPnlpiGetData(nlpi);
309  assert(nlpidata != NULL);
310 
311  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &tmpdstats, dstatssize) );
312 
313  for( i = 0; i < nlpidata->nnlpis; ++i )
314  {
315  assert(nlpidata->nlpis[i] != NULL);
316  assert(problem->nlpiproblems[i] != NULL);
317 
318  if( i < nlpidata->nnlpis - 1 )
319  {
320  /* restore dstats entries */
321  BMScopyMemoryArray(tmpdstats, dstats, dstatssize);
322 
323  SCIP_CALL( SCIPdelNlpiConsSet(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], tmpdstats, dstatssize) );
324  }
325  else
326  {
327  /* NOTE this works only when all dstats array are the same after calling the nlpidelconsset callback
328  * As long as all solvers use the SCIP NLPI oracle to store the NLP problem data, this is the case.
329  * @TODO Assert that the returned dstats are all the same?
330  */
331  SCIP_CALL( SCIPdelNlpiConsSet(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], dstats, dstatssize) );
332  }
333  }
334 
335  SCIPfreeBlockMemoryArray(scip, &tmpdstats, dstatssize);
336 
337  return SCIP_OKAY;
338 } /*lint !e715*/
339 
340 /** changes (or adds) linear coefficients in a constraint or objective */
341 static
342 SCIP_DECL_NLPICHGLINEARCOEFS(nlpiChgLinearCoefsAll)
343 {
344  SCIP_NLPIDATA* nlpidata;
345  int i;
346 
347  nlpidata = SCIPnlpiGetData(nlpi);
348  assert(nlpidata != NULL);
349 
350  for( i = 0; i < nlpidata->nnlpis; ++i )
351  {
352  assert(nlpidata->nlpis[i] != NULL);
353  assert(problem->nlpiproblems[i] != NULL);
354 
355  SCIP_CALL( SCIPchgNlpiLinearCoefs(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], idx, nvals, varidxs, vals) );
356  }
357 
358  return SCIP_OKAY;
359 } /*lint !e715*/
360 
361 /** replaces the expression of a constraint or objective */
362 static
363 SCIP_DECL_NLPICHGEXPR(nlpiChgExprAll)
364 {
365  SCIP_NLPIDATA* nlpidata;
366  int i;
367 
368  nlpidata = SCIPnlpiGetData(nlpi);
369  assert(nlpidata != NULL);
370 
371  for( i = 0; i < nlpidata->nnlpis; ++i )
372  {
373  assert(nlpidata->nlpis[i] != NULL);
374  assert(problem->nlpiproblems[i] != NULL);
375 
376  SCIP_CALL( SCIPchgNlpiExpr(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], idxcons, expr) );
377  }
378 
379  return SCIP_OKAY;
380 } /*lint !e715*/
381 
382 /** change the constant offset in the objective */
383 static
384 SCIP_DECL_NLPICHGOBJCONSTANT(nlpiChgObjConstantAll)
385 {
386  SCIP_NLPIDATA* nlpidata;
387  int i;
388 
389  nlpidata = SCIPnlpiGetData(nlpi);
390  assert(nlpidata != NULL);
391 
392  for( i = 0; i < nlpidata->nnlpis; ++i )
393  {
394  assert(nlpidata->nlpis[i] != NULL);
395  assert(problem->nlpiproblems[i] != NULL);
396 
397  SCIP_CALL( SCIPchgNlpiObjConstant(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], objconstant) );
398  }
399 
400  return SCIP_OKAY;
401 } /*lint !e715*/
402 
403 /** sets initial guess for primal variables */
404 static
405 SCIP_DECL_NLPISETINITIALGUESS(nlpiSetInitialGuessAll)
406 {
407  SCIP_NLPIDATA* nlpidata;
408  int i;
409 
410  nlpidata = SCIPnlpiGetData(nlpi);
411  assert(nlpidata != NULL);
412 
413  for( i = 0; i < nlpidata->nnlpis; ++i )
414  {
415  assert(nlpidata->nlpis[i] != NULL);
416  assert(problem->nlpiproblems[i] != NULL);
417 
418  SCIP_CALL( SCIPsetNlpiInitialGuess(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], primalvalues, consdualvalues,
419  varlbdualvalues, varubdualvalues) );
420  }
421 
422  return SCIP_OKAY;
423 } /*lint !e715*/
424 
425 /** tries to solve NLP */
426 static
427 SCIP_DECL_NLPISOLVE(nlpiSolveAll)
428 {
429  SCIP_NLPIDATA* nlpidata;
430  SCIP_NLPTERMSTAT besttermstat;
431  SCIP_NLPSOLSTAT bestsolstat;
432  SCIP_Real bestsolval;
433  int i;
434 
435  nlpidata = SCIPnlpiGetData(nlpi);
436  assert(nlpidata != NULL);
437 
438  /* use first solver per default */
439  problem->bestidx = 0;
440 
441  /* initialize best solution values */
442  besttermstat = SCIP_NLPTERMSTAT_OTHER;
443  bestsolstat = SCIP_NLPSOLSTAT_UNKNOWN;
444  bestsolval = SCIPinfinity(scip);
445 
446  for( i = 0; i < nlpidata->nnlpis; ++i )
447  {
448  SCIP_NLPTERMSTAT termstat;
449  SCIP_NLPSOLSTAT solstat;
450  SCIP_Real solval;
451  SCIP_Bool update;
452 
453  assert(nlpidata->nlpis[i] != NULL);
454  assert(problem->nlpiproblems[i] != NULL);
455 
456  /* solve NLP */
457  SCIP_CALL( SCIPsolveNlpiParam(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], param) );
458 
459  termstat = SCIPgetNlpiTermstat(scip, nlpidata->nlpis[i], problem->nlpiproblems[i]);
460  solstat = SCIPgetNlpiSolstat(scip, nlpidata->nlpis[i], problem->nlpiproblems[i]);
461  solval = SCIPinfinity(scip);
462  update = FALSE;
463 
464  /* collect solution value */
465  if( solstat <= SCIP_NLPSOLSTAT_FEASIBLE )
466  {
467  SCIP_CALL( SCIPgetNlpiSolution(scip, nlpidata->nlpis[i], problem->nlpiproblems[i],
468  NULL, NULL, NULL, NULL, &solval) );
469  assert(!SCIPisInfinity(scip, solval));
470  }
471 
472  /* better termination status -> update best solver */
473  if( termstat < besttermstat )
474  update = TRUE;
475 
476  /* no feasible solutions have been found so far -> update best solver */
477  else if( bestsolstat >= SCIP_NLPSOLSTAT_LOCINFEASIBLE && solstat <= SCIP_NLPSOLSTAT_LOCINFEASIBLE )
478  update = TRUE;
479 
480  /* use solver with the better solution value */
481  else if( solval < bestsolval )
482  update = TRUE;
483 
484  /* update best solver */
485  if( update )
486  {
487  besttermstat = termstat;
488  bestsolstat = solstat;
489  bestsolval = solval;
490  problem->bestidx = i;
491  }
492 
493 #ifdef SCIP_STATISTIC
494  {
495  SCIP_NLPSTATISTICS stats;
496 
497  SCIP_CALL( SCIPgetNlpiStatistics(scip, nlpidata->nlpis[i], problem->nlpiproblems[i], &stats) );
498 
499  SCIPstatisticMessage("%d solver %s termstat %d solstat %d solval %e iters %d time %g\n",
500  _nnlps, SCIPnlpiGetName(nlpidata->nlpis[i]), termstat, solstat, solval,
501  stats.niterations, stats.totaltime);
502  }
503 #endif
504 
505  /* don't try more NLP solvers if allowed time is exceeded or SCIP is asked to interrupt */
506  if( termstat == SCIP_NLPTERMSTAT_TIMELIMIT || termstat == SCIP_NLPTERMSTAT_INTERRUPT )
507  break;
508  }
509 
510 #ifdef SCIP_STATISTIC
511  ++_nnlps;
512 #endif
513 
514  return SCIP_OKAY;
515 } /*lint !e715*/
516 
517 /** gives solution status */
518 static
519 SCIP_DECL_NLPIGETSOLSTAT(nlpiGetSolstatAll)
520 {
521  SCIP_NLPIDATA* nlpidata;
522 
523  nlpidata = SCIPnlpiGetData(nlpi);
524  assert(nlpidata != NULL);
525  assert(nlpidata->nlpis != NULL);
526  assert(nlpidata->nlpis[problem->bestidx] != NULL);
527  assert(problem->nlpiproblems != NULL);
528  assert(problem->nlpiproblems[problem->bestidx] != NULL);
529 
530  /* return the solution status of the first nlpi */
531  return SCIPgetNlpiSolstat(scip, nlpidata->nlpis[problem->bestidx], problem->nlpiproblems[problem->bestidx]);
532 }
533 
534 /** gives termination reason */
535 static
536 SCIP_DECL_NLPIGETTERMSTAT(nlpiGetTermstatAll)
537 {
538  SCIP_NLPIDATA* nlpidata;
539 
540  nlpidata = SCIPnlpiGetData(nlpi);
541  assert(nlpidata != NULL);
542  assert(nlpidata->nlpis != NULL);
543  assert(nlpidata->nlpis[problem->bestidx] != NULL);
544  assert(problem->nlpiproblems != NULL);
545  assert(problem->nlpiproblems[problem->bestidx] != NULL);
546 
547  /* return the solution status of the first nlpi */
548  return SCIPgetNlpiTermstat(scip, nlpidata->nlpis[problem->bestidx], problem->nlpiproblems[problem->bestidx]);
549 }
550 
551 /** gives primal and dual solution values */
552 static
553 SCIP_DECL_NLPIGETSOLUTION(nlpiGetSolutionAll)
554 {
555  SCIP_NLPIDATA* nlpidata;
556 
557  nlpidata = SCIPnlpiGetData(nlpi);
558  assert(nlpidata != NULL);
559  assert(nlpidata->nlpis != NULL);
560  assert(nlpidata->nlpis[problem->bestidx] != NULL);
561  assert(problem->nlpiproblems != NULL);
562  assert(problem->nlpiproblems[problem->bestidx] != NULL);
563 
564  /* return the solution status of the first nlpi */
565  SCIP_CALL( SCIPgetNlpiSolution(scip, nlpidata->nlpis[problem->bestidx], problem->nlpiproblems[problem->bestidx],
566  primalvalues, consdualvalues, varlbdualvalues, varubdualvalues, objval) );
567 
568  return SCIP_OKAY;
569 }
570 
571 /** gives solve statistics */
572 static
573 SCIP_DECL_NLPIGETSTATISTICS(nlpiGetStatisticsAll)
574 {
575  SCIP_NLPIDATA* nlpidata;
576 
577  nlpidata = SCIPnlpiGetData(nlpi);
578  assert(nlpidata != NULL);
579  assert(nlpidata->nlpis != NULL);
580  assert(nlpidata->nlpis[problem->bestidx] != NULL);
581  assert(problem->nlpiproblems != NULL);
582  assert(problem->nlpiproblems[problem->bestidx] != NULL);
583 
584  /* collect statistics of the first solver */
585  SCIP_CALL( SCIPgetNlpiStatistics(scip, nlpidata->nlpis[problem->bestidx], problem->nlpiproblems[problem->bestidx],
586  statistics) );
587 
588  return SCIP_OKAY;
589 } /*lint !e715*/
590 
591 /*
592  * NLP solver interface specific interface methods
593  */
594 
595 /** create solver interface for the solver "All" and includes it into SCIP, if at least 2 NLPIs have already been included
596  *
597  * This method should be called after all other NLP solver interfaces have been included.
598  */
600  SCIP* scip /**< SCIP data structure */
601  )
602 {
603  SCIP_NLPIDATA* nlpidata;
604  int i;
605 
606  assert(scip != NULL);
607 
608  /* the number of NLPIs so far must be >= 2 */
609  if( SCIPgetNNlpis(scip) < 2 )
610  return SCIP_OKAY;
611 
612  /* create all solver interface data */
613  SCIP_CALL( SCIPallocClearBlockMemory(scip, &nlpidata) );
614 
615  nlpidata->nnlpis = SCIPgetNNlpis(scip);
616  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &nlpidata->nlpis, nlpidata->nnlpis) );
617 
618  /* copy nlpi pointers TODO should not need that */
619  for( i = 0; i < nlpidata->nnlpis; ++i )
620  nlpidata->nlpis[i] = SCIPgetNlpis(scip)[i];
621 
622  /* create solver interface */
625  nlpiCopyAll, nlpiFreeAll, NULL,
626  nlpiCreateProblemAll, nlpiFreeProblemAll, NULL,
627  nlpiAddVarsAll, nlpiAddConstraintsAll, nlpiSetObjectiveAll,
628  nlpiChgVarBoundsAll, nlpiChgConsSidesAll, nlpiDelVarSetAll, nlpiDelConstraintSetAll,
629  nlpiChgLinearCoefsAll, nlpiChgExprAll,
630  nlpiChgObjConstantAll, nlpiSetInitialGuessAll, nlpiSolveAll, nlpiGetSolstatAll, nlpiGetTermstatAll,
631  nlpiGetSolutionAll, nlpiGetStatisticsAll,
632  nlpidata) );
633 
634  return SCIP_OKAY;
635 }
#define NLPI_DESC
Definition: nlpi_all.c:42
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:110
#define NULL
Definition: def.h:267
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition: type_nlpi.h:194
SCIP_NLPIDATA * SCIPnlpiGetData(SCIP_NLPI *nlpi)
Definition: nlpi.c:712
#define SCIPallocBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:93
static SCIP_DECL_NLPICHGEXPR(nlpiChgExprAll)
Definition: nlpi_all.c:363
public methods for memory management
#define FALSE
Definition: def.h:94
SCIP_Real SCIPinfinity(SCIP *scip)
#define TRUE
Definition: def.h:93
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
#define SCIPstatisticMessage
Definition: pub_message.h:123
SCIP_NLPIPROBLEM ** nlpiproblems
Definition: nlpi_all.c:57
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition: nlpi.c:722
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
Definition: scip_nlpi.c:187
static SCIP_DECL_NLPICOPY(nlpiCopyAll)
Definition: nlpi_all.c:76
public methods for numerical tolerances
int SCIPgetNNlpis(SCIP *scip)
Definition: scip_nlpi.c:200
public methods for NLPI solver interfaces
static SCIP_DECL_NLPIGETSOLSTAT(nlpiGetSolstatAll)
Definition: nlpi_all.c:519
#define NLPI_PRIORITY
Definition: nlpi_all.c:43
struct SCIP_NlpiData SCIP_NLPIDATA
Definition: type_nlpi.h:52
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
Definition: type_nlpi.h:168
static SCIP_DECL_NLPISOLVE(nlpiSolveAll)
Definition: nlpi_all.c:427
SCIP_Real totaltime
Definition: type_nlpi.h:200
#define NLPI_NAME
Definition: nlpi_all.c:41
static SCIP_DECL_NLPISETOBJECTIVE(nlpiSetObjectiveAll)
Definition: nlpi_all.c:199
#define SCIP_CALL(x)
Definition: def.h:380
static SCIP_DECL_NLPIGETSOLUTION(nlpiGetSolutionAll)
Definition: nlpi_all.c:553
static SCIP_DECL_NLPICHGLINEARCOEFS(nlpiChgLinearCoefsAll)
Definition: nlpi_all.c:342
static SCIP_DECL_NLPIGETSTATISTICS(nlpiGetStatisticsAll)
Definition: nlpi_all.c:573
#define SCIP_Bool
Definition: def.h:91
static SCIP_DECL_NLPIDELCONSSET(nlpiDelConstraintSetAll)
Definition: nlpi_all.c:302
static SCIP_DECL_NLPICHGOBJCONSTANT(nlpiChgObjConstantAll)
Definition: nlpi_all.c:384
static SCIP_DECL_NLPIADDCONSTRAINTS(nlpiAddConstraintsAll)
Definition: nlpi_all.c:177
#define BMScopyMemoryArray(ptr, source, num)
Definition: memory.h:134
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
NLP interface that uses all available NLP interfaces.
static SCIP_DECL_NLPIGETTERMSTAT(nlpiGetTermstatAll)
Definition: nlpi_all.c:536
static SCIP_DECL_NLPICREATEPROBLEM(nlpiCreateProblemAll)
Definition: nlpi_all.c:101
static SCIP_DECL_NLPISETINITIALGUESS(nlpiSetInitialGuessAll)
Definition: nlpi_all.c:405
static SCIP_DECL_NLPIFREE(nlpiFreeAll)
Definition: nlpi_all.c:86
public methods for message output
#define SCIP_Real
Definition: def.h:173
SCIP_RETCODE SCIPincludeNlpSolverAll(SCIP *scip)
Definition: nlpi_all.c:599
static SCIP_DECL_NLPICHGVARBOUNDS(nlpiChgVarBoundsAll)
Definition: nlpi_all.c:220
static SCIP_DECL_NLPIFREEPROBLEM(nlpiFreeProblemAll)
Definition: nlpi_all.c:129
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
Definition: scip_mem.h:111
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, const char *name, const char *description, int priority, SCIP_DECL_NLPICOPY((*nlpicopy)), SCIP_DECL_NLPIFREE((*nlpifree)), SCIP_DECL_NLPIGETSOLVERPOINTER((*nlpigetsolverpointer)), SCIP_DECL_NLPICREATEPROBLEM((*nlpicreateproblem)), SCIP_DECL_NLPIFREEPROBLEM((*nlpifreeproblem)), SCIP_DECL_NLPIGETPROBLEMPOINTER((*nlpigetproblempointer)), SCIP_DECL_NLPIADDVARS((*nlpiaddvars)), SCIP_DECL_NLPIADDCONSTRAINTS((*nlpiaddconstraints)), SCIP_DECL_NLPISETOBJECTIVE((*nlpisetobjective)), SCIP_DECL_NLPICHGVARBOUNDS((*nlpichgvarbounds)), SCIP_DECL_NLPICHGCONSSIDES((*nlpichgconssides)), SCIP_DECL_NLPIDELVARSET((*nlpidelvarset)), SCIP_DECL_NLPIDELCONSSET((*nlpidelconsset)), SCIP_DECL_NLPICHGLINEARCOEFS((*nlpichglinearcoefs)), SCIP_DECL_NLPICHGEXPR((*nlpichgexpr)), SCIP_DECL_NLPICHGOBJCONSTANT((*nlpichgobjconstant)), SCIP_DECL_NLPISETINITIALGUESS((*nlpisetinitialguess)), SCIP_DECL_NLPISOLVE((*nlpisolve)), SCIP_DECL_NLPIGETSOLSTAT((*nlpigetsolstat)), SCIP_DECL_NLPIGETTERMSTAT((*nlpigettermstat)), SCIP_DECL_NLPIGETSOLUTION((*nlpigetsolution)), SCIP_DECL_NLPIGETSTATISTICS((*nlpigetstatistics)), SCIP_NLPIDATA *nlpidata)
Definition: scip_nlpi.c:108
#define SCIPallocClearBlockMemory(scip, ptr)
Definition: scip_mem.h:91
static SCIP_DECL_NLPICHGCONSSIDES(nlpiChgConsSidesAll)
Definition: nlpi_all.c:241
static SCIP_DECL_NLPIDELVARSET(nlpiDelVarSetAll)
Definition: nlpi_all.c:262
static SCIP_DECL_NLPIADDVARS(nlpiAddVarsAll)
Definition: nlpi_all.c:155