Scippy

SCIP

Solving Constraint Integer Programs

Sorting Algorithms

Detailed Description

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 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 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 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 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 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 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 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 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 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 SCIPsortDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 SCIPsortedvecDelPosDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, 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 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 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)
 

Function Documentation

SCIP_DECL_SORTPTRCOMP ( SCIPsortCompInt  )

default comparer for integers

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
permpointer to store the resulting permutation
dataptrpointer to data field that is given to the external compare method
lennumber of elements to be sorted (valid index range)
void SCIPsortInd ( int *  indarray,
SCIP_DECL_SORTINDCOMP((*indcomp))  ,
void *  dataptr,
int  len 
)

sort an index array in non-decreasing order

Parameters
indarraypointer to the index array to be sorted
dataptrpointer to data field that is given to the external compare method
lenlength of array
void SCIPsortPtr ( void **  ptrarray,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
int  len 
)

sort of an array of pointers in non-decreasing order

Parameters
ptrarraypointer array to be sorted
lenlength of array
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
void SCIPsortReal ( SCIP_Real realarray,
int  len 
)

sort an array of Reals in non-decreasing order

Parameters
realarraySCIP_Real array to be sorted
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarrayint array to be sorted
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarray1int array to be sorted
intarray2int array to be sorted
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
longarraySCIP_Longint array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
void SCIPsortInt ( int *  intarray,
int  len 
)

sort array of ints in non-decreasing order

Parameters
intarrayint array to be sorted
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
lenlength of arrays
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
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
intarray3third int array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
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
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayreal array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
void SCIPsortLong ( SCIP_Longint longarray,
int  len 
)

sort an array of Longints in non-decreasing order

Parameters
longarraySCIP_Longint array to be sorted
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
intarrayint array to be sorted
lenlength of arrays
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
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
lenlength of arrays
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
permpointer to store the resulting permutation
dataptrpointer to data field that is given to the external compare method
lennumber of elements to be sorted (valid index range)
void SCIPsortDownInd ( int *  indarray,
SCIP_DECL_SORTINDCOMP((*indcomp))  ,
void *  dataptr,
int  len 
)

sort an index array in non-increasing order

Parameters
indarraypointer to the index array to be sorted
dataptrpointer to data field that is given to the external compare method
lenlength of array
void SCIPsortDownPtr ( void **  ptrarray,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
int  len 
)

sort of an array of pointers in non-increasing order

Parameters
ptrarraypointer array to be sorted
lenlength of array
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
void SCIPsortDownReal ( SCIP_Real realarray,
int  len 
)

sort an array of Reals in non-increasing order

Parameters
realarraySCIP_Real array to be sorted
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
intarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarrayint array to be sorted
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarray1int array to be sorted
intarray2int array to be sorted
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
longarraySCIP_Longint array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
lenlength of arrays
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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
void SCIPsortDownInt ( int *  intarray,
int  len 
)

sort array of ints in non-increasing order

Parameters
intarrayint array to be sorted
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
lenlength of arrays
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
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
intarray3third int array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
lenlength of arrays
void SCIPsortDownLong ( SCIP_Longint longarray,
int  len 
)

sort an array of Longints in non-increasing order

Parameters
longarraySCIP_Longint array to be sorted
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
lenlength of arrays
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
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
intarrayint array to be sorted
lenlength of arrays
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
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
lenlength of arrays
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
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
lenlength of arrays
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
indarraypointer to the index array where an element is to be inserted
dataptrpointer to data field that is given to the external compare method
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer to the pointer array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
intarrayint array to be sorted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
intarrayint array to be sorted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
longarraySCIP_Longint where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarray1pointer array where an element is to be inserted
ptrarray2pointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
intvaladditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarray1pointer array where an element is to be inserted
ptrarray2pointer array where an element is to be inserted
intarray1int array where an element is to be inserted
intarray2int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
intval1additional value of new element
intval2additional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1SCIP_Real array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
realarray3SCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
realarray3third SCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
realarray3third SCIP_Real array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
realarray3third SCIP_Real array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
void SCIPsortedvecInsertInt ( int *  intarray,
int  keyval,
int *  len,
int *  pos 
)

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

