SCIP Optimization Suite

https://scipopt.org/doc/html/
Admin
SCIP is a framework and solver for constraint integer programs (CIPs) and mixed-integer nonlinear...
Tokens:18,697,005
Snippets:83,935
Trust Score:9.2
Update:9 months ago
Show doc for...
Tokens:
Raw
### Start Initial LP Setup in SCIP Pricestore (C)

Source: https://scipopt.org/doc/html/pricestore_8c_source

Informs the pricing storage that the setup of the initial LP is starting. Asserts that the pricing storage is not already in the initial LP state and that no variables have been added yet. Sets the 'initiallp' flag to TRUE.

```c
void SCIPpricestoreStartInitialLP(
    SCIP_PRICESTORE* pricestore /**< pricing storage */
)
{
    assert(pricestore != NULL);
    assert(!pricestore->initiallp);
    assert(pricestore->nvars == 0);

    pricestore->initiallp = TRUE;
}
```

--------------------------------

### Setup Starting Point - C

Source: https://scipopt.org/doc/html/nlpi__filtersqp_8c_source

Calls the setupStart function to establish an initial starting point for the optimization. It includes error handling to gracefully manage cases where a valid starting point cannot be determined, potentially leading to solver termination.

```C
SCIP_CALL( setupStart(data, problem, problem->x, &success) );
if( !success )
{
    /* FilterSQP would crash if starting point cannot be evaluated, so give up */
    SCIP_CALL( processSolveOutcome(data, problem, 7, param.feastol, param.opttol, NULL, NULL) );
    return SCIP_OKAY;
}
```

--------------------------------

### SCIPpricestoreStartInitialLP

Source: https://scipopt.org/doc/html/pricestore_8c_source

Informs the pricing storage that the setup of the initial LP is starting.

```APIDOC
## SCIPpricestoreStartInitialLP

### Description
Informs the pricing storage that the setup of the initial LP is starting.

### Method
`void`

### Parameters
- **pricestore** (SCIP_PRICESTORE*) - Pointer to the pricing storage.

### Request Example
```c
SCIP_PRICESTORE* pricestore;
// ... initialize pricestore
SCIPpricestoreStartInitialLP(pricestore);
```

### Response
This function does not return a value.
```

--------------------------------

### Prepare NLP Starting Point (C)

Source: https://scipopt.org/doc/html/heur__subnlp_8c_source

Allocates buffer space for an NLP starting point and potentially prints messages indicating its setup. This prepares the solver to use the current solution or LP solution as a starting point for NLP calculations.

```c
/* set starting values (=refpoint, if not NULL; otherwise LP solution (or pseudo solution)) */
SCIP_CALL( SCIPallocBufferArray(scip, &startpoint, SCIPgetNNLPVars(heurdata->subscip)) );

if( heurdata->nlpverblevel >= 3 )
{
SCIPinfoMessage(scip, NULL, "set NLP starting point\n");
}

for( i = 0; i < SCIPgetNNLPVars(heurdata->subscip); ++i )
{
SCIP_Real scalar;
SCIP_Real constant;

subvar = SCIPgetNLPVars(heurdata->subscip)[i];

```

--------------------------------

### Get Starting Point for Optimization in C++

Source: https://scipopt.org/doc/html/nlpi__ipopt_8cpp_source

This function provides the starting point for the optimization algorithm, including primal and dual values. It conditionally retrieves values based on the boolean flags init_x, init_z, and init_lambda. It depends on the SCIPnlpiOracleGetNVars and SCIPnlpiOracleGetNConstraints functions and requires the NLPIPProblem struct to have valid solution data.

```C++
bool ScipNLP::get_starting_point(
    Index n, /**< number of variables */
    bool init_x, /**< whether initial values for primal values are requested */
    Number* x, /**< buffer to store initial primal values */
    bool init_z, /**< whether initial values for dual values of variable bounds are requested */
    Number* z_L, /**< buffer to store dual values for variable lower bounds */
    Number* z_U, /**< buffer to store dual values for variable upper bounds */
    Index m, /**< number of constraints */
    bool init_lambda, /**< whether initial values for dual values of constraints are required */
    Number* lambda /**< buffer to store dual values of constraints */
)
{
    assert(nlpiproblem != NULL);
    assert(nlpiproblem->oracle != NULL);

    assert(n == SCIPnlpiOracleGetNVars(nlpiproblem->oracle));
    assert(m == SCIPnlpiOracleGetNConstraints(nlpiproblem->oracle));

    if( init_x )
    {
        assert(nlpiproblem->solprimalvalid);
        assert(nlpiproblem->solprimals != NULL);
        BMScopyMemoryArray(x, nlpiproblem->solprimals, n);
    }

    if( init_z )
    {
        assert(nlpiproblem->soldualvalid);
        assert(nlpiproblem->soldualvarlb != NULL);
        assert(nlpiproblem->soldualvarub != NULL);
        BMScopyMemoryArray(z_L, nlpiproblem->soldualvarlb, n);
        BMScopyMemoryArray(z_U, nlpiproblem->soldualvarub, n);
    }

    if( init_lambda )
    {
        assert(nlpiproblem->soldualvalid);
        assert(nlpiproblem->soldualcons != NULL);
        BMScopyMemoryArray(lambda, nlpiproblem->soldualcons, m);
    }

    return true;
}

```

--------------------------------

