  # SCIP

Solving Constraint Integer Programs

Sorting Algorithms

## Detailed Description

public methods for in place sorting of arrays

Below are the public methods for in place sorting of up to six arrays of joint data.

## Functions

SCIP_DECL_SORTPTRCOMP (SCIPsortCompInt)

void SCIPsort (int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)

void SCIPsortInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)

void SCIPsortPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrRealReal (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortReal (SCIP_Real *realarray, int len)

void SCIPsortRealPtr (SCIP_Real *realarray, void **ptrarray, int len)

void SCIPsortRealInt (SCIP_Real *realarray, int *intarray, int len)

void SCIPsortRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int len)

void SCIPsortRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int len)

void SCIPsortRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int len)

void SCIPsortRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int len)

void SCIPsortRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int len)

void SCIPsortRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)

void SCIPsortRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)

void SCIPsortRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int len)

void SCIPsortRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int len)

void SCIPsortRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int len)

void SCIPsortRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int len)

void SCIPsortRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int len)

void SCIPsortRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int len)

void SCIPsortInt (int *intarray, int len)

void SCIPsortIntInt (int *intarray1, int *intarray2, int len)

void SCIPsortIntPtr (int *intarray, void **ptrarray, int len)

void SCIPsortIntReal (int *intarray, SCIP_Real *realarray, int len)

void SCIPsortIntIntInt (int *intarray1, int *intarray2, int *intarray3, int len)

void SCIPsortIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int len)

void SCIPsortIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, int len)

void SCIPsortIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int len)

void SCIPsortIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int len)

void SCIPsortIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, int len)

void SCIPsortIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int len)

void SCIPsortIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int len)

void SCIPsortIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int len)

void SCIPsortLong (SCIP_Longint *longarray, int len)

void SCIPsortLongPtr (SCIP_Longint *longarray, void **ptrarray, int len)

void SCIPsortLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int len)

void SCIPsortLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int len)

void SCIPsortLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int len)

void SCIPsortLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int len)

void SCIPsortLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)

void SCIPsortLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)

void SCIPsortLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int len)

void SCIPsortPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int len)

void SCIPsortDown (int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)

void SCIPsortDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)

void SCIPsortDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownReal (SCIP_Real *realarray, int len)

void SCIPsortDownRealPtr (SCIP_Real *realarray, void **ptrarray, int len)

void SCIPsortDownRealInt (SCIP_Real *realarray, int *intarray, int len)

void SCIPsortDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int len)

void SCIPsortDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int len)

void SCIPsortDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int len)

void SCIPsortDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int len)

void SCIPsortDownRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, int len)

void SCIPsortDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int len)

void SCIPsortDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, int len)

void SCIPsortDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)

void SCIPsortDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)

void SCIPsortDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int len)

void SCIPsortDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int len)

void SCIPsortDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int len)

void SCIPsortDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int len)

void SCIPsortDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int len)

void SCIPsortDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int len)

void SCIPsortDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int len)

void SCIPsortDownInt (int *intarray, int len)

void SCIPsortDownIntInt (int *intarray1, int *intarray2, int len)

void SCIPsortDownIntPtr (int *intarray, void **ptrarray, int len)

void SCIPsortDownIntReal (int *intarray, SCIP_Real *realarray, int len)

void SCIPsortDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, int len)

void SCIPsortDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int len)

void SCIPsortDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int len)

void SCIPsortDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int len)

void SCIPsortDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int len)

void SCIPsortDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int len)

void SCIPsortDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int len)

void SCIPsortDownLong (SCIP_Longint *longarray, int len)

void SCIPsortDownLongPtr (SCIP_Longint *longarray, void **ptrarray, int len)

void SCIPsortDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int len)

void SCIPsortDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int len)

void SCIPsortDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int len)

void SCIPsortDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int len)

void SCIPsortDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)

void SCIPsortDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)

void SCIPsortDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int len)

void SCIPsortDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

void SCIPsortDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int len)

void SCIPsortedvecInsertInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int keyval, int *len, int *pos)

void SCIPsortedvecInsertPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int *len, int *pos)

void SCIPsortedvecInsertPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int *len, int *pos)

void SCIPsortedvecInsertPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int *len, int *pos)

void SCIPsortedvecInsertPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Bool field1val, int *len, int *pos)

void SCIPsortedvecInsertPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, SCIP_Bool field2val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int field4val, int *len, int *pos)

void SCIPsortedvecInsertRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real keyval, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Bool field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertRealPtr (SCIP_Real *realarray, void **ptrarray, SCIP_Real keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertReal (SCIP_Real *realarray, SCIP_Real keyval, int *len, int *pos)

void SCIPsortedvecInsertRealInt (SCIP_Real *realarray, int *intarray, SCIP_Real keyval, int field1val, int *len, int *pos)

void SCIPsortedvecInsertRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)

void SCIPsortedvecInsertRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real keyval, int field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real keyval, void *field1val, void *field2val, int intval, int *len, int *pos)

void SCIPsortedvecInsertRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real keyval, void *field1val, void *field2val, int intval1, int intval2, int *len, int *pos)

void SCIPsortedvecInsertRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Longint field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, void *field3val, int *len, int *pos)

void SCIPsortedvecInsertRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, void *field4val, int *len, int *pos)

void SCIPsortedvecInsertRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, void *field5val, int *len, int *pos)

void SCIPsortedvecInsertInt (int *intarray, int keyval, int *len, int *pos)

void SCIPsortedvecInsertIntInt (int *intarray1, int *intarray2, int keyval, int field1val, int *len, int *pos)

void SCIPsortedvecInsertIntPtr (int *intarray, void **ptrarray, int keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertIntReal (int *intarray, SCIP_Real *realarray, int keyval, SCIP_Real field1val, int *len, int *pos)

void SCIPsortedvecInsertIntIntInt (int *intarray1, int *intarray2, int *intarray3, int keyval, int field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)

void SCIPsortedvecInsertIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, int keyval, SCIP_Real field1val, SCIP_Longint field2val, int *len, int *pos)

void SCIPsortedvecInsertIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int keyval, int field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int keyval, int field1val, SCIP_Real field2val, int *len, int *pos)

void SCIPsortedvecInsertIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, int keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)

void SCIPsortedvecInsertIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int keyval, int field1val, int field2val, void *field3val, int *len, int *pos)

void SCIPsortedvecInsertIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int keyval, int field1val, int field2val, SCIP_Real field3val, int *len, int *pos)

void SCIPsortedvecInsertIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int keyval, void *field1val, int field2val, SCIP_Real field3val, int *len, int *pos)

void SCIPsortedvecInsertLong (SCIP_Longint *longarray, SCIP_Longint keyval, int *len, int *pos)

void SCIPsortedvecInsertLongPtr (SCIP_Longint *longarray, void **ptrarray, SCIP_Longint keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Longint keyval, void *field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, SCIP_Bool field4val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, int field4val, SCIP_Bool field5val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int field4val, int *len, int *pos)

void SCIPsortedvecInsertLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, SCIP_Bool field3val, int field4val, int *len, int *pos)

void SCIPsortedvecInsertPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, SCIP_Bool field3val, SCIP_Bool field4val, int *len, int *pos)

void SCIPsortedvecInsertIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int keyval, void *field1val, int field2val, int field3val, SCIP_Bool field4val, SCIP_Bool field5val, int *len, int *pos)

void SCIPsortedvecInsertDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int keyval, int *len, int *pos)

void SCIPsortedvecInsertDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Bool field1val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, SCIP_Bool field2val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int field4val, int *len, int *pos)

void SCIPsortedvecInsertDownReal (SCIP_Real *realarray, SCIP_Real keyval, int *len, int *pos)

void SCIPsortedvecInsertDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Bool field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealPtr (SCIP_Real *realarray, void **ptrarray, SCIP_Real keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, SCIP_Real keyval, void *field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealInt (SCIP_Real *realarray, int *intarray, SCIP_Real keyval, int field1val, int *len, int *pos)

void SCIPsortedvecInsertDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real keyval, int field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealInt (SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Real keyval, SCIP_Real field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real keyval, int field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, SCIP_Real keyval, SCIP_Real field1val, void *field2val, void *field3val, int *len, int *pos)

void SCIPsortedvecInsertDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real keyval, void *field1val, void *field2val, int intval, int *len, int *pos)

void SCIPsortedvecInsertDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real keyval, void *field1val, void *field2val, int intval1, int intval2, int *len, int *pos)

void SCIPsortedvecInsertDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Longint field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, void *field3val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, void *field4val, int *len, int *pos)

void SCIPsortedvecInsertDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, void *field5val, int *len, int *pos)

void SCIPsortedvecInsertDownInt (int *intarray, int keyval, int *len, int *pos)

void SCIPsortedvecInsertDownIntInt (int *intarray1, int *intarray2, int keyval, int field1val, int *len, int *pos)

void SCIPsortedvecInsertDownIntReal (int *intarray, SCIP_Real *realarray, int keyval, SCIP_Real field1val, int *len, int *pos)

void SCIPsortedvecInsertDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, int keyval, int field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)

void SCIPsortedvecInsertDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int keyval, int field1val, void *field2val, int *len, int *pos)

void SCIPsortedvecInsertDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int keyval, int field1val, SCIP_Real field2val, int *len, int *pos)

void SCIPsortedvecInsertDownIntPtr (int *intarray, void **ptrarray, int keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int keyval, int field1val, int field2val, void *field3val, int *len, int *pos)

void SCIPsortedvecInsertDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int keyval, int field1val, int field2val, SCIP_Real field3val, int *len, int *pos)

void SCIPsortedvecInsertDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int keyval, void *field1val, int field2val, SCIP_Real field3val, int *len, int *pos)

void SCIPsortedvecInsertDownLong (SCIP_Longint *longarray, SCIP_Longint keyval, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtr (SCIP_Longint *longarray, void **ptrarray, SCIP_Longint keyval, void *field1val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Longint keyval, void *field1val, int field2val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, SCIP_Bool field4val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, int field4val, SCIP_Bool field5val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int field4val, int *len, int *pos)

void SCIPsortedvecInsertDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, SCIP_Bool field3val, int field4val, int *len, int *pos)

void SCIPsortedvecInsertDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, SCIP_Bool field3val, SCIP_Bool field4val, int *len, int *pos)

void SCIPsortedvecInsertDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int keyval, void *field1val, int field2val, int field3val, SCIP_Bool field4val, SCIP_Bool field5val, int *len, int *pos)

void SCIPsortedvecDelPosInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int pos, int *len)

void SCIPsortedvecDelPosPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosRealPtr (SCIP_Real *realarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosReal (SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosRealInt (SCIP_Real *realarray, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosInt (int *intarray, int pos, int *len)

void SCIPsortedvecDelPosIntInt (int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosIntReal (int *intarray, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosIntIntInt (int *intarray1, int *intarray2, int *intarray3, int pos, int *len)

void SCIPsortedvecDelPosIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosIntPtr (int *intarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosLong (SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtr (SCIP_Longint *longarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int pos, int *len)

void SCIPsortedvecDelPosDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int pos, int *len)

void SCIPsortedvecDelPosDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownReal (SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealPtr (SCIP_Real *realarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealInt (SCIP_Real *realarray, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, int pos, int *len)

void SCIPsortedvecDelPosDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int pos, int *len)

void SCIPsortedvecDelPosDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownInt (int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntInt (int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosDownIntReal (int *intarray, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, int pos, int *len)

void SCIPsortedvecDelPosDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntPtr (int *intarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int pos, int *len)

void SCIPsortedvecDelPosDownLong (SCIP_Longint *longarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtr (SCIP_Longint *longarray, void **ptrarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)

void SCIPsortedvecDelPosDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int pos, int *len)

void SCIPsortedvecDelPosDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)

void SCIPsortedvecDelPosDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int pos, int *len)

SCIP_Bool SCIPsortedvecFindInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindReal (SCIP_Real *realarray, SCIP_Real val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindInt (int *intarray, int val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindLong (SCIP_Longint *longarray, SCIP_Longint val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindDownReal (SCIP_Real *realarray, SCIP_Real val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindDownInt (int *intarray, int val, int len, int *pos)

SCIP_Bool SCIPsortedvecFindDownLong (SCIP_Longint *longarray, SCIP_Longint val, int len, int *pos)

## ◆ SCIP_DECL_SORTPTRCOMP()

 SCIP_DECL_SORTPTRCOMP ( SCIPsortCompInt )

default comparer for integers

Definition at line 5297 of file misc.c.

## ◆ SCIPsort()

 void SCIPsort ( int * perm, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int len )

sort an indexed element set in non-decreasing order, resulting in a permutation index array

Parameters
 perm pointer to store the resulting permutation dataptr pointer to data field that is given to the external compare method len number of elements to be sorted (valid index range)

Definition at line 5317 of file misc.c.

References NULL, and SCIPsortInd().

## ◆ SCIPsortInd()

 void SCIPsortInd ( int * indarray, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int len )

sort an index array in non-decreasing order

Parameters
 indarray pointer to the index array to be sorted dataptr pointer to data field that is given to the external compare method len length of array

Referenced by extractCapacityRows(), extractFlowRows(), and SCIPsort().

## ◆ SCIPsortPtr()

 void SCIPsortPtr ( void ** ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

## ◆ SCIPsortPtrPtr()

 void SCIPsortPtrPtr ( void ** ptrarray1, void ** ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrReal()

 void SCIPsortPtrReal ( void ** ptrarray, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrInt()

 void SCIPsortPtrInt ( void ** ptrarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted intarray int array to be permuted in the same way len length of arrays

Referenced by exprgraphFindParentByOperator(), makeCoverMinimal(), and selectBranchVar().

## ◆ SCIPsortPtrBool()

 void SCIPsortPtrBool ( void ** ptrarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted boolarray SCIP_Bool array to be permuted in the same way len length of arrays

Referenced by checkSolution(), findAggregation(), SCIPcliquelistDel(), and sortAndMergeClique().

## ◆ SCIPsortPtrIntInt()

 void SCIPsortPtrIntInt ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrRealInt()

 void SCIPsortPtrRealInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

Referenced by colSortLP(), colSortNonLP(), and exprgraphFindParentByOperator().

## ◆ SCIPsortPtrRealRealInt()

 void SCIPsortPtrRealRealInt ( void ** ptrarray, SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted realarray1 SCIP_Real array to be permuted in the same way realarray2 SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrRealBool()

 void SCIPsortPtrRealBool ( void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

Referenced by correctLocksAndCaptures(), and getLinVarsAndAndRess().

## ◆ SCIPsortPtrRealReal()

 void SCIPsortPtrRealReal ( void ** ptrarray, SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted realarray1 first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrPtrInt()

 void SCIPsortPtrPtrInt ( void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

Referenced by computeAndConstraintInfos(), and exprgraphFindParentByOperator().

## ◆ SCIPsortPtrPtrReal()

 void SCIPsortPtrPtrReal ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

Referenced by consdataSortLinearVars(), exprgraphFindParentByOperator(), and printColumnSection().

## ◆ SCIPsortPtrPtrIntInt()

 void SCIPsortPtrPtrIntInt ( void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

Referenced by SCIPinitHeurOptcumulative().

## ◆ SCIPsortPtrRealIntInt()

 void SCIPsortPtrRealIntInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrPtrRealInt()

 void SCIPsortPtrPtrRealInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

Referenced by exprgraphFindParentByOperator().

## ◆ SCIPsortPtrPtrRealBool()

 void SCIPsortPtrPtrRealBool ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

Referenced by consdataCreate().

## ◆ SCIPsortPtrPtrLongInt()

 void SCIPsortPtrPtrLongInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortPtrPtrLongIntInt()

 void SCIPsortPtrPtrLongIntInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortReal()

 void SCIPsortReal ( SCIP_Real * realarray, int len )

sort an array of Reals in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted len length of arrays

## ◆ SCIPsortRealPtr()

 void SCIPsortRealPtr ( SCIP_Real * realarray, void ** ptrarray, int len )

sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by SCIP_DECL_HEUREXEC(), SCIPcreateConsSOS1(), SCIPcreateConsSOS2(), separateGLS(), and separateHeur().

## ◆ SCIPsortRealInt()

 void SCIPsortRealInt ( SCIP_Real * realarray, int * intarray, int len )

sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealIntInt()

 void SCIPsortRealIntInt ( SCIP_Real * realarray, int * intarray1, int * intarray2, int len )

sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted intarray1 int array to be permuted in the same way intarray2 int array to be permuted in the same way len length of arrays

Referenced by computeSteinerTreeVnoi().

## ◆ SCIPsortRealBoolPtr()

 void SCIPsortRealBoolPtr ( SCIP_Real * realarray, SCIP_Bool * boolarray, void ** ptrarray, int len )

sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealIntLong()

 void SCIPsortRealIntLong ( SCIP_Real * realarray, int * intarray, SCIP_Longint * longarray, int len )

sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealIntPtr()

 void SCIPsortRealIntPtr ( SCIP_Real * realarray, int * intarray, void ** ptrarray, int len )

sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by checkSystemGF2().

## ◆ SCIPsortRealRealPtr()

 void SCIPsortRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray, int len )

sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array to be sorted realarray2 second SCIP_Real array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealPtrPtrInt()

 void SCIPsortRealPtrPtrInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray, int len )

sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray1 pointer array to be permuted in the same way ptrarray2 pointer array to be permuted in the same way intarray int array to be sorted len length of arrays

Referenced by optimize(), and SCIPcreateConsCardinality().

## ◆ SCIPsortRealPtrPtrIntInt()

 void SCIPsortRealPtrPtrIntInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, int len )

sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray1 pointer array to be permuted in the same way ptrarray2 pointer array to be permuted in the same way intarray1 int array to be sorted intarray2 int array to be sorted len length of arrays

Referenced by checkRedundancy(), enfopsCons(), and solveSubproblem().

## ◆ SCIPsortRealLongRealInt()

 void SCIPsortRealLongRealInt ( SCIP_Real * realarray1, SCIP_Longint * longarray, SCIP_Real * realarray3, int * intarray, int len )

sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array to be sorted longarray SCIP_Longint array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealRealIntInt()

 void SCIPsortRealRealIntInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray1, int * intarray2, int len )

sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way intarray1 int array to be permuted in the same way intarray2 int array to be permuted in the same way len length of arrays

Referenced by singletonColumnStuffing().

## ◆ SCIPsortRealRealRealInt()

 void SCIPsortRealRealRealInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, int * intarray, int len )

sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealRealRealPtr()

 void SCIPsortRealRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, void ** ptrarray, int len )

sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealRealRealBoolPtr()

 void SCIPsortRealRealRealBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray, void ** ptrarray, int len )

sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortRealRealRealBoolBoolPtr()

 void SCIPsortRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, int len )

sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray1 SCIP_Bool array to be permuted in the same way boolarray2 SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortInt()

 void SCIPsortInt ( int * intarray, int len )

sort array of ints in non-decreasing order

Parameters
 intarray int array to be sorted len length of arrays

## ◆ SCIPsortIntInt()

 void SCIPsortIntInt ( int * intarray1, int * intarray2, int len )

sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntPtr()

 void SCIPsortIntPtr ( int * intarray, void ** ptrarray, int len )

sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray int array to be sorted ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by applyHeur(), consdataSort(), and sortComponents().

## ◆ SCIPsortIntReal()

 void SCIPsortIntReal ( int * intarray, SCIP_Real * realarray, int len )

sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray int array to be sorted realarray real array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntIntInt()

 void SCIPsortIntIntInt ( int * intarray1, int * intarray2, int * intarray3, int len )

sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way intarray3 third int array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntIntLong()

 void SCIPsortIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, int len )

sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntRealLong()

 void SCIPsortIntRealLong ( int * intarray, SCIP_Real * realarray, SCIP_Longint * longarray, int len )

sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order

Parameters
 intarray int array to be sorted realarray real array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntIntPtr()

 void SCIPsortIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, int len )

sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntIntReal()

 void SCIPsortIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, int len )

sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

Referenced by detectParallelCols(), SCIPmatrixGetParallelCols(), and SCIPmatrixGetParallelRows().

## ◆ SCIPsortIntPtrReal()

 void SCIPsortIntPtrReal ( int * intarray, void ** ptrarray, SCIP_Real * realarray, int len )

sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order

Parameters
 intarray int array to be sorted ptrarray pointer array to be permuted in the same way realarray real array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntIntIntPtr()

 void SCIPsortIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, int len )

sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntIntIntReal()

 void SCIPsortIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, int len )

sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntPtrIntReal()

 void SCIPsortIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, int len )

sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

Referenced by rowSortLP(), and rowSortNonLP().

## ◆ SCIPsortLong()

 void SCIPsortLong ( SCIP_Longint * longarray, int len )

sort an array of Longints in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted len length of arrays

## ◆ SCIPsortLongPtr()

 void SCIPsortLongPtr ( SCIP_Longint * longarray, void ** ptrarray, int len )

sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortLongPtrInt()

 void SCIPsortLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, int len )

sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortLongPtrRealBool()

 void SCIPsortLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, int len )

sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortLongPtrRealRealBool()

 void SCIPsortLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, int len )

sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

Referenced by detectImpliedBounds().

## ◆ SCIPsortLongPtrRealRealIntBool()

 void SCIPsortLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, int len )

sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortLongPtrPtrInt()

 void SCIPsortLongPtrPtrInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray, int len )

sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortLongPtrPtrIntInt()

 void SCIPsortLongPtrPtrIntInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, int len )

sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortLongPtrPtrBoolInt()

 void SCIPsortLongPtrPtrBoolInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, SCIP_Bool * boolarray, int * intarray, int len )

sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way intarray int array to be sorted len length of arrays

## ◆ SCIPsortPtrIntIntBoolBool()

 void SCIPsortPtrIntIntBoolBool ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortIntPtrIntIntBoolBool()

 void SCIPsortIntPtrIntIntBoolBool ( int * intarray1, void ** ptrarray, int * intarray2, int * intarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, int len )

sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDown()

 void SCIPsortDown ( int * perm, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int len )

sort an indexed element set in non-increasing order, resulting in a permutation index array

Parameters
 perm pointer to store the resulting permutation dataptr pointer to data field that is given to the external compare method len number of elements to be sorted (valid index range)

Definition at line 5836 of file misc.c.

References NULL, and SCIPsortDownInd().

## ◆ SCIPsortDownInd()

 void SCIPsortDownInd ( int * indarray, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int len )

sort an index array in non-increasing order

Parameters
 indarray pointer to the index array to be sorted dataptr pointer to data field that is given to the external compare method len length of array

Referenced by cutTightenCoefs(), cutTightenCoefsQuad(), and SCIPsortDown().