Parameters
intarrayint array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarrayint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarrayint array where an element is to be inserted
realarrayreal array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
intarray3third int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
realarrayreal array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarrayint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
intarray3second int array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1first int array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
intarray2second int array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarrayfirst SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarrayfirst SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
field5valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
intarrayint array to be sorted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
field5valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
indarraypointer to the index array where an element is to be inserted
dataptrpointer to data field that is given to the external compare method
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarray1pointer array where an element is to be inserted
ptrarray2pointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
intvaladditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarraySCIP_Real array where an element is to be inserted
ptrarray1pointer array where an element is to be inserted
ptrarray2pointer array where an element is to be inserted
intarray1int array where an element is to be inserted
intarray2int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
intval1additional value of new element
intval2additional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1SCIP_Real array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
realarray3SCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1first SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1SCIP_Real array where an element is to be inserted
realarray2SCIP_Real array where an element is to be inserted
realarray3SCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1SCIP_Real array where an element is to be inserted
realarray2SCIP_Real array where an element is to be inserted
realarray3SCIP_Real array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
realarray1SCIP_Real array where an element is to be inserted
realarray2SCIP_Real array where an element is to be inserted
realarray3SCIP_Real array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
void SCIPsortedvecInsertDownInt ( int *  intarray,
int  keyval,
int *  len,
int *  pos 
)

insert a new element into an array of ints in non-increasing order

Parameters
intarrayint array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarrayint array where an element is to be inserted
realarrayreal array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
intarray3third int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
longarraySCIP_Longint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2second int array where an element is to be inserted
realarrayreal array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarrayint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
intarray2int array where an element is to be inserted
intarray3int array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
intarray2int array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
keyvalkey value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarraySCIP_Real array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarrayfirst SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarraypointer array where an element is to be inserted
realarrayfirst SCIP_Real array where an element is to be inserted
realarray2second SCIP_Real array where an element is to be inserted
intarrayint array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
field5valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
intarray1first int array where an element is to be inserted
intarray2second int array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
longarraySCIP_Longint array where an element is to be inserted
ptrarray1first pointer array where an element is to be inserted
ptrarray2second pointer array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
intarrayint array where an element is to be inserted
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
keyvalkey value of new element
field1valadditional value of new element
field2valadditional value of new element
field3valadditional value of new element
field4valadditional value of new element
field5valadditional value of new element
lenpointer to length of arrays (will be increased by 1)
pospointer to store the insertion position, or NULL
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
indarraypointer to the index array where an element is to be deleted
dataptrpointer to data field that is given to the external compare method
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarraypointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarraypointer array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
posarray position of element to be deleted
lenpointer to length of arrays (will be increased by 1)
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
ptrarraypointer array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarraySCIP_Real array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarray1first SCIP_Real array where an element is to be deleted
realarray2second SCIP_Real array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarrayfirst SCIP_Real array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarrayfirst SCIP_Real array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarray1int array where an element is to be deleted
intarray2int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarray1SCIP_Real array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
intarray1int array where an element is to be deleted
intarray2int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarrayint array where an element is to be deleted
realarrayreal array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
intarray3third int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
realarrayreal array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarrayint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarrayint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
intarray2int array where an element is to be deleted
intarray3int array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
intarray1int array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
intarray2int array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
longarraySCIP_Longint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarrayfirst SCIP_Real array where an element is to be deleted
realarray2second SCIP_Real array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
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 array in non-decreasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarrayfirst SCIP_Real array where an element is to be deleted
realarray2second SCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosLongPtrPtrInt ( SCIP_Longint longarray,
void **  ptrarray1,
void **  ptrarray2,
int *  intarray,
int  pos,
int *  len 
)

delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosLongPtrPtrIntInt ( SCIP_Longint longarray,
void **  ptrarray1,
void **  ptrarray2,
int *  intarray1,
int *  intarray2,
int  pos,
int *  len 
)

delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosLongPtrPtrBoolInt ( SCIP_Longint longarray,
void **  ptrarray1,
void **  ptrarray2,
SCIP_Bool boolarray,
int *  intarray,
int  pos,
int *  len 
)