### Copying SCIP Example Project (Bash)

Source: https://scipopt.org/doc/html/START

Demonstrates how to copy an example project from the SCIP distribution to a new directory for customization. This is useful for starting new projects based on existing SCIP examples.

```bash
cp -r examples/Binpacking/ ../SCIPProject/ ; cd ../SCIPProject
```

--------------------------------

### SCIP Pricer Get Setup Time

Source: https://scipopt.org/doc/html/pricer_8c_source

Function to get the setup time of a SCIP pricer.

```c
SCIP_Real SCIPpricerGetSetupTime(SCIP_PRICER *pricer);
```

--------------------------------

### Get Setup Time for Constraint Handler

Source: https://scipopt.org/doc/html/pub__cons_8h_source

Returns the time spent in the setup phase of a constraint handler. This helps in profiling the initialization and setup overhead.

```c
SCIP_Real SCIPconshdlrGetSetupTime(SCIP_CONSHDLR *conshdlr)
{
    /* implementation details */
}

```

--------------------------------

### Start SCIP LPI Exact Interface

Source: https://scipopt.org/doc/html/lpiexact__qsoex_8c_source

Function to initialize the SCIP LPI Exact interface globally. `SCIPlpiExactStart` should be called once before using any other LPI functions.

```c
void SCIPlpiExactStart(void);
```

--------------------------------

### SCIPlpiExactStart

Source: https://scipopt.org/doc/html/lpiexact_8h

Initializes the LPI exact solver. This method typically prepares the solver for subsequent operations.

```APIDOC
## SCIPlpiExactStart

### Description
Initializes the LPI exact solver.

### Method
GET

### Endpoint
SCIPlpiExactStart()

### Parameters
None

### Response
#### Success Response (200)
- **status** (void) - Indicates successful execution.

#### Response Example
{
  "status": "solver started"
}
```

--------------------------------

### Get Earliest Start Permutation (C)

Source: https://scipopt.org/doc/html/heur__listscheduling_8c

Determines a job permutation based on their earliest start times. It uses start times, earliest start times, and a permutation array.

```c
static SCIP_RETCODE getEstPermutation (SCIP *scip, int *starttimes, int *ests, int *perm, int njobs)
```

--------------------------------

### Initial LP Setup Notifications

Source: https://scipopt.org/doc/html/pricestore_8h_source

Functions to notify the pricestore about the start and end of the initial LP setup.

```APIDOC
## SCIPpricestoreStartInitialLP

### Description
Informs the pricing storage that the setup of the initial LP is starting.

### Method
void

### Parameters
- **pricestore** (*SCIP_PRICESTORE*) - The pricing storage.

### Response Example
```json
{
  "status": "completed"
}
```

## SCIPpricestoreEndInitialLP

### Description
Informs the pricing storage that the setup of the initial LP is finished.

### Method
void

### Parameters
- **pricestore** (*SCIP_PRICESTORE*) - The pricing storage.

### Response Example
```json
{
  "status": "completed"
}
```
```

--------------------------------

### SCIP Presolver Initialization and Setup (C)

Source: https://scipopt.org/doc/html/scip__presol_8c_source

Functions for including and setting up presolvers in SCIP. These functions allow the user to register new presolvers, define their properties like priority and timing, and set various callback functions.

```c
/** include presolver into SCIP */
SCIP_RETCODE SCIPincludePresol(
    SCIP* scip,
    const char* name,
    const char* desc,
    int priority,
    int maxrounds,
    SCIP_PRESOLTIMING timing,
    SCIP_DECL_PRESOLCOPY((*presolcopy)),
    SCIP_DECL_PRESOLFREE((*presolfree)),
    SCIP_DECL_PRESOLINIT((*presolinit)),
    SCIP_DECL_PRESOLEXIT((*presolexit)),
    SCIP_DECL_PRESOLINITPRE((*presolinitpre)),
    SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),
    SCIP_DECL_PRESOLEXEC((*presolexec)),
    SCIP_PRESOLDATA *presoldata
    );

/** set presolver's exitpre method */
SCIP_RETCODE SCIPsetPresolExitpre(
    SCIP* scip,
    SCIP_PRESOL* presol,
    SCIP_DECL_PRESOLEXITPRE((*presolexitpre))
    );

/** set presolver's init method */
SCIP_RETCODE SCIPsetPresolInit(
    SCIP* scip,
    SCIP_PRESOL* presol,
    SCIP_DECL_PRESOLINIT((*presolinit))
    );

/** set presolver's exit method */
SCIP_RETCODE SCIPsetPresolExit(
    SCIP* scip,
    SCIP_PRESOL* presol,
    SCIP_DECL_PRESOLEXIT((*presolexit))
    );

/** set presolver's copy method */
SCIP_RETCODE SCIPsetPresolCopy(
    SCIP* scip,
    SCIP_PRESOL* presol,
    SCIP_DECL_PRESOLCOPY((*presolcopy))
    );

/** set presolver's free method */
SCIP_RETCODE SCIPsetPresolFree(
    SCIP* scip,
    SCIP_PRESOL* presol,
    SCIP_DECL_PRESOLFREE((*presolfree))
    );

/** set presolver's initpre method */
SCIP_RETCODE SCIPsetPresolInitpre(
    SCIP* scip,
    SCIP_PRESOL* presol,
    SCIP_DECL_PRESOLINITPRE((*presolinitpre))
    );
```