## ◆ SCIPsortDownPtr()

 void SCIPsortDownPtr ( void ** ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of an array of pointers in non-increasing order

Parameters
 ptrarray pointer array to be sorted len length of array

## ◆ SCIPsortDownPtrPtr()

 void SCIPsortDownPtrPtr ( void ** ptrarray1, void ** ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way len length of arrays

Referenced by SCIP_DECL_DIALOGEXEC().

## ◆ SCIPsortDownPtrReal()

 void SCIPsortDownPtrReal ( void ** ptrarray, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrInt()

 void SCIPsortDownPtrInt ( void ** ptrarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted intarray int array to be permuted in the same way len length of arrays

Referenced by getLiftingSequence(), and getLiftingSequenceGUB().

## ◆ SCIPsortDownPtrBool()

 void SCIPsortDownPtrBool ( void ** ptrarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrIntInt()

 void SCIPsortDownPtrIntInt ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrRealInt()

 void SCIPsortDownPtrRealInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrRealBool()

 void SCIPsortDownPtrRealBool ( void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrInt()

 void SCIPsortDownPtrPtrInt ( void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrReal()

 void SCIPsortDownPtrPtrReal ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrIntInt()

 void SCIPsortDownPtrPtrIntInt ( void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrRealIntInt()

 void SCIPsortDownPtrRealIntInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted realarray SCIP_Real array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrRealInt()

 void SCIPsortDownPtrPtrRealInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrRealBool()

 void SCIPsortDownPtrPtrRealBool ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrLongInt()

 void SCIPsortDownPtrPtrLongInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownPtrPtrLongIntInt()

 void SCIPsortDownPtrPtrLongIntInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array to be sorted ptrarray2 second pointer array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownReal()

 void SCIPsortDownReal ( SCIP_Real * realarray, int len )

sort an array of Reals in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted len length of arrays

Referenced by computeLiftingData().

## ◆ SCIPsortDownRealPtr()

 void SCIPsortDownRealPtr ( SCIP_Real * realarray, void ** ptrarray, int len )

sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by filterPoints(), SCIP_DECL_SEPAEXECLP(), separateGLS(), separateHeur(), and sortVariables().

## ◆ SCIPsortDownRealInt()

 void SCIPsortDownRealInt ( SCIP_Real * realarray, int * intarray, int len )

sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted intarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealIntInt()

 void SCIPsortDownRealIntInt ( SCIP_Real * realarray, int * intarray1, int * intarray2, int len )

sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted intarray1 int array to be sorted intarray2 int array to be sorted len length of arrays

Referenced by SCIPverifyCircularPatternHeuristic().

## ◆ SCIPsortDownRealBoolPtr()

 void SCIPsortDownRealBoolPtr ( SCIP_Real * realarray, SCIP_Bool * boolarray, void ** ptrarray, int len )

sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealIntLong()

 void SCIPsortDownRealIntLong ( SCIP_Real * realarray, int * intarray, SCIP_Longint * longarray, int len )

sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way len length of arrays

Referenced by SCIPsolveKnapsackExactly().

## ◆ SCIPsortDownRealIntPtr()

 void SCIPsortDownRealIntPtr ( SCIP_Real * realarray, int * intarray, void ** ptrarray, int len )

sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by applyNlobbt().

## ◆ SCIPsortDownRealRealInt()

 void SCIPsortDownRealRealInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray, int len )

sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray1 first SCIP_Real array to be sorted realarray2 second SCIP_Real array to be permuted in the same way intarray integer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealRealPtr()

 void SCIPsortDownRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray, int len )

sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

Parameters
 realarray1 first SCIP_Real array to be sorted realarray2 second SCIP_Real array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by computeRanks(), and rowprepCleanupSortTerms().

## ◆ SCIPsortDownRealRealPtrPtr()

 void SCIPsortDownRealRealPtrPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray1, void ** ptrarray2, int len )

sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

Parameters
 realarray1 first SCIP_Real array to be sorted realarray2 second SCIP_Real array to be permuted in the same way ptrarray1 pointer array to be permuted in the same way ptrarray2 pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealPtrPtrInt()

 void SCIPsortDownRealPtrPtrInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray, int len )

sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray1 pointer array to be permuted in the same way ptrarray2 pointer array to be permuted in the same way intarray int array to be sorted len length of arrays

## ◆ SCIPsortDownRealPtrPtrIntInt()

 void SCIPsortDownRealPtrPtrIntInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, int len )

sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray1 pointer array to be permuted in the same way ptrarray2 pointer array to be permuted in the same way intarray1 int array to be sorted intarray2 int array to be sorted len length of arrays

## ◆ SCIPsortDownRealLongRealInt()

 void SCIPsortDownRealLongRealInt ( SCIP_Real * realarray1, SCIP_Longint * longarray, SCIP_Real * realarray3, int * intarray, int len )

sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array to be sorted longarray SCIP_Longint array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealRealIntInt()

 void SCIPsortDownRealRealIntInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray1, int * intarray2, int len )

sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way intarray1 int array to be permuted in the same way intarray2 int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealRealRealInt()

 void SCIPsortDownRealRealRealInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, int * intarray, int len )

sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealRealRealPtr()

 void SCIPsortDownRealRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, void ** ptrarray, int len )

sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealPtrPtr()

 void SCIPsortDownRealPtrPtr ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int len )

sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted ptrarray1 pointer array to be permuted in the same way ptrarray2 pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownRealRealRealBoolPtr()

 void SCIPsortDownRealRealRealBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray, void ** ptrarray, int len )

sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by SCIP_DECL_HEUREXEC().

## ◆ SCIPsortDownRealRealRealBoolBoolPtr()

 void SCIPsortDownRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, int len )

sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray1 SCIP_Bool array to be permuted in the same way boolarray2 SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownInt()

 void SCIPsortDownInt ( int * intarray, int len )

sort array of ints in non-increasing order

Parameters
 intarray int array to be sorted len length of arrays

## ◆ SCIPsortDownIntInt()

 void SCIPsortDownIntInt ( int * intarray1, int * intarray2, int len )

sort of two joint arrays of ints/ints, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntPtr()

 void SCIPsortDownIntPtr ( int * intarray, void ** ptrarray, int len )

sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order

Parameters
 intarray int array to be sorted ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntReal()

 void SCIPsortDownIntReal ( int * intarray, SCIP_Real * realarray, int len )

sort of two joint arrays of ints/reals, sorted by first array in non-increasing order

Parameters
 intarray int array to be sorted realarray real array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntIntInt()

 void SCIPsortDownIntIntInt ( int * intarray1, int * intarray2, int * intarray3, int len )

sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way intarray3 third int array to be permuted in the same way len length of arrays

Referenced by analyzeEnergyRequirement().

## ◆ SCIPsortDownIntIntLong()

 void SCIPsortDownIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, int len )

sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntIntPtr()

 void SCIPsortDownIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, int len )

sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntIntReal()

 void SCIPsortDownIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, int len )

sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntIntIntPtr()

 void SCIPsortDownIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, int len )

sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way ptrarray pointer array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntIntIntReal()

 void SCIPsortDownIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, int len )

sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntPtrIntReal()

 void SCIPsortDownIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, int len )

sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLong()

 void SCIPsortDownLong ( SCIP_Longint * longarray, int len )

sort an array of Longints in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted len length of arrays

## ◆ SCIPsortDownLongPtr()

 void SCIPsortDownLongPtr ( SCIP_Longint * longarray, void ** ptrarray, int len )

sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way len length of arrays

Referenced by greedyCliqueAlgorithm().

## ◆ SCIPsortDownLongPtrInt()

 void SCIPsortDownLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, int len )

sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLongPtrRealBool()

 void SCIPsortDownLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, int len )

sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLongPtrRealRealBool()

 void SCIPsortDownLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, int len )

sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLongPtrRealRealIntBool()

 void SCIPsortDownLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, int len )

sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLongPtrPtrInt()

 void SCIPsortDownLongPtrPtrInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray, int len )

sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLongPtrPtrIntInt()

 void SCIPsortDownLongPtrPtrIntInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, int len )

sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownLongPtrPtrBoolInt()

 void SCIPsortDownLongPtrPtrBoolInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, SCIP_Bool * boolarray, int * intarray, int len )

sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way intarray int array to be sorted len length of arrays

## ◆ SCIPsortDownPtrIntIntBoolBool()

 void SCIPsortDownPtrIntIntBoolBool ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int len )

sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortDownIntPtrIntIntBoolBool()

 void SCIPsortDownIntPtrIntIntBoolBool ( int * intarray1, void ** ptrarray, int * intarray2, int * intarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, int len )

sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way len length of arrays

## ◆ SCIPsortedvecInsertInd()

 void SCIPsortedvecInsertInd ( int * indarray, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int keyval, int * len, int * pos )

insert a new element into an index array in non-decreasing order