delete the element at the given position from five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosPtrIntIntBoolBool ( void **  ptrarray,
int *  intarray1,
int *  intarray2,
SCIP_Bool boolarray1,
SCIP_Bool boolarray2,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
int  pos,
int *  len 
)

delete the element at the given position from five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosIntPtrIntIntBoolBool ( int *  intarray1,
void **  ptrarray,
int *  intarray2,
int *  intarray3,
SCIP_Bool boolarray1,
SCIP_Bool boolarray2,
int  pos,
int *  len 
)

delete the element at the given position from six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownInd ( 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-increasing order

Parameters
indarraypointer to the index array where an element is to be deleted
dataptrpointer to data field that is given to the external compare method
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtr ( void **  ptrarray,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
int  pos,
int *  len 
)

delete the element at the given position from an array of pointers in non-increasing order

Parameters
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtr ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrReal ( 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-increasing order

Parameters
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrInt ( 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-increasing order

Parameters
ptrarraypointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrBool ( 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-increasing order

Parameters
ptrarraypointer array where an element is to be inserted
boolarraySCIP_Bool array where an element is to be inserted
posarray position of element to be deleted
lenpointer to length of arrays (will be increased by 1)
void SCIPsortedvecDelPosDownPtrIntInt ( 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-increasing order

Parameters
ptrarraypointer array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrRealInt ( 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-increasing order

Parameters
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtrInt ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtrReal ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtrIntInt ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrRealIntInt ( 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-increasing order

Parameters
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtrRealInt ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtrLongInt ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrPtrLongIntInt ( 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-increasing order

Parameters
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownReal ( SCIP_Real realarray,
int  pos,
int *  len 
)

delete the element at the given position from an array of Reals, sorted in non-increasing order

Parameters
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealBoolPtr ( 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-increasing order

Parameters
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealPtr ( 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-increasing order

Parameters
realarraySCIP_Real array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealInt ( 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-increasing order

Parameters
realarraySCIP_Real array where an element is to be deleted
intarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealIntLong ( 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-increasing order

Parameters
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealIntPtr ( 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-increasing order

Parameters
realarraySCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealRealPtr ( 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-increasing order

Parameters
realarray1first SCIP_Real array where an element is to be deleted
realarray2second SCIP_Real array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealPtrPtr ( SCIP_Real realarray,
void **  ptrarray1,
void **  ptrarray2,
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-increasing order

Parameters
realarrayfirst SCIP_Real array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealPtrPtrInt ( 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-increasing order

Parameters
realarrayfirst SCIP_Real array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealPtrPtrIntInt ( 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-increasing order

Parameters
realarrayfirst SCIP_Real array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarray1int array where an element is to be deleted
intarray2int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealLongRealInt ( 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-increasing order

Parameters
realarray1SCIP_Real array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealRealIntInt ( 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-increasing order

Parameters
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
intarray1int array where an element is to be deleted
intarray2int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealRealRealInt ( 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-increasing order

Parameters
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealRealRealPtr ( 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-increasing order

Parameters
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownRealRealRealBoolPtr ( 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-increasing order

Parameters
realarray1SCIP_Real array where an element is to be deleted
realarray2SCIP_Real array where an element is to be deleted
realarray3SCIP_Real array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownInt ( int *  intarray,
int  pos,
int *  len 
)

delete the element at the given position from an array of ints in non-increasing order

Parameters
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntInt ( 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-increasing order

Parameters
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntReal ( 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-increasing order

Parameters
intarrayint array where an element is to be deleted
realarrayreal array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntIntInt ( 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-increasing order

Parameters
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
intarray3third int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntIntLong ( 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-increasing order

Parameters
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
longarraySCIP_Longint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntIntPtr ( 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-increasing order

Parameters
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntIntReal ( 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-increasing order

Parameters
intarray1int array where an element is to be deleted
intarray2second int array where an element is to be deleted
realarrayreal array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntPtr ( 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-increasing order

Parameters
intarrayint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntIntIntPtr ( 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
intarray1int array where an element is to be deleted
intarray2int array where an element is to be deleted
intarray3int array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntPtrIntReal ( 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
intarray1int array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
intarray2int array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLong ( SCIP_Longint longarray,
int  pos,
int *  len 
)

delete the element at the given position from an array of Longints, sorted in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtr ( SCIP_Longint longarray,
void **  ptrarray,
int  pos,
int *  len 
)

delete the element at the given position from three two arrays of Long/pointer, sorted by the first array in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrInt ( 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-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrRealBool ( SCIP_Longint longarray,
void **  ptrarray,
SCIP_Real realarray,
SCIP_Bool boolarray,
int  pos,
int *  len 
)

delete the element at the given position from three joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarraySCIP_Real array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrRealRealBool ( 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-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarrayfirst SCIP_Real array where an element is to be deleted
realarray2second SCIP_Real array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrRealRealIntBool ( 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 array in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarraypointer array where an element is to be deleted
realarrayfirst SCIP_Real array where an element is to be deleted
realarray2second SCIP_Real array where an element is to be deleted
intarrayint array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrPtrInt ( SCIP_Longint longarray,
void **  ptrarray1,
void **  ptrarray2,
int *  intarray,
int  pos,
int *  len 
)

delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrPtrIntInt ( SCIP_Longint longarray,
void **  ptrarray1,
void **  ptrarray2,
int *  intarray1,
int *  intarray2,
int  pos,
int *  len 
)

delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
intarray1first int array where an element is to be deleted
intarray2second int array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownLongPtrPtrBoolInt ( SCIP_Longint longarray,
void **  ptrarray1,
void **  ptrarray2,
SCIP_Bool boolarray,
int *  intarray,
int  pos,
int *  len 
)

delete the element at the given position from five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order

Parameters
longarraySCIP_Longint array where an element is to be deleted
ptrarray1first pointer array where an element is to be deleted
ptrarray2second pointer array where an element is to be deleted
boolarraySCIP_Bool array where an element is to be deleted
intarrayint array where an element is to be deleted
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownPtrIntIntBoolBool ( void **  ptrarray,
int *  intarray1,
int *  intarray2,
SCIP_Bool boolarray1,
SCIP_Bool boolarray2,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
int  pos,
int *  len 
)

delete the element at the given position from five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
void SCIPsortedvecDelPosDownIntPtrIntIntBoolBool ( int *  intarray1,
void **  ptrarray,
int *  intarray2,
int *  intarray3,
SCIP_Bool boolarray1,
SCIP_Bool boolarray2,
int  pos,
int *  len 
)

delete the element at the given position from six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
posarray position of element to be deleted
lenpointer to length of arrays (will be decreased by 1)
SCIP_Bool SCIPsortedvecFindInd ( int *  indarray,
SCIP_DECL_SORTINDCOMP((*indcomp))  ,
void *  dataptr,
int  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
indarrayindex array to be searched
dataptrpointer to data field that is given to the external compare method
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindPtr ( void **  ptrarray,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
void *  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
ptrarraypointer array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindReal ( SCIP_Real realarray,
SCIP_Real  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
realarraySCIP_Real array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindInt ( int *  intarray,
int  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
intarrayint array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindLong ( SCIP_Longint longarray,
SCIP_Longint  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
longarraySCIP_Longint array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindDownInd ( int *  indarray,
SCIP_DECL_SORTINDCOMP((*indcomp))  ,
void *  dataptr,
int  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
indarrayindex array to be searched
dataptrpointer to data field that is given to the external compare method
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindDownPtr ( void **  ptrarray,
SCIP_DECL_SORTPTRCOMP((*ptrcomp))  ,
void *  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
ptrarraypointer array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindDownReal ( SCIP_Real realarray,
SCIP_Real  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
realarraySCIP_Real array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindDownInt ( int *  intarray,
int  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
intarrayint array to be searched
valvalue to search
lenlength of array
pospointer to store position of element
SCIP_Bool SCIPsortedvecFindDownLong ( SCIP_Longint longarray,
SCIP_Longint  val,
int  len,
int *  pos 
)

Finds the position at which 'val' is located in the sorted vector by binary search. If the element exists, the method returns TRUE and stores the position of the element in '*pos'. If the element does not exist, the method returns FALSE and stores the position of the element that follows 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted. Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.

Parameters
longarraySCIP_Longint array to be searched
valvalue to search
lenlength of array
pospointer to store position of element