--------------------------------

### setupSubscipLpface()

Source: https://scipopt.org/doc/html/heur__lpface_8c

Sets up and solves the subproblem, catching the return code. Handles variable fixing and parameter settings.

```APIDOC
## POST /setupSubscipLpface

### Description
Sets up and solves the subproblem, capturing the return code. This function also configures parameters and handles variable fixing for the subproblem.

### Method
POST

### Endpoint
/setupSubscipLpface

#### Parameters

##### Request Body
- **_scip_** (SCIP*) - Required - SCIP data structure
- **_subscip_** (SCIP*) - Required - Sub-SCIP data structure
- **_heurdata_** (SCIP_HEURDATA*) - Required - Heuristics data
- **_subvars_** (SCIP_VAR**) - Required - Subproblem's variables
- **_vars_** (SCIP_VAR**) - Required - Original problem's variables
- **_fixvars_** (SCIP_VAR**) - Optional - Variables that should be fixed
- **_fixvals_** (SCIP_Real*) - Optional - Corresponding fixing values
- **_nfixvars_** (int) - Optional - Number of variables that should be fixed
- **_nvars_** (int) - Required - Number of original problem's variables

### Request Example
```json
{
  "_scip_": "...",
  "_subscip_": "...",
  "_heurdata_": "...",
  "_subvars_": "...",
  "_vars_": "...",
  "_nvars_": 10
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### SCIP Profile Get Latest Feasible Start (C)

Source: https://scipopt.org/doc/html/heur__listscheduling_8c_source

Calculates the latest possible start time for an activity within a profile, given its earliest start, latest start, duration, and demand. It also indicates if a feasible start time exists.

```c
int SCIPprofileGetLatestFeasibleStart(SCIP_PROFILE *profile, int est, int lst, int duration, int demand, SCIP_Bool *infeasible)
**Definition:** misc.c:7366
```

--------------------------------

### Get Number of Constraints at Problem Start

Source: https://scipopt.org/doc/html/prob_8h_source

Retrieves the number of constraints that existed when the problem solving process initially started.

```APIDOC
## SCIPprobGetStartNConss

### Description
Gets the number of constraints that existed when the problem solving started.

### Method
GET

### Endpoint
N/A (This is a C function/macro)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
SCIP_PROB* prob = ...; // Assume prob is initialized
int startNConss = SCIPprobGetStartNConss(prob);
```

### Response
#### Success Response (200)
- **startNConss** (int) - The number of constraints at the start of problem solving.

#### Response Example
```json
{
  "startNConss": 180
}
```
```

--------------------------------

### C: Setup and Solve Subproblem with LP Face Heuristic

Source: https://scipopt.org/doc/html/heur__lpface_8c_source

This C function `setupSubscipLpface` prepares and potentially solves a subproblem, often for the LP face heuristic. It handles copying plugins, parameter settings, and variables from a source SCIP instance to a target sub-SCIP instance. It can optionally copy constraints and cuts, and configure the sub-SCIP to run in floating-point mode even when exact solving is enabled.

```C
/** setup and solve the subproblem and catch the return code */
static
SCIP_RETCODE setupSubscipLpface(
 SCIP* scip, /**< SCIP data structure */
 SCIP* subscip, /**< sub-SCIP data structure */
 SCIP_HEURDATA* heurdata, /**< heuristics data */
 SCIP_VAR** subvars, /**< subproblem's variables */
 SCIP_VAR** vars, /**< original problem's variables */
 SCIP_VAR** fixvars, /**< variables that should be fixed */
 SCIP_Real* fixvals, /**< corresponding fixing values */
 int nfixvars, /**< number of variables that should be fixed */
 int nvars /**< number of original problem's variables */
)
{
 SCIP_HASHMAP* varmapfw = NULL; /* mapping of SCIP variables to sub-SCIP variables */
 SCIP_Bool success;
 int i;

 assert( subscip != NULL );
 assert( heurdata != NULL );
 assert( vars != NULL );

 /* create the variable hash map */
 SCIP_CALL( SCIPhashmapCreate(&varmapfw, SCIPblkmem(subscip), nvars) );
 success = FALSE;

 if( heurdata->uselprows )
 {
 SCIP_Bool valid;
 char probname[SCIP_MAXSTRLEN];

 /* copy all plugins */
 SCIP_CALL( SCIPcopyPlugins(scip, subscip, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, &valid) );

 /* copy parameter settings */
 SCIP_CALL( SCIPcopyParamSettings(scip, subscip) );

 /* even when solving exactly, sub-SCIP heuristics should be run in floating-point mode, since the exactsol constraint
 * handler is in place to perform a final repair step
 */
 SCIP_CALL( SCIPenableExactSolving(subscip, FALSE) );

 /* get name of the original problem and add the string "_lpfacesub" */
 (void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_lpfacesub", SCIPgetProbName(scip));

 /* create the subproblem */
 SCIP_CALL( SCIPcreateProbBasic(subscip, probname) );
 SCIPsetSubscipDepth(subscip, SCIPgetSubscipDepth(scip) + 1);

 /* copy all variables */
 SCIP_CALL( SCIPcopyVars(scip, subscip, varmapfw, NULL, fixvars, fixvals, nfixvars, TRUE) );
 }
 else
 {
 SCIP_CALL( SCIPcopyConsCompression(scip, subscip, varmapfw, NULL, "lpface", fixvars, fixvals, nfixvars, TRUE, FALSE, FALSE, TRUE, &success) );

 if( heurdata->copycuts )
 {
 /* copies all active cuts from cutpool of sourcescip to linear constraints in targetscip */
 SCIP_CALL( SCIPcopyCuts(scip, subscip, varmapfw, NULL, TRUE, NULL) );
 }
 }
 assert(!SCIPisExact(subscip));

 /* fill subvars array with mapping from original variables and set the objective coefficient to the desired value */
 for( i = 0; i < nvars; i++ )
 {
 subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapfw, vars[i]);

 if( subvars[i] != NULL )
 {
 SCIP_CALL( changeSubvariableObjective(scip, subscip, vars[i], subvars[i], heurdata) );
 }
 }

 /* free hash map */
 SCIPhashmapFree(&varmapfw);

 return SCIP_OKAY;
}

```

--------------------------------

### main()

Source: https://scipopt.org/doc/html/applications_2PBSolver_2src_2main_8c

Main method for starting the PBSolver.

```APIDOC
## main()

### Description
Main method starting the PBSolver.

### Method
int

### Endpoint
N/A (Entry point)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (int)
Returns an integer indicating the exit status.

#### Response Example
int

### Parameters Details
- **_argc_** (int) - number of arguments
- **_argv_** (char **) - string array with arguments
```

--------------------------------

### Get Number of Variables at Problem Start

Source: https://scipopt.org/doc/html/prob_8h_source

Retrieves the number of variables that existed when the problem solving process initially started.

```APIDOC
## SCIPprobGetStartNVars

### Description
Gets the number of variables that existed when the problem solving started.

### Method
GET

### Endpoint
N/A (This is a C function/macro)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
SCIP_PROB* prob = ...; // Assume prob is initialized
int startNVars = SCIPprobGetStartNVars(prob);
```

### Response
#### Success Response (200)
- **startNVars** (int) - The number of variables at the start of problem solving.

#### Response Example
```json
{
  "startNVars": 95
}
```
```

--------------------------------

### End Initial LP Setup in SCIP Pricestore (C)

Source: https://scipopt.org/doc/html/pricestore_8c_source

Informs the pricing storage that the setup of the initial LP is now finished. Asserts that the pricing storage is indeed in the initial LP state and that no variables have been added. Sets the 'initiallp' flag to FALSE.

```c
void SCIPpricestoreEndInitialLP(
    SCIP_PRICESTORE* pricestore /**< pricing storage */
)
{
    assert(pricestore != NULL);
    assert(pricestore->initiallp);
    assert(pricestore->nvars == 0);

    pricestore->initiallp = FALSE;
}
```

--------------------------------

### SCIP Profile Get Earliest Feasible Start (C)

Source: https://scipopt.org/doc/html/heur__listscheduling_8c_source

Calculates the earliest possible start time for an activity within a profile, considering constraints like earliest start, latest start, duration, and demand. It also indicates if a feasible start time exists.

```c
int SCIPprofileGetEarliestFeasibleStart(SCIP_PROFILE *profile, int est, int lst, int duration, int demand, SCIP_Bool *infeasible)
**Definition:** misc.c:7217
```

--------------------------------

### Get Setup Time of SCIP Event Handler

Source: https://scipopt.org/doc/html/event_8c_source

Retrieves the setup time of an event handler. This function returns the time elapsed during the setup phase of the event handler. It requires an event handler.

```c
SCIP_Real SCIPeventhdlrGetSetupTime(SCIP_EVENTHDLR *eventhdlr)
```

--------------------------------

### Ensure Starting Point for NLP Solve (C)

Source: https://scipopt.org/doc/html/nlpi__ipopt_8cpp_source

Verifies and prepares a starting point for an NLP solve. It disables warmstart if primal or dual solutions are unavailable and potentially generates a random starting point if none is provided.

```c
static SCIP_RETCODE ensureStartingPoint(
 SCIP* scip,
 SCIP_NLPIPROBLEM* problem,
 SCIP_Bool& warmstart
)
{
 SCIP_Real lb, ub;
 int n;

 assert(problem != NULL);

 if( warmstart && (!problem->solprimalvalid || !problem->soldualvalid ))
 {
  SCIPdebugMsg(scip, "Disable warmstart as no primal or dual solution available.\n");
  warmstart = false;
 }

 if( problem->solprimalgiven || warmstart )
 {
  assert(problem->solprimalvalid);
  assert(problem->solprimals != NULL);
  assert(!warmstart || !problem->solprimalgiven || problem->soldualgiven);
  assert(!warmstart || problem->soldualcons != NULL);
  assert(!warmstart || problem->soldualvarlb != NULL);
  assert(!warmstart || problem->soldualvarub != NULL);
  SCIPdebugMsg(scip, "Starting solution for %sstart available from %s.\n",
   warmstart ? "warm" : "cold",
   problem->solprimalgiven ? "user" : "previous solve");
  return SCIP_OKAY;
 }

 SCIPdebugMsg(scip, "Starting solution for coldstart not available. Making up something by projecting 0 onto variable bounds and adding a random perturbation.\n");

 return SCIP_OKAY;
}

```

--------------------------------

### Get Presolver Setup Time (C)

Source: https://scipopt.org/doc/html/pub__presol_8h_source

Retrieves the time spent during the setup phase of the presolver. The function takes a SCIP_PRESOL pointer.

```c
SCIP_Real SCIPpresolGetSetupTime(SCIP_PRESOL *presol)
**Definition:** presol.c:722
```

--------------------------------

### Start SCIP LPI Exact Solver

Source: https://scipopt.org/doc/html/lpiexact__qsoex_8c_source

Initializes the QSopt Exact LP solver. This function ensures that necessary constants and internal data structures for rational and extended precision arithmetic are set up before solver operations.

```c
/** calls initializator of LP solver (if this did not already happen); this is mainly needed for defining constants in extended and rational precision */
void SCIPlpiExactStart(
    void
)
{
    if( !__QSexact_setup )
        QSexactStart();
}
```

--------------------------------

### Setup and Solve Subscip in SCIP (C)

Source: https://scipopt.org/doc/html/heur__vbounds_8c_source

This section details the process of setting up and solving a subproblem using SCIP when no solution is found via the LP. It includes checking for sufficient time and memory, creating a sub-SCIP instance, and calling a helper function `setupAndSolveSubscip` to manage the subproblem solving. The sub-SCIP is freed afterward.

```c
/* if no solution has been found --> fix all other variables by subscip if necessary */
if( !lperror && lpstatus != SCIP_LPSOLSTAT_INFEASIBLE && lpstatus != SCIP_LPSOLSTAT_OBJLIMIT )
{
SCIP* subscip;
SCIP_RETCODE retcode;
SCIP_Bool valid;

/* check whether there is enough time and memory left */
SCIP_CALL( SCIPcheckCopyLimits(scip, &valid) );

if( !valid )
goto TERMINATE;

/* create subproblem */
SCIP_CALL( SCIPcreate(&subscip) );

retcode = setupAndSolveSubscip(scip, subscip, heur, vars, nvars, nstallnodes, lowerbound,
&nprevars, &wasfeas, result);

SCIP_CALL( SCIPfree(&subscip) );

SCIP_CALL( retcode );
}
```

--------------------------------

### Get Start Permutation UCB

Source: https://scipopt.org/doc/html/pub__bandit__ucb_8h

Retrieves the initial permutation used by the UCB bandit.

```APIDOC
## SCIPgetStartPermutationUcb

### Description
Gets the start permutation of actions for the UCB bandit.

### Method
int *

### Endpoint
N/A (Function Call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
int * SCIPgetStartPermutationUcb(SCIP_BANDIT *ucb);
```

### Response
#### Success Response (int *)
- **Start Permutation**: A pointer to an array of integers representing the initial action permutation.

#### Response Example
```c
int *permutation = SCIPgetStartPermutationUcb(my_bandit);
// Use the permutation array
```
```

--------------------------------

### Get Separator Setup Time (C)

Source: https://scipopt.org/doc/html/sepa_8c_source

Retrieves the time spent by the separator in setup for subsequent stages. This function returns the cumulative time in seconds used for the separator's setup phase. It requires a pointer to the separator.

```c
SCIP_Real SCIPsepaGetSetupTime(
  SCIP_SEPA* sepa /**< separator */
)
{
  assert(sepa != NULL);

  return SCIPclockGetTime(sepa->setuptime);
}
```

--------------------------------

### SCIP Initialization and Setup in C

Source: https://scipopt.org/doc/html/examples_2LOP_2src_2cmain_8c_source

This C code snippet demonstrates the basic initialization of the SCIP solver. It includes creating a SCIP instance, including default plugins and custom handlers (linear ordering constraint handler and reader), processing shell arguments, and finally freeing the SCIP instance. Error handling is managed via the SCIP_CALL_ERROR macro.

```c
#include <scip/scip.h>
#include <scip/scipdefplugins.h>
#include "cons_lop.h"
#include "reader_lop.h"

#define SCIP_CALL_ERROR(x) do { \
    SCIP_RETCODE _restat_; \
    if( (_restat_ = (x)) != SCIP_OKAY ) \
    { \
        SCIPprintError(_restat_); \
        return -1; \
    } \
} while( FALSE )