Parameters
 indarray pointer to the index array where an element is to be inserted dataptr pointer to data field that is given to the external compare method keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtr()

 void SCIPsortedvecInsertPtr ( void ** ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int * len, int * pos )

insert a new element into an array of pointers in non-decreasing order

Parameters
 ptrarray pointer to the pointer array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtr()

 void SCIPsortedvecInsertPtrPtr ( void ** ptrarray1, void ** ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrReal()

 void SCIPsortedvecInsertPtrReal ( void ** ptrarray, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrInt()

 void SCIPsortedvecInsertPtrInt ( void ** ptrarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrBool()

 void SCIPsortedvecInsertPtrBool ( void ** ptrarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Bool field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrIntInt()

 void SCIPsortedvecInsertPtrIntInt ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrRealInt()

 void SCIPsortedvecInsertPtrRealInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrRealRealInt()

 void SCIPsortedvecInsertPtrRealRealInt ( void ** ptrarray, SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray1 SCIP_Real array where an element is to be inserted realarray2 SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrRealBool()

 void SCIPsortedvecInsertPtrRealBool ( void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, SCIP_Bool field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrInt()

 void SCIPsortedvecInsertPtrPtrInt ( void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrReal()

 void SCIPsortedvecInsertPtrPtrReal ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Real field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrIntInt()

 void SCIPsortedvecInsertPtrPtrIntInt ( void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, int field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrRealIntInt()

 void SCIPsortedvecInsertPtrRealIntInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, int field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrRealInt()

 void SCIPsortedvecInsertPtrPtrRealInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrRealBool()

 void SCIPsortedvecInsertPtrPtrRealBool ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Real field2val, SCIP_Bool field3val, int * len, int * pos )

insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrLongInt()

 void SCIPsortedvecInsertPtrPtrLongInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Longint field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted intarray int array to be sorted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrPtrLongIntInt()

 void SCIPsortedvecInsertPtrPtrLongIntInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Longint field2val, int field3val, int field4val, int * len, int * pos )

insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted longarray SCIP_Longint where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealIntInt()

 void SCIPsortedvecInsertRealIntInt ( SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_Real keyval, int field2val, int field3val, int * len, int * pos )

insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealBoolPtr()

 void SCIPsortedvecInsertRealBoolPtr ( SCIP_Real * realarray, SCIP_Bool * boolarray, void ** ptrarray, SCIP_Real keyval, SCIP_Bool field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealPtr()

 void SCIPsortedvecInsertRealPtr ( SCIP_Real * realarray, void ** ptrarray, SCIP_Real keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

Referenced by SCIPvaluehistoryFind().

## ◆ SCIPsortedvecInsertReal()

 void SCIPsortedvecInsertReal ( SCIP_Real * realarray, SCIP_Real keyval, int * len, int * pos )

insert a new element into an arrays of Reals, sorted in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealInt()

 void SCIPsortedvecInsertRealInt ( SCIP_Real * realarray, int * intarray, SCIP_Real keyval, int field1val, int * len, int * pos )

insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealIntLong()

 void SCIPsortedvecInsertRealIntLong ( SCIP_Real * realarray, int * intarray, SCIP_Longint * longarray, SCIP_Real keyval, int field1val, SCIP_Longint field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealIntPtr()

 void SCIPsortedvecInsertRealIntPtr ( SCIP_Real * realarray, int * intarray, void ** ptrarray, SCIP_Real keyval, int field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealRealPtr()

 void SCIPsortedvecInsertRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealPtrPtrInt()

 void SCIPsortedvecInsertRealPtrPtrInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_Real keyval, void * field1val, void * field2val, int intval, int * len, int * pos )

insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray1 pointer array where an element is to be inserted ptrarray2 pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element intval additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealPtrPtrIntInt()

 void SCIPsortedvecInsertRealPtrPtrIntInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_Real keyval, void * field1val, void * field2val, int intval1, int intval2, int * len, int * pos )

insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray1 pointer array where an element is to be inserted ptrarray2 pointer array where an element is to be inserted intarray1 int array where an element is to be inserted intarray2 int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element intval1 additional value of new element intval2 additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealLongRealInt()

 void SCIPsortedvecInsertRealLongRealInt ( SCIP_Real * realarray1, SCIP_Longint * longarray, SCIP_Real * realarray3, int * intarray, SCIP_Real keyval, SCIP_Longint field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted realarray3 SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealRealIntInt()

 void SCIPsortedvecInsertRealRealIntInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray1, int * intarray2, SCIP_Real keyval, SCIP_Real field1val, int field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealRealRealInt()

 void SCIPsortedvecInsertRealRealRealInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, int * intarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted realarray3 third SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealRealRealPtr()

 void SCIPsortedvecInsertRealRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, void * field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted realarray3 third SCIP_Real array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealRealRealBoolPtr()

 void SCIPsortedvecInsertRealRealRealBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, void * field4val, int * len, int * pos )

insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted realarray3 third SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertRealRealRealBoolBoolPtr()

 void SCIPsortedvecInsertRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, void * field5val, int * len, int * pos )

insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted realarray3 third SCIP_Real array where an element is to be inserted boolarray1 SCIP_Bool array where an element is to be inserted boolarray2 SCIP_Bool array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element field5val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertInt()

 void SCIPsortedvecInsertInt ( int * intarray, int keyval, int * len, int * pos )

insert a new element into an array of ints in non-decreasing order

Parameters
 intarray int array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntInt()

 void SCIPsortedvecInsertIntInt ( int * intarray1, int * intarray2, int keyval, int field1val, int * len, int * pos )

insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

Referenced by profileInsertTimepoint().

## ◆ SCIPsortedvecInsertIntPtr()

 void SCIPsortedvecInsertIntPtr ( int * intarray, void ** ptrarray, int keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntReal()

 void SCIPsortedvecInsertIntReal ( int * intarray, SCIP_Real * realarray, int keyval, SCIP_Real field1val, int * len, int * pos )

insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be inserted realarray real array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntIntInt()

 void SCIPsortedvecInsertIntIntInt ( int * intarray1, int * intarray2, int * intarray3, int keyval, int field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted intarray3 third int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntIntLong()

 void SCIPsortedvecInsertIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, int keyval, int field1val, SCIP_Longint field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntRealLong()

 void SCIPsortedvecInsertIntRealLong ( int * intarray, SCIP_Real * realarray, SCIP_Longint * longarray, int keyval, SCIP_Real field1val, SCIP_Longint field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be inserted realarray SCIP_Real where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntIntPtr()

 void SCIPsortedvecInsertIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, int keyval, int field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntIntReal()

 void SCIPsortedvecInsertIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, int keyval, int field1val, SCIP_Real field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order

Parameters
 intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted realarray real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntPtrReal()

 void SCIPsortedvecInsertIntPtrReal ( int * intarray, void ** ptrarray, SCIP_Real * realarray, int keyval, void * field1val, SCIP_Real field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntIntIntPtr()

 void SCIPsortedvecInsertIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, int keyval, int field1val, int field2val, void * field3val, int * len, int * pos )

insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted intarray3 second int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntIntIntReal()

 void SCIPsortedvecInsertIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, int keyval, int field1val, int field2val, SCIP_Real field3val, int * len, int * pos )

insert a new element into four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted intarray3 second int array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntPtrIntReal()

 void SCIPsortedvecInsertIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, int keyval, void * field1val, int field2val, SCIP_Real field3val, int * len, int * pos )

insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray1 first int array where an element is to be inserted ptrarray pointer array where an element is to be inserted intarray2 second int array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLong()

 void SCIPsortedvecInsertLong ( SCIP_Longint * longarray, SCIP_Longint keyval, int * len, int * pos )

insert a new element into an array of Longints, sorted in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtr()

 void SCIPsortedvecInsertLongPtr ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Longint keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrInt()

 void SCIPsortedvecInsertLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, SCIP_Longint keyval, void * field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrRealBool()

 void SCIPsortedvecInsertLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_Longint keyval, void * field1val, SCIP_Real field2val, SCIP_Bool field3val, int * len, int * pos )

insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrRealRealBool()

 void SCIPsortedvecInsertLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, SCIP_Longint keyval, void * field1val, SCIP_Real field2val, SCIP_Real field3val, SCIP_Bool field4val, int * len, int * pos )

insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrRealRealIntBool()

 void SCIPsortedvecInsertLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, SCIP_Longint keyval, void * field1val, SCIP_Real field2val, SCIP_Real field3val, int field4val, SCIP_Bool field5val, int * len, int * pos )

insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element field5val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrPtrInt()

 void SCIPsortedvecInsertLongPtrPtrInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_Longint keyval, void * field1val, void * field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrPtrIntInt()

 void SCIPsortedvecInsertLongPtrPtrIntInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_Longint keyval, void * field1val, void * field2val, int field3val, int field4val, int * len, int * pos )

insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertLongPtrPtrBoolInt()

 void SCIPsortedvecInsertLongPtrPtrBoolInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, SCIP_Bool * boolarray, int * intarray, SCIP_Longint keyval, void * field1val, void * field2val, SCIP_Bool field3val, int field4val, int * len, int * pos )

insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted intarray int array to be sorted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertPtrIntIntBoolBool()

 void SCIPsortedvecInsertPtrIntIntBoolBool ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int field1val, int field2val, SCIP_Bool field3val, SCIP_Bool field4val, int * len, int * pos )

insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertIntPtrIntIntBoolBool()

 void SCIPsortedvecInsertIntPtrIntIntBoolBool ( int * intarray1, void ** ptrarray, int * intarray2, int * intarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, int keyval, void * field1val, int field2val, int field3val, SCIP_Bool field4val, SCIP_Bool field5val, int * len, int * pos )

insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element field5val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownInd()

 void SCIPsortedvecInsertDownInd ( int * indarray, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int keyval, int * len, int * pos )

insert a new element into an index array in non-increasing order

Parameters
 indarray pointer to the index array where an element is to be inserted dataptr pointer to data field that is given to the external compare method keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtr()

 void SCIPsortedvecInsertDownPtr ( void ** ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int * len, int * pos )

insert a new element into an array of pointers in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtr()

 void SCIPsortedvecInsertDownPtrPtr ( void ** ptrarray1, void ** ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrReal()

 void SCIPsortedvecInsertDownPtrReal ( void ** ptrarray, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrInt()

 void SCIPsortedvecInsertDownPtrInt ( void ** ptrarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrBool()

 void SCIPsortedvecInsertDownPtrBool ( void ** ptrarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Bool field1val, int * len, int * pos )

insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrIntInt()

 void SCIPsortedvecInsertDownPtrIntInt ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrRealInt()

 void SCIPsortedvecInsertDownPtrRealInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrRealBool()

 void SCIPsortedvecInsertDownPtrRealBool ( void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, SCIP_Bool field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrInt()

 void SCIPsortedvecInsertDownPtrPtrInt ( void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrReal()

 void SCIPsortedvecInsertDownPtrPtrReal ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Real field2val, int * len, int * pos )

insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrIntInt()

 void SCIPsortedvecInsertDownPtrPtrIntInt ( void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, int field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrRealIntInt()

 void SCIPsortedvecInsertDownPtrRealIntInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, SCIP_Real field1val, int field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrRealInt()

 void SCIPsortedvecInsertDownPtrPtrRealInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrRealBool()

 void SCIPsortedvecInsertDownPtrPtrRealBool ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Real field2val, SCIP_Bool field3val, int * len, int * pos )

insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrLongInt()

 void SCIPsortedvecInsertDownPtrPtrLongInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Longint field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrPtrLongIntInt()

 void SCIPsortedvecInsertDownPtrPtrLongIntInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, void * field1val, SCIP_Longint field2val, int field3val, int field4val, int * len, int * pos )

insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order

Parameters
 ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownReal()

 void SCIPsortedvecInsertDownReal ( SCIP_Real * realarray, SCIP_Real keyval, int * len, int * pos )

insert a new element into an array of Reals, sorted in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealBoolPtr()

 void SCIPsortedvecInsertDownRealBoolPtr ( SCIP_Real * realarray, SCIP_Bool * boolarray, void ** ptrarray, SCIP_Real keyval, SCIP_Bool field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealPtr()

 void SCIPsortedvecInsertDownRealPtr ( SCIP_Real * realarray, void ** ptrarray, SCIP_Real keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealPtrPtr()

 void SCIPsortedvecInsertDownRealPtrPtr ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, SCIP_Real keyval, void * field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealInt()

 void SCIPsortedvecInsertDownRealInt ( SCIP_Real * realarray, int * intarray, SCIP_Real keyval, int field1val, int * len, int * pos )

insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealIntInt()

 void SCIPsortedvecInsertDownRealIntInt ( SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_Real keyval, int field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted intarray1 int array where an element is to be inserted intarray2 int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealInt()

 void SCIPsortedvecInsertDownRealRealInt ( SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Real keyval, SCIP_Real field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted realarray2 SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealIntLong()

 void SCIPsortedvecInsertDownRealIntLong ( SCIP_Real * realarray, int * intarray, SCIP_Longint * longarray, SCIP_Real keyval, int field1val, SCIP_Longint field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array to be sorted intarray int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealIntPtr()

 void SCIPsortedvecInsertDownRealIntPtr ( SCIP_Real * realarray, int * intarray, void ** ptrarray, SCIP_Real keyval, int field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealPtr()

 void SCIPsortedvecInsertDownRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealPtrPtr()

 void SCIPsortedvecInsertDownRealRealPtrPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray1, void ** ptrarray2, SCIP_Real keyval, SCIP_Real field1val, void * field2val, void * field3val, int * len, int * pos )

insert a new element into three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted ptrarray1 pointer array where an element is to be inserted ptrarray2 pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealPtrPtrInt()

 void SCIPsortedvecInsertDownRealPtrPtrInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_Real keyval, void * field1val, void * field2val, int intval, int * len, int * pos )

insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray1 pointer array where an element is to be inserted ptrarray2 pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element intval additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealPtrPtrIntInt()

 void SCIPsortedvecInsertDownRealPtrPtrIntInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_Real keyval, void * field1val, void * field2val, int intval1, int intval2, int * len, int * pos )

insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order

Parameters
 realarray SCIP_Real array where an element is to be inserted ptrarray1 pointer array where an element is to be inserted ptrarray2 pointer array where an element is to be inserted intarray1 int array where an element is to be inserted intarray2 int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element intval1 additional value of new element intval2 additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealLongRealInt()

 void SCIPsortedvecInsertDownRealLongRealInt ( SCIP_Real * realarray1, SCIP_Longint * longarray, SCIP_Real * realarray3, int * intarray, SCIP_Real keyval, SCIP_Longint field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted realarray3 SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealIntInt()

 void SCIPsortedvecInsertDownRealRealIntInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray1, int * intarray2, SCIP_Real keyval, SCIP_Real field1val, int field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealRealInt()

 void SCIPsortedvecInsertDownRealRealRealInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, int * intarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array where an element is to be inserted realarray2 SCIP_Real array where an element is to be inserted realarray3 SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealRealPtr()

 void SCIPsortedvecInsertDownRealRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, void * field3val, int * len, int * pos )

insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array where an element is to be inserted realarray2 SCIP_Real array where an element is to be inserted realarray3 SCIP_Real array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealRealBoolPtr()

 void SCIPsortedvecInsertDownRealRealRealBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, void * field4val, int * len, int * pos )

insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array where an element is to be inserted realarray2 SCIP_Real array where an element is to be inserted realarray3 SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownRealRealRealBoolBoolPtr()

 void SCIPsortedvecInsertDownRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, void * field5val, int * len, int * pos )

insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order

Parameters
 realarray1 SCIP_Real array where an element is to be inserted realarray2 SCIP_Real array where an element is to be inserted realarray3 SCIP_Real array where an element is to be inserted boolarray1 SCIP_Bool array where an element is to be inserted boolarray2 SCIP_Bool array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element field5val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownInt()

 void SCIPsortedvecInsertDownInt ( int * intarray, int keyval, int * len, int * pos )

insert a new element into an array of ints in non-increasing order

Parameters
 intarray int array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntInt()

 void SCIPsortedvecInsertDownIntInt ( int * intarray1, int * intarray2, int keyval, int field1val, int * len, int * pos )

insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntReal()

 void SCIPsortedvecInsertDownIntReal ( int * intarray, SCIP_Real * realarray, int keyval, SCIP_Real field1val, int * len, int * pos )

insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order

Parameters
 intarray int array where an element is to be inserted realarray real array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntIntInt()

 void SCIPsortedvecInsertDownIntIntInt ( int * intarray1, int * intarray2, int * intarray3, int keyval, int field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted intarray3 third int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntIntLong()

 void SCIPsortedvecInsertDownIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, int keyval, int field1val, SCIP_Longint field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted longarray SCIP_Longint array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntIntPtr()

 void SCIPsortedvecInsertDownIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, int keyval, int field1val, void * field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntIntReal()

 void SCIPsortedvecInsertDownIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, int keyval, int field1val, SCIP_Real field2val, int * len, int * pos )

insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 second int array where an element is to be inserted realarray real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntPtr()

 void SCIPsortedvecInsertDownIntPtr ( int * intarray, void ** ptrarray, int keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order

Parameters
 intarray int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntIntIntPtr()

 void SCIPsortedvecInsertDownIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, int keyval, int field1val, int field2val, void * field3val, int * len, int * pos )

insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 int array where an element is to be inserted intarray3 int array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntIntIntReal()

 void SCIPsortedvecInsertDownIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, int keyval, int field1val, int field2val, SCIP_Real field3val, int * len, int * pos )

insert a new element into four joint arrays of ints/int/ints/reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted intarray2 int array where an element is to be inserted intarray3 int array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntPtrIntReal()

 void SCIPsortedvecInsertDownIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, int keyval, void * field1val, int field2val, SCIP_Real field3val, int * len, int * pos )

insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-increasing order

Parameters
 intarray1 int array where an element is to be inserted ptrarray pointer array where an element is to be inserted intarray2 int array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLong()

 void SCIPsortedvecInsertDownLong ( SCIP_Longint * longarray, SCIP_Longint keyval, int * len, int * pos )

insert a new element into an array of Longints, sorted in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted keyval key value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtr()

 void SCIPsortedvecInsertDownLongPtr ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Longint keyval, void * field1val, int * len, int * pos )

insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted keyval key value of new element field1val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrInt()

 void SCIPsortedvecInsertDownLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, SCIP_Longint keyval, void * field1val, int field2val, int * len, int * pos )

insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrRealBool()

 void SCIPsortedvecInsertDownLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_Longint keyval, void * field1val, SCIP_Real field2val, SCIP_Bool field3val, int * len, int * pos )

insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrRealRealBool()

 void SCIPsortedvecInsertDownLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, SCIP_Longint keyval, void * field1val, SCIP_Real field2val, SCIP_Real field3val, SCIP_Bool field4val, int * len, int * pos )

insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrRealRealIntBool()

 void SCIPsortedvecInsertDownLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, SCIP_Longint keyval, void * field1val, SCIP_Real field2val, SCIP_Real field3val, int field4val, SCIP_Bool field5val, int * len, int * pos )

insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray pointer array where an element is to be inserted realarray first SCIP_Real array where an element is to be inserted realarray2 second SCIP_Real array where an element is to be inserted intarray int array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element field5val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrPtrInt()

 void SCIPsortedvecInsertDownLongPtrPtrInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_Longint keyval, void * field1val, void * field2val, int field3val, int * len, int * pos )

insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrPtrIntInt()

 void SCIPsortedvecInsertDownLongPtrPtrIntInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_Longint keyval, void * field1val, void * field2val, int field3val, int field4val, int * len, int * pos )

insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted intarray1 first int array where an element is to be inserted intarray2 second int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownLongPtrPtrBoolInt()

 void SCIPsortedvecInsertDownLongPtrPtrBoolInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, SCIP_Bool * boolarray, int * intarray, SCIP_Longint keyval, void * field1val, void * field2val, SCIP_Bool field3val, int field4val, int * len, int * pos )

insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order

Parameters
 longarray SCIP_Longint array where an element is to be inserted ptrarray1 first pointer array where an element is to be inserted ptrarray2 second pointer array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted intarray int array where an element is to be inserted keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownPtrIntIntBoolBool()

 void SCIPsortedvecInsertDownPtrIntIntBoolBool ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , void * keyval, int field1val, int field2val, SCIP_Bool field3val, SCIP_Bool field4val, int * len, int * pos )

insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecInsertDownIntPtrIntIntBoolBool()

 void SCIPsortedvecInsertDownIntPtrIntIntBoolBool ( int * intarray1, void ** ptrarray, int * intarray2, int * intarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, int keyval, void * field1val, int field2val, int field3val, SCIP_Bool field4val, SCIP_Bool field5val, int * len, int * pos )

insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way keyval key value of new element field1val additional value of new element field2val additional value of new element field3val additional value of new element field4val additional value of new element field5val additional value of new element len pointer to length of arrays (will be increased by 1) pos pointer to store the insertion position, or NULL

## ◆ SCIPsortedvecDelPosInd()

 void SCIPsortedvecDelPosInd ( int * indarray, SCIP_DECL_SORTINDCOMP((*indcomp)) , void * dataptr, int pos, int * len )

delete the element at the given position from an index array in non-decreasing order

Parameters
 indarray pointer to the index array where an element is to be deleted dataptr pointer to data field that is given to the external compare method pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtr()

 void SCIPsortedvecDelPosPtr ( void ** ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from an array of pointers in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

Referenced by removeNode().

## ◆ SCIPsortedvecDelPosPtrPtr()

 void SCIPsortedvecDelPosPtrPtr ( void ** ptrarray1, void ** ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrReal()

 void SCIPsortedvecDelPosPtrReal ( void ** ptrarray, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrInt()

 void SCIPsortedvecDelPosPtrInt ( void ** ptrarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrBool()

 void SCIPsortedvecDelPosPtrBool ( void ** ptrarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be inserted boolarray SCIP_Bool array where an element is to be inserted pos array position of element to be deleted len pointer to length of arrays (will be increased by 1)

## ◆ SCIPsortedvecDelPosPtrIntInt()

 void SCIPsortedvecDelPosPtrIntInt ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted intarray1 first int array where an element is to be deleted intarray2 second int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrRealInt()

 void SCIPsortedvecDelPosPtrRealInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrRealRealInt()

 void SCIPsortedvecDelPosPtrRealRealInt ( void ** ptrarray, SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from four joint arrays of pointers/RealsReals//ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted realarray1 SCIP_Real array where an element is to be deleted realarray2 SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrRealBool()

 void SCIPsortedvecDelPosPtrRealBool ( void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted boolarray SCIP_Bool array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrInt()

 void SCIPsortedvecDelPosPtrPtrInt ( void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrReal()

 void SCIPsortedvecDelPosPtrPtrReal ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrIntInt()

 void SCIPsortedvecDelPosPtrPtrIntInt ( void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted intarray1 first int array where an element is to be deleted intarray2 second array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrRealIntInt()

 void SCIPsortedvecDelPosPtrRealIntInt ( void ** ptrarray, SCIP_Real * realarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted intarray1 first int array where an element is to be deleted intarray2 second int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrRealInt()

 void SCIPsortedvecDelPosPtrPtrRealInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrRealBool()

 void SCIPsortedvecDelPosPtrPtrRealBool ( void ** ptrarray1, void ** ptrarray2, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted boolarray SCIP_Bool array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrLongInt()

 void SCIPsortedvecDelPosPtrPtrLongInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted longarray SCIP_Longint array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosPtrPtrLongIntInt()

 void SCIPsortedvecDelPosPtrPtrLongIntInt ( void ** ptrarray1, void ** ptrarray2, SCIP_Longint * longarray, int * intarray1, int * intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int pos, int * len )

deletes the element at the given position from five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order

Parameters
 ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted longarray SCIP_Longint array where an element is to be deleted intarray1 first int array where an element is to be deleted intarray2 second int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealBoolPtr()

 void SCIPsortedvecDelPosRealBoolPtr ( SCIP_Real * realarray, SCIP_Bool * boolarray, void ** ptrarray, int pos, int * len )

delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array to be sorted boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealPtr()

 void SCIPsortedvecDelPosRealPtr ( SCIP_Real * realarray, void ** ptrarray, int pos, int * len )

delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosReal()

 void SCIPsortedvecDelPosReal ( SCIP_Real * realarray, int pos, int * len )

delete the element at the given position from an arrays of Reals, sorted in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealInt()

 void SCIPsortedvecDelPosRealInt ( SCIP_Real * realarray, int * intarray, int pos, int * len )

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealIntInt()

 void SCIPsortedvecDelPosRealIntInt ( SCIP_Real * realarray, int * intarray1, int * intarray2, int pos, int * len )

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be deleted intarray1 int array where an element is to be deleted intarray2 int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealIntLong()

 void SCIPsortedvecDelPosRealIntLong ( SCIP_Real * realarray, int * intarray, SCIP_Longint * longarray, int pos, int * len )

delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted longarray SCIP_Longint array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealIntPtr()

 void SCIPsortedvecDelPosRealIntPtr ( SCIP_Real * realarray, int * intarray, void ** ptrarray, int pos, int * len )

delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealRealPtr()

 void SCIPsortedvecDelPosRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, void ** ptrarray, int pos, int * len )

delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

Parameters
 realarray1 first SCIP_Real array where an element is to be deleted realarray2 second SCIP_Real array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealPtrPtrInt()

 void SCIPsortedvecDelPosRealPtrPtrInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray, int pos, int * len )

delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

Parameters
 realarray first SCIP_Real array where an element is to be deleted ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealPtrPtrIntInt()

 void SCIPsortedvecDelPosRealPtrPtrIntInt ( SCIP_Real * realarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, int pos, int * len )

delete the element at the given position from five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray first SCIP_Real array where an element is to be deleted ptrarray1 first pointer array where an element is to be deleted ptrarray2 second pointer array where an element is to be deleted intarray1 int array where an element is to be deleted intarray2 int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealLongRealInt()

 void SCIPsortedvecDelPosRealLongRealInt ( SCIP_Real * realarray1, SCIP_Longint * longarray, SCIP_Real * realarray3, int * intarray, int pos, int * len )

delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be deleted longarray SCIP_Longint array where an element is to be deleted realarray3 SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealRealIntInt()

 void SCIPsortedvecDelPosRealRealIntInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, int * intarray1, int * intarray2, int pos, int * len )

delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be deleted realarray2 SCIP_Real array where an element is to be deleted intarray1 int array where an element is to be deleted intarray2 int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealRealRealInt()

 void SCIPsortedvecDelPosRealRealRealInt ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, int * intarray, int pos, int * len )

delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be deleted realarray2 SCIP_Real array where an element is to be deleted realarray3 SCIP_Real array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealRealRealPtr()

 void SCIPsortedvecDelPosRealRealRealPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, void ** ptrarray, int pos, int * len )

delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be deleted realarray2 SCIP_Real array where an element is to be deleted realarray3 SCIP_Real array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealRealRealBoolPtr()

 void SCIPsortedvecDelPosRealRealRealBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray, void ** ptrarray, int pos, int * len )

delete the element at the given position from five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be deleted realarray2 SCIP_Real array where an element is to be deleted realarray3 SCIP_Real array where an element is to be deleted boolarray SCIP_Bool array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosRealRealRealBoolBoolPtr()

 void SCIPsortedvecDelPosRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, int pos, int * len )

delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

Parameters
 realarray1 SCIP_Real array where an element is to be deleted realarray2 SCIP_Real array where an element is to be deleted realarray3 SCIP_Real array where an element is to be deleted boolarray1 SCIP_Bool array where an element is to be deleted boolarray2 SCIP_Bool array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosInt()

 void SCIPsortedvecDelPosInt ( int * intarray, int pos, int * len )

delete the element at the given position from an array of ints in non-decreasing order

Parameters
 intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntInt()

 void SCIPsortedvecDelPosIntInt ( int * intarray1, int * intarray2, int pos, int * len )

delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 second int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntReal()

 void SCIPsortedvecDelPosIntReal ( int * intarray, SCIP_Real * realarray, int pos, int * len )

delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be deleted realarray real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntIntInt()

 void SCIPsortedvecDelPosIntIntInt ( int * intarray1, int * intarray2, int * intarray3, int pos, int * len )

delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 second int array where an element is to be deleted intarray3 third int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntIntLong()

 void SCIPsortedvecDelPosIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, int pos, int * len )

delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 second int array where an element is to be deleted longarray SCIP_Longint array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntRealLong()

 void SCIPsortedvecDelPosIntRealLong ( int * intarray, SCIP_Real * realarray, SCIP_Longint * longarray, int pos, int * len )

delete the element at the given position from three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted longarray SCIP_Longint array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntIntPtr()

 void SCIPsortedvecDelPosIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, int pos, int * len )

delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 second int array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntIntReal()

 void SCIPsortedvecDelPosIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, int pos, int * len )

delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 second int array where an element is to be deleted realarray real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntPtr()

 void SCIPsortedvecDelPosIntPtr ( int * intarray, void ** ptrarray, int pos, int * len )

delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntPtrReal()

 void SCIPsortedvecDelPosIntPtrReal ( int * intarray, void ** ptrarray, SCIP_Real * realarray, int pos, int * len )

delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order

Parameters
 intarray int array where an element is to be deleted ptrarray pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntIntIntPtr()

 void SCIPsortedvecDelPosIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, int pos, int * len )

delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 int array where an element is to be deleted intarray3 int array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntIntIntReal()

 void SCIPsortedvecDelPosIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, int pos, int * len )

delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted intarray2 int array where an element is to be deleted intarray3 int array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosIntPtrIntReal()

 void SCIPsortedvecDelPosIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, int pos, int * len )

delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order

Parameters
 intarray1 int array where an element is to be deleted ptrarray pointer array where an element is to be deleted intarray2 int array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosLong()

 void SCIPsortedvecDelPosLong ( SCIP_Longint * longarray, int pos, int * len )

delete the element at the given position from an array of Longints, sorted by in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosLongPtr()

 void SCIPsortedvecDelPosLongPtr ( SCIP_Longint * longarray, void ** ptrarray, int pos, int * len )

delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be deleted ptrarray pointer array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosLongPtrInt()

 void SCIPsortedvecDelPosLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, int pos, int * len )

delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be deleted ptrarray pointer array where an element is to be deleted intarray int array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosLongPtrRealBool()

 void SCIPsortedvecDelPosLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, int pos, int * len )

delete the element at the given position from four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be deleted ptrarray pointer array where an element is to be deleted realarray SCIP_Real array where an element is to be deleted boolarray SCIP_Bool array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosLongPtrRealRealBool()

 void SCIPsortedvecDelPosLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, int pos, int * len )

delete the element at the given position from five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

Parameters
 longarray SCIP_Longint array where an element is to be deleted ptrarray pointer array where an element is to be deleted realarray first SCIP_Real array where an element is to be deleted realarray2 second SCIP_Real array where an element is to be deleted boolarray SCIP_Bool array where an element is to be deleted pos array position of element to be deleted len pointer to length of arrays (will be decreased by 1)

## ◆ SCIPsortedvecDelPosLongPtrRealRealIntBool()

 void SCIPsortedvecDelPosLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, int pos, int * len )

delete the element at the given position from six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first a