int main(int argc, char** argv)
{
    SCIP* scip = NULL;

    /* initialize SCIP */
    SCIP_CALL_ERROR( SCIPcreate(&scip) );

    /* output version information */
    SCIPinfoMessage(scip, NULL, "Solving the linear ordering problem using SCIP.\n");
    SCIPinfoMessage(scip, NULL, "\n");

    /* include default SCIP plugins */
    SCIP_CALL_ERROR( SCIPincludeDefaultPlugins(scip) );

    /* include linear ordering constraint handler */
    SCIP_CALL_ERROR( SCIPincludeConshdlrLOP(scip) );

    /* include linear ordering file reader */
    SCIP_CALL_ERROR( SCIPincludeReaderLOP(scip) );

    /* Process command line arguments */
    SCIP_CALL_ERROR( SCIPprocessShellArguments(scip, argc, argv, "scip.set") );

    /* free SCIP */
    SCIP_CALL_ERROR( SCIPfree(&scip) );

    BMScheckEmptyMemory();

    return 0;
}
```

--------------------------------

### Heuristic Sub-NLP Functions

Source: https://scipopt.org/doc/html/heur__subnlp_8c_source

Functions related to the Sub-NLP heuristic, including getting start candidates, applying the heuristic, and updating start points.

```APIDOC
## SCIPgetStartCandidateHeurSubNlp

### Description
Retrieves a starting candidate solution for the Sub-NLP heuristic.

### Method
SCIPgetStartCandidateHeurSubNlp

### Parameters
- **scip** (SCIP *) - Pointer to the SCIP main structure.
- **heur** (SCIP_HEUR *) - Pointer to the Sub-NLP heuristic structure.

### Response
- **SCIP_SOL *** - Pointer to the starting candidate solution.

## SCIPapplyHeurSubNlp

### Description
Applies the Sub-NLP heuristic to find a solution.

### Method
SCIPapplyHeurSubNlp

### Parameters
- **scip** (SCIP *) - Pointer to the SCIP main structure.
- **heur** (SCIP_HEUR *) - Pointer to the Sub-NLP heuristic structure.
- **result** (SCIP_RESULT *) - Pointer to store the result of the heuristic application.
- **refpoint** (SCIP_SOL *) - A reference point for the heuristic.
- **resultsol** (SCIP_SOL *) - Pointer to store the found solution.

### Response
- **SCIP_RETCODE** - Return code indicating success or failure.

## SCIPupdateStartpointHeurSubNlp

### Description
Updates the starting point for the Sub-NLP heuristic.

### Method
SCIPupdateStartpointHeurSubNlp

### Parameters
- **scip** (SCIP *) - Pointer to the SCIP main structure.
- **heur** (SCIP_HEUR *) - Pointer to the Sub-NLP heuristic structure.
- **solcand** (SCIP_SOL *) - The candidate solution to update from.
- **violation** (SCIP_Real) - The violation amount.

### Response
- **SCIP_RETCODE** - Return code indicating success or failure.

## SCIPincludeHeurSubNlp

### Description
Includes the Sub-NLP heuristic into the SCIP environment.

### Method
SCIPincludeHeurSubNlp

### Parameters
- **scip** (SCIP *) - Pointer to the SCIP main structure.

### Response
- **SCIP_RETCODE** - Return code indicating success or failure.
```

--------------------------------

### setupAndSolveSubscipRapidlearning()

Source: https://scipopt.org/doc/html/sepa__rapidlearning_8c

Sets up and solves a sub-SCIP problem, potentially using rapid learning techniques.

```APIDOC
## POST /sepa/rapidlearning/setupAndSolveSubscip

### Description
This function sets up and solves a sub-SCIP problem. It's designed for rapid learning scenarios within the SCIP framework.

### Method
POST

### Endpoint
/sepa/rapidlearning/setupAndSolveSubscip

### Parameters
#### Path Parameters
None

#### Query Parameters
* **randseed** (int) - Required - Global seed shift used in the sub-SCIP.
* **global** (SCIP_Bool) - Required - Whether rapid learning should run on the global problem.

#### Request Body
* **scip** (SCIP *) - Required - The main SCIP data structure.
* **subscip** (SCIP *) - Required - The sub-SCIP data structure to be solved.
* **sepadata** (SCIP_SEPADATA *) - Required - Separator's private data.
* **result** (SCIP_RESULT *) - Required - Pointer to store the result of the operation.

### Request Example
```json
{
  "scip": "<SCIP_pointer>",
  "subscip": "<SCIP_pointer>",
  "sepadata": "<SCIP_SEPADATA_pointer>",
  "randseed": 12345,
  "global": true,
  "result": "<SCIP_RESULT_pointer>"
}
```

### Response
#### Success Response (200)
- **SCIP_RETCODE** (string) - The return code of the operation (e.g., "SCIP_OKAY").

#### Response Example
```json
{
  "SCIP_RETCODE": "SCIP_OKAY"
}
```
```

--------------------------------

### SCIPmatrixGetColIdxPtr()

Source: https://scipopt.org/doc/html/matrix_8c

Gets a pointer to the start of column indices in the matrix.

```APIDOC
## SCIPmatrixGetColIdxPtr()

### Description
Gets the column-based start pointer of row indices.

### Method
(Not applicable, this is a C function)

### Endpoint
(Not applicable, this is a C function)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
(None)

### Request Example
(Not applicable, this is a C function)

### Response
#### Success Response (200)
(Not applicable, this is a C function)

#### Response Example
(Not applicable, this is a C function)
```

--------------------------------

### Include Presolver with Basic Callbacks (C)

Source: https://scipopt.org/doc/html/scip__presol_8h_source

This function creates a presolver and includes it in SCIP with its fundamental callback. Optional callbacks like init and exit are set to NULL and can be configured later using specific setter functions such as SCIPsetPresolCopy(), SCIPsetPresolFree(), etc. This approach is recommended for better future compatibility.

```c
SCIP_EXPORT
SCIP_RETCODE SCIPincludePresolBasic(
 SCIP* scip, /**< SCIP data structure */
 SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
 const char* name, /**< name of presolver */
 const char* desc, /**< description of presolver */
 int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
 int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
 SCIP_PRESOLTIMING timing /**< timing mask of the presolver */
);
```

--------------------------------

### SCIPmatrixGetColValPtr()

Source: https://scipopt.org/doc/html/matrix_8c

Gets a pointer to the start of column values in the matrix.

```APIDOC
## SCIPmatrixGetColValPtr()

### Description
Gets the column-based start pointer of values.

### Method
(Not applicable, this is a C function)

### Endpoint
(Not applicable, this is a C function)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
(None)

### Request Example
(Not applicable, this is a C function)

### Response
#### Success Response (200)
(Not applicable, this is a C function)

#### Response Example
(Not applicable, this is a C function)
```

--------------------------------

### setupAndSolve()

Source: https://scipopt.org/doc/html/heur__ofins_8c

Sets up and solves a sub-SCIP problem for the OFINS heuristic.

```APIDOC
## setupAndSolve()

### Description
This function sets up and solves a sub-SCIP problem, which is a core part of the OFINS heuristic's strategy.

### Method
`static SCIP_RETCODE setupAndSolve(
    SCIP *scip,
    SCIP *subscip,
    SCIP_HEUR *heur,
    SCIP_HEURDATA *heurdata,
    SCIP_RESULT *result,
    SCIP_Longint nstallnodes,
    SCIP_Bool *chgcoeffs
)`

### Endpoint
N/A (Internal function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
N/A (Internal function)

### Response
#### Success Response (SCIP_RETCODE)
Returns `SCIP_OKAY` on success.

#### Response Example
N/A (Internal function)

### Remarks
This function references numerous SCIP internal functions for problem manipulation, solving, and heuristic data management.
```

--------------------------------

### SCIPrelaxGetSetupTime

Source: https://scipopt.org/doc/html/relax_8c

Gets the setup time of the relaxation handler.

```APIDOC
## SCIP_Real SCIPrelaxGetSetupTime (SCIP_RELAX *relax)

### Description
Gets the setup time of the relaxation handler.

### Method
SCIP_Real

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Response Example
N/A
```

--------------------------------

### Create and Configure Master SCIP Instance

Source: https://scipopt.org/doc/html/miniisc_8c_source

This snippet demonstrates the creation of a master SCIP instance, including the inclusion of default plugins and setting the objective sense to minimize. It also shows how to set problem-specific parameters like the gap limit and stall nodes for solving the master problem approximately.

```c
SCIP_CALL( SCIPcreate(&masterscip) );
SCIP_CALL( SCIPincludeDefaultPlugins(masterscip) );
SCIP_CALL( SCIPcreateProb(masterscip, name, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPsetObjsense(masterscip, SCIP_OBJSENSE_MINIMIZE) );

SCIP_CALL( SCIPaddBoolParam(masterscip,
"miniisc/solvemasterapprox",
"Solve master problem approximately?",
&solvemasterapprox, TRUE, DEFAULT_SOLVEMASTERAPPROX, NULL, NULL) );

SCIP_CALL( SCIPaddRealParam(masterscip,
"miniisc/mastergaplimit",
"gap bound for approximately solving the master problem",
&mastergaplimit, TRUE, DEFAULT_MASTERGAPLIMIT, 0.0, SCIP_REAL_MAX, NULL, NULL) );

SCIP_CALL( SCIPaddLongintParam(masterscip,
"miniisc/masterstallnodes",
"stall nodes for the master problem",
&masterstallnodes, TRUE, DEFAULT_MASTERSTALLNODES, 0L, SCIP_LONGINT_MAX, NULL, NULL) );

SCIP_CALL( SCIPaddBoolParam(masterscip,
"miniisc/reoptimization",
"Use reoptimization to solve master problem?",
&reoptimization, TRUE, DEFAULT_REOPTIMIZATION, NULL, NULL) );
```

--------------------------------

### SCIP Get Start Candidate Heuristic SubNlp Function (C)

Source: https://scipopt.org/doc/html/heur__subnlp_8c

C function to retrieve the current start candidate solution for the 'subnlp' heuristic.

```c
SCIP_SOL * SCIPgetStartCandidateHeurSubNlp (SCIP *scip, SCIP_HEUR *heur)
{
    // Implementation details...
    return NULL;
}
```

--------------------------------

### ScipNLP::get_starting_point

Source: https://scipopt.org/doc/html/nlpi__ipopt_8cpp_source

Provides the starting point for the algorithm, including initial values for primal and dual variables, and constraint duals.

```APIDOC
## ScipNLP::get_starting_point

### Description
This method provides the starting point for the optimization algorithm. It can return initial values for primal variables (x), dual values for variable bounds (z_L, z_U), and dual values for constraints (lambda), based on the boolean flags provided.

### Method
This is a conceptual representation of a method; it does not map directly to a single HTTP request.

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (Conceptual)
Returns `true` if the starting point is successfully retrieved.

#### Response Example
```json
{
  "success": true
}
```
```

--------------------------------

### Setup and Solve Sub-SCIP - C

Source: https://scipopt.org/doc/html/heur__completesol_8c_source

This C function `setupAndSolve` initializes and solves a sub-SCIP instance. It involves creating variable mappings, copying the main SCIP instance, setting up event handlers, and configuring various parameters for the subproblem like limits, presolving, and branching rules.

```c
static
SCIP_RETCODE setupAndSolve(
 SCIP* scip, /**< original SCIP data structure */
 SCIP* subscip, /**< sub-SCIP data structure */
 SCIP_HEUR* heur, /**< heuristic data structure */
 SCIP_HEURDATA* heurdata, /**< heuristic's private data structure */
 SCIP_RESULT* result, /**< result data structure */
 SCIP_Longint nstallnodes, /**< number of stalling nodes for the subproblem */
 SCIP_SOL* partialsol, /**< partial solution */
 SCIP_Bool* tightened /**< array to store whether a variable was already tightened */
)
{
 SCIP_HASHMAP* varmapf;
 SCIP_VAR** vars;
 SCIP_VAR** subvars = NULL;
 SCIP_EVENTHDLR* eventhdlr;
 int nvars;
 int i;

 SCIP_SOL** subsols;
 int nsubsols;

 SCIP_Bool valid;
 SCIP_Bool success;
 SCIP_RETCODE retcode;

 assert(scip != NULL);
 assert(subscip != NULL);
 assert(heur != NULL);
 assert(heurdata != NULL);
 assert(result != NULL);
 assert(partialsol != NULL);

 vars = SCIPgetVars(scip);
 nvars = SCIPgetNVars(scip);

 /* create the variable mapping hash map */
 SCIP_CALL( SCIPhashmapCreate(&varmapf, SCIPblkmem(subscip), nvars) );

 eventhdlr = NULL;
 valid = FALSE;

 /* copy complete SCIP instance */
 SCIP_CALL( SCIPcopyConsCompression(scip, subscip, varmapf, NULL, "completesol", NULL, NULL, 0, FALSE, FALSE, FALSE,
 TRUE, &valid) );
 SCIPdebugMsg(scip, "Copying the SCIP instance returned with valid=%u.\n", valid);

 /* create event handler for LP events */
 SCIP_CALL( SCIPincludeEventhdlrBasic(subscip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC, eventExecCompletesol, NULL) );
 if( eventhdlr == NULL )
 {
 SCIPerrorMessage("event handler for " HEUR_NAME " heuristic not found.\n");
 return SCIP_PLUGINNOTFOUND;
 }

 /* allocate memory to align the SCIP and the sub-SCIP variables */
 SCIP_CALL( SCIPallocBufferArray(scip, &subvars, nvars) );

 /* map all variables */
 for( i = 0; i < nvars; i++ )
 subvars[i] = (SCIP_VAR*) SCIPhashmapGetImage(varmapf, vars[i]);

 /* free hash map */
 SCIPhashmapFree(&varmapf);

 /* create a new problem, which fixes variables with same value in bestsol and LP relaxation */
 SCIP_CALL( createSubproblem(scip, subscip, heurdata, subvars, partialsol, tightened) );
 SCIPdebugMsg(scip, "Completesol subproblem: %d vars, %d cons\n", SCIPgetNVars(subscip), SCIPgetNConss(subscip));

 /* do not abort subproblem on CTRL-C */
 SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );

#ifdef SCIP_DEBUG
 /* for debugging, enable full output */
 SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", SCIP_VERBLEVEL_FULL) );
 SCIP_CALL( SCIPsetIntParam(subscip, "display/freq", -1) );
#else
 /* disable statistic timing inside sub SCIP and output to console */
 SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", (int) SCIP_VERBLEVEL_NONE) );
 SCIP_CALL( SCIPsetBoolParam(subscip, "timing/statistictiming", FALSE) );
#endif

 /* set limits for the subproblem */
 SCIP_CALL( SCIPcopyLimits(scip, subscip) );
 heurdata->nodelimit = heurdata->maxnodes;
 SCIP_CALL( SCIPsetLongintParam(subscip, "limits/stallnodes", nstallnodes) );
 SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", heurdata->maxnodes) );
 SCIP_CALL( SCIPsetIntParam(subscip, "limits/bestsol", heurdata->bestsols) );

 /* limit the number of LP iterations */
 SCIP_CALL( SCIPsetLongintParam(subscip, "lp/iterlim", heurdata->maxlpiter) );
 SCIP_CALL( SCIPsetLongintParam(subscip, "lp/rootiterlim", heurdata->maxlpiter) );

 /* forbid recursive call of heuristics and separators solving sub-SCIPs */
 SCIP_CALL( SCIPsetSubscipsOff(subscip, TRUE) );

 /* disable cutting plane separation */
 SCIP_CALL( SCIPsetSeparating(subscip, SCIP_PARAMSETTING_OFF, TRUE) );

 /* disable expensive presolving */
 SCIP_CALL( SCIPsetPresolving(subscip, SCIP_PARAMSETTING_FAST, TRUE) );

 /* use best estimate node selection */
 if( SCIPfindNodesel(subscip, "estimate") != NULL && !SCIPisParamFixed(subscip, "nodeselection/estimate/stdpriority") )
 {
 SCIP_CALL( SCIPsetIntParam(subscip, "nodeselection/estimate/stdpriority", INT_MAX/4) );
 }

 /* use inference branching */
 if( SCIPfindBranchrule(subscip, "inference") != NULL && !SCIPisParamFixed(subscip, "branching/inference/priority") )
 {
 SCIP_CALL( SCIPsetIntParam(subscip, "branching/inference/priority", INT_MAX/4) );
 }

 /* disable conflict analysis */
 if( !SCIPisParamFixed(subscip, "conflict/enable") )
 {
 return retcode; /* This line seems incomplete from the provided text */
 }

 return retcode; /* This line also seems incomplete */
}
```

--------------------------------

### Get SCIP Compression Setup Time

Source: https://scipopt.org/doc/html/compr_8c_source

Retrieves the total time spent in setting up a tree compression. This includes time spent in initialization and other setup phases.

```c
SCIP_Real SCIPcomprGetSetupTime(SCIP_COMPR *compr)
**Definition:** compr.c:540
```
Tokens:
Raw