Detailed Description

public methods for in place sorting of arrays

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

Functions
	SCIP_DECL_SORTPTRCOMP (SCIPsortCompInt)

	SCIP_DECL_SORTINDCOMP (SCIPsortArgsortInt)

	SCIP_DECL_SORTINDCOMP (SCIPsortArgsortPtr)

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

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

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

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

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

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

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

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

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

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

void	SCIPsortPtrRealRealBoolBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int len)

void	SCIPsortPtrRealRealIntBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int len)

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

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

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

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

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

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

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

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

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

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

void	SCIPsortReal (SCIP_Real *realarray, int len)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	SCIPsortInt (int *intarray, int len)

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

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

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

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

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

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

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

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

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

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

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

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

void	SCIPsortLong (SCIP_Longint *longarray, int len)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	SCIPsortDownReal (SCIP_Real *realarray, int len)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	SCIPsortDownInt (int *intarray, int len)

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

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

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

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

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

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

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

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

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

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

void	SCIPsortDownLong (SCIP_Longint *longarray, int len)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	SCIPsortedvecInsertPtrRealRealBoolBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), void keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, int len, int *pos)

void	SCIPsortedvecInsertPtrRealRealIntBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), void keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, SCIP_Bool field4val, int len, int *pos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	SCIPsortedvecDelPosPtrRealRealBoolBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int pos, int *len)

void	SCIPsortedvecDelPosPtrRealRealIntBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int pos, int *len)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Function Documentation

◆ SCIP_DECL_SORTPTRCOMP()

SCIP_DECL_SORTPTRCOMP ( SCIPsortCompInt )

default comparer for integers

Definition at line 5480 of file misc.c.

◆ SCIP_DECL_SORTINDCOMP() [1/2]

SCIP_DECL_SORTINDCOMP ( SCIPsortArgsortInt )

implements argsort

The data pointer is a lookup array of integers.

Definition at line 5501 of file misc.c.

◆ SCIP_DECL_SORTINDCOMP() [2/2]

SCIP_DECL_SORTINDCOMP ( SCIPsortArgsortPtr )

implements argsort

The data pointer is a lookup array, which are pointer arrays.

Definition at line 5520 of file misc.c.

◆ SCIPsort()

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

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

Parameters

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

Definition at line 5538 of file misc.c.

References NULL, and SCIPsortInd().

Referenced by applyCliqueFixings(), applyOrbitalBranchingPropagations(), applyOrbitalReductionPropagations(), buildSubgroupGraph(), checkSymmetriesAreSymmetries(), identifyOrbitalSymmetriesBroken(), removeRedundantConss(), SCIP_DECL_BRANCHEXECLP(), SCIPcomputeSymgraphColors(), SCIPcreateSymgraphConsnodeperm(), and tryAddGadgetSquaredDifference().

◆ SCIPsortInd()

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

sort an index array in non-decreasing order

Parameters

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

Referenced by checkOverloadViaThetaTree(), decompHorizonGetFirstPosBestPotential(), extractCapacityRows(), extractFlowRows(), getVarOrder(), SCIP_DECL_EXPRSIMPLIFY(), SCIPsort(), and updateColumnOrderWhenBranchingOnColumn().

◆ SCIPsortPtr()

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

sort of an array of pointers in non-decreasing order

Parameters

ptrarray	pointer array to be sorted
len	length of array

Referenced by addExprViolScoresAuxVars(), canonicalizeConstraints(), checkSolution(), componentPackingPartitioningOrbisackUpgrade(), consdataCreate(), consdataSort(), correctConshdlrdata(), createAndAddAndCons(), createConflictGraphSST(), doSeparation(), dropVarEvent(), extractGates(), getLinearConsVarsData(), getLinVarsAndAndRess(), innerPresolve(), mergeMultiples(), mod2MatrixAddOrigRow(), mod2MatrixAddTransRow(), preprocessConstraintPairs(), removeDoubleAndSingletonsAndPerformDualpresolve(), removeRedundantConssAndNonzeros(), SCIP_DECL_DIALOGEXEC(), SCIP_DECL_HEUREXEC(), SCIP_DECL_NLHDLRDETECT(), SCIPbendersGetBenderscuts(), SCIPbendersSortBenderscuts(), SCIPbendersSortBenderscutsName(), SCIPcreateConsPseudobooleanWithConss(), SCIPdispAutoActivate(), SCIPprintSolReaderFzn(), SCIPprintStatistics(), SCIPprobResortVars(), SCIPprobSortConssCheck(), SCIPsetExistsDialog(), SCIPsetFindConshdlr(), SCIPsetFindCutsel(), SCIPsetFindReader(), SCIPsetFreeConcsolvers(), SCIPsetGetNodesel(), SCIPsetIncludeConcsolver(), SCIPsetIncludeProp(), SCIPsetIncludeReader(), SCIPsetReinsertConshdlrSepaPrio(), SCIPsetSortConflicthdlrs(), SCIPsetSortConflicthdlrsName(), SCIPsetSortCutsels(), SCIPsetSortHeurs(), SCIPsetSortHeursName(), SCIPsetSortPresols(), SCIPsetSortPresolsName(), SCIPsetSortPricers(), SCIPsetSortPricersName(), SCIPsetSortRelaxs(), SCIPsetSortRelaxsName(), SCIPsetSortSepas(), SCIPvarsGetActiveVars(), transformToOrig(), tryUpgradingXor(), and updateConsanddataUses().

◆ SCIPsortPtrPtr()

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

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

Parameters

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

◆ SCIPsortPtrReal()

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

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

Parameters

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

Referenced by checkOrigPbCons(), conflictstoreCleanUpStorage(), getLinearConsVarsData(), nlrowSortLinear(), SCIPmergeRowprepTerms(), and SCIPvarGetActiveRepresentatives().

◆ SCIPsortPtrInt()

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

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

Parameters

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

Referenced by makeCoverMinimal(), and selectBranchVar().

◆ SCIPsortPtrBool()

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

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

Parameters

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

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

◆ SCIPsortPtrIntInt()

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

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

Parameters

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

◆ SCIPsortPtrRealInt()

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

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

Parameters

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

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

◆ SCIPsortPtrRealRealInt()

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

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

Parameters

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

◆ SCIPsortPtrRealRealBoolBool()

void SCIPsortPtrRealRealBoolBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	len
	)

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

Parameters

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

Referenced by SCIPconflictstoreAddDualsolcons().

◆ SCIPsortPtrRealRealIntBool()

void SCIPsortPtrRealRealIntBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	len
	)

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

Parameters

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

◆ SCIPsortPtrRealBool()

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

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

Parameters

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

Referenced by correctLocksAndCaptures(), and getLinVarsAndAndRess().

◆ SCIPsortPtrRealReal()

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

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

Parameters

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

◆ SCIPsortPtrPtrInt()

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

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

Parameters

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

Referenced by computeAndConstraintInfos().

◆ SCIPsortPtrPtrReal()

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

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

Parameters

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

Referenced by printColumnSection().

◆ SCIPsortPtrPtrIntInt()

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

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

Parameters

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

Referenced by SCIPinitHeurOptcumulative().

◆ SCIPsortPtrRealIntInt()

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

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

Parameters

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

◆ SCIPsortPtrPtrRealInt()

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

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

Parameters

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

◆ SCIPsortPtrPtrRealBool()

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

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

Parameters

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

Referenced by consdataCreate().

◆ SCIPsortPtrPtrLongInt()

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

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

Parameters

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

◆ SCIPsortPtrPtrLongIntInt()

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

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

Parameters

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

◆ SCIPsortReal()

void SCIPsortReal	(	SCIP_Real *	realarray,
		int	len
	)

sort an array of Reals in non-decreasing order

Parameters

realarray	SCIP_Real array to be sorted
len	length of arrays

Referenced by checkDivingCandidates().

◆ SCIPsortRealPtr()

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

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

Parameters

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

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

◆ SCIPsortRealInt()

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

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

Parameters

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

Referenced by cancelCol(), combineCols(), computeFixingOrder(), detectParallelCols(), executeHeuristic(), getFeasibleSet(), getLiftingSequenceGUB(), getOptimalShiftingValue(), initRest(), roundPartition(), SCIP_DECL_HEUREXEC(), SCIP_DECL_HEURINITSOL(), SCIP_DECL_PRESOLEXEC(), SCIPmatrixGetParallelCols(), SCIPmatrixGetParallelRows(), SCIPreduceMatrixSize(), sequentialUpAndDownLifting(), sortComponents(), superadditiveUpLifting(), and tightenVarsBoundsSOS1().

◆ SCIPsortRealIntInt()

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

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

Parameters

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

◆ SCIPsortRealBoolPtr()

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

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

Parameters

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

◆ SCIPsortRealIntLong()

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

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

Parameters

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

◆ SCIPsortRealIntPtr()

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

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

Parameters

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

Referenced by checkSystemGF2().

◆ SCIPsortRealRealPtr()

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

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

Parameters

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

◆ SCIPsortRealPtrPtrInt()

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

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

Parameters

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

Referenced by optimize(), and SCIPcreateConsCardinality().

◆ SCIPsortRealPtrPtrIntInt()

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

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

Parameters

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

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

◆ SCIPsortRealLongRealInt()

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

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

Parameters

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

◆ SCIPsortRealRealIntInt()

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

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

Parameters

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

Referenced by singletonColumnStuffing().

◆ SCIPsortRealRealRealInt()

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

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

Parameters

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

◆ SCIPsortRealRealRealPtr()

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

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

Parameters

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

◆ SCIPsortRealRealRealBoolPtr()

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

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

Parameters

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

◆ SCIPsortRealRealRealBoolBoolPtr()

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

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

Parameters

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

◆ SCIPsortInt()

void SCIPsortInt	(	int *	intarray,
		int	len
	)

sort array of ints in non-decreasing order

Parameters

intarray	int array to be sorted
len	length of arrays

Referenced by addBranchingComplementaritiesSOS1(), computeModularity(), createCumulativeCons(), detectMinors(), determineMaxDistance(), enforceConflictgraph(), extensionOperatorSOS1(), handleNewVariableSOS1(), initConflictgraph(), isConnectedSOS1(), performImplicationGraphAnalysis(), presolRoundConssSOS1(), and vardataCreate().

◆ SCIPsortIntInt()

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

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

Parameters

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

Referenced by addGroupedEdges(), addOrDetermineEffectOfGroupedEdges(), applyRepair(), cancelRow(), checkCumulativeCondition(), chooseOrderOfGenerators(), consCheckRedundancy(), createCoverCuts(), createCoverCutsTimepoint(), createSelectedSortedEventpointsSol(), createSortedEventpoints(), createSortedEventpointsSol(), detectOrbitopalSymmetries(), dualBoundStrengthening(), findUncapacitatedArcs(), getEstPermutation(), GUBsetCalcCliquePartition(), initLP(), isDoublelLexSym(), propagateTTEF(), SCIP_DECL_CONSEXIT(), SCIP_DECL_HEUREXEC(), SCIP_DECL_PRESOLEXEC(), SCIPcomputeComponentsSym(), sortLocalRows(), SYMcheckGraphsAreIdentical(), and SYMcomputeSymmetryGenerators().

◆ SCIPsortIntPtr()

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

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

Parameters

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

Referenced by applyHeur(), assignLinking(), buildBlockGraph(), decompHorizonInitialize(), isDoublelLexSym(), SCIP_DECL_HEUREXEC(), SCIPassignDecompLinkConss(), SCIPcomputeDecompStats(), selectInitialVariableDecomposition(), and sortComponents().

◆ SCIPsortIntReal()

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

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

Parameters

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

Referenced by applyLPboundTightening(), combineCols(), roundPartition(), SCIP_DECL_PRESOLEXEC(), SCIPlpiChgSides(), SCIPnlpiOracleDelVarSet(), and sortLinearCoefficients().

◆ SCIPsortIntIntInt()

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

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

Parameters

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

Referenced by createOrDetermineSizeGraph(), createOrDetermineSizeGraphCheck(), detectOrbitopalSymmetries(), sortLocalRows(), and SYMcomputeSymmetryGenerators().

◆ SCIPsortIntIntLong()

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

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

Parameters

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

◆ SCIPsortIntRealLong()

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

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

Parameters

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

◆ SCIPsortIntIntPtr()

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

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

Parameters

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

◆ SCIPsortIntIntReal()

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

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

Parameters

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

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

◆ SCIPsortIntPtrReal()

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

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

Parameters

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

Referenced by conflictsetAddBounds().

◆ SCIPsortIntIntIntPtr()

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

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

Parameters

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

◆ SCIPsortIntIntIntReal()

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

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

Parameters

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

◆ SCIPsortIntPtrIntReal()

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

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

Parameters

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

Referenced by rowSortLP(), and rowSortNonLP().

◆ SCIPsortLong()

void SCIPsortLong	(	SCIP_Longint *	longarray,
		int	len
	)

sort an array of Longints in non-decreasing order

Parameters

longarray	SCIP_Longint array to be sorted
len	length of arrays

◆ SCIPsortLongPtr()

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

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

Parameters

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

◆ SCIPsortLongPtrInt()

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

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

Parameters

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

◆ SCIPsortLongPtrRealBool()

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

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

Parameters

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

◆ SCIPsortLongPtrRealRealBool()

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

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

Parameters

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

Referenced by detectImpliedBounds().

◆ SCIPsortLongPtrRealRealIntBool()

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

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

Parameters

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

◆ SCIPsortLongPtrPtrInt()

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

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

Parameters

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

◆ SCIPsortLongPtrPtrIntInt()

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

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

Parameters

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

◆ SCIPsortLongPtrPtrBoolInt()

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

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

Parameters

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

◆ SCIPsortPtrIntIntBoolBool()

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

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

Parameters

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

◆ SCIPsortIntPtrIntIntBoolBool()

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

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

Parameters

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

◆ SCIPsortDown()

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

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

Parameters

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

Definition at line 6077 of file misc.c.

References NULL, and SCIPsortDownInd().

Referenced by selectBranchingCandidate().

◆ SCIPsortDownInd()

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

sort an index array in non-increasing order

Parameters

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

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

◆ SCIPsortDownPtr()

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

sort of an array of pointers in non-increasing order

Parameters

ptrarray	pointer array to be sorted
len	length of array

Referenced by analyzeConflictOverload(), checkForOverlapping(), detectNlhdlr(), preprocessCliques(), propdataInit(), SCIP_DECL_CONSEXIT(), SCIP_DECL_CONSINIT(), SCIP_DECL_SORTPTRCOMP(), SCIPincludeNlhdlrNonlinear(), and SCIPnodepqClear().

◆ SCIPsortDownPtrPtr()

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

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

Parameters

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

Referenced by SCIP_DECL_DIALOGEXEC().

◆ SCIPsortDownPtrReal()

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

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

Parameters

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

◆ SCIPsortDownPtrInt()

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

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

Parameters

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

Referenced by getLiftingSequence(), and getLiftingSequenceGUB().

◆ SCIPsortDownPtrBool()

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

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

Parameters

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

◆ SCIPsortDownPtrIntInt()

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

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

Parameters

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

◆ SCIPsortDownPtrRealInt()

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

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

Parameters

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

◆ SCIPsortDownPtrRealBool()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrInt()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrReal()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrIntInt()

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

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

Parameters

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

◆ SCIPsortDownPtrRealIntInt()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrRealInt()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrRealBool()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrLongInt()

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

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

Parameters

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

◆ SCIPsortDownPtrPtrLongIntInt()

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

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

Parameters

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

◆ SCIPsortDownReal()

void SCIPsortDownReal	(	SCIP_Real *	realarray,
		int	len
	)

sort an array of Reals in non-increasing order

Parameters

realarray	SCIP_Real array to be sorted
len	length of arrays

Referenced by computeLiftingData().

◆ SCIPsortDownRealPtr()

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

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

Parameters

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

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

◆ SCIPsortDownRealInt()

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

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

Parameters

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

Referenced by aggregateNextRow(), changePartitionCovervars(), changePartitionFeasiblesetvars(), computeFixingOrder(), computeInitialKnapsackCover(), dataReset(), DECL_VARFIXINGS(), getBranchingDecisionStrongbranchSOS1(), getInferenceOrder(), getLiftingSequence(), getLiftingSequenceGUB(), greedyStableSet(), insertSortedRootNeighbors(), maxWeightIndSetHeuristic(), prepareLiftingData(), SCIP_DECL_HEUREXEC(), SCIP_DECL_SEPAEXECLP(), separateCuts(), solvePricingHeuristic(), sortIDs(), sortNodes(), superadditiveUpLifting(), and tightenVarsBoundsSOS1().

◆ SCIPsortDownRealIntInt()

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

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

Parameters

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

Referenced by SCIPverifyCircularPatternHeuristic().

◆ SCIPsortDownRealBoolPtr()

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

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

Parameters

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

◆ SCIPsortDownRealIntLong()

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

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

Parameters

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

Referenced by SCIPsolveKnapsackExactly().

◆ SCIPsortDownRealIntPtr()

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

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

Parameters

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

Referenced by applyNlobbt().

◆ SCIPsortDownRealRealInt()

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

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

Parameters

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

Referenced by SCIP_DECL_READERREAD(), SCIPcutGenerationHeuristicCMIR(), and SCIPcutsTightenCoefficients().

◆ SCIPsortDownRealRealPtr()

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

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

Parameters

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

Referenced by computeRanks(), and rowprepCleanupSortTerms().

◆ SCIPsortDownRealRealPtrPtr()

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

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

Parameters

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

◆ SCIPsortDownRealPtrPtrInt()

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

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

Parameters

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

◆ SCIPsortDownRealPtrPtrIntInt()

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

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

Parameters

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

◆ SCIPsortDownRealLongRealInt()

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

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

Parameters

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

◆ SCIPsortDownRealRealIntInt()

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

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

Parameters

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

Referenced by separateCuts().

◆ SCIPsortDownRealRealRealInt()

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

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

Parameters

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

◆ SCIPsortDownRealRealRealPtr()

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

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

Parameters

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

◆ SCIPsortDownRealPtrPtr()

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

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

Parameters

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

◆ SCIPsortDownRealRealRealBoolPtr()

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

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

Parameters

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

Referenced by SCIP_DECL_HEUREXEC().

◆ SCIPsortDownRealRealRealBoolBoolPtr()

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

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

Parameters

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

◆ SCIPsortDownInt()

void SCIPsortDownInt	(	int *	intarray,
		int	len
	)

sort array of ints in non-increasing order

Parameters

intarray	int array to be sorted
len	length of arrays

Referenced by COLORprobStableSetIsNew(), constructSNFRelaxation(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), SCIP_DECL_HEUREXEC(), SCIP_DECL_PRICERFARKAS(), and SCIP_DECL_READERREAD().

◆ SCIPsortDownIntInt()

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

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

Parameters

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

Referenced by getLctPermuataion(), greedyStableSet(), presolRoundConssSOS1(), resolvePropagationCoretimes(), SCIP_DECL_HEUREXEC(), and SCIPcreateWorstCaseProfile().

◆ SCIPsortDownIntPtr()

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

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

Parameters

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

Referenced by getFactorizedBinaryQuadraticExpr().

◆ SCIPsortDownIntReal()

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

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

Parameters

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

◆ SCIPsortDownIntIntInt()

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

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

Parameters

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

Referenced by analyzeEnergyRequirement().

◆ SCIPsortDownIntIntLong()

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

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

Parameters

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

◆ SCIPsortDownIntIntPtr()

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

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

Parameters

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

◆ SCIPsortDownIntIntReal()

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

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

Parameters

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

◆ SCIPsortDownIntIntIntPtr()

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

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

Parameters

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

◆ SCIPsortDownIntIntIntReal()

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

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

Parameters

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

◆ SCIPsortDownIntPtrIntReal()

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

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

Parameters

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

◆ SCIPsortDownLong()

void SCIPsortDownLong	(	SCIP_Longint *	longarray,
		int	len
	)

sort an array of Longints in non-increasing order

Parameters

longarray	SCIP_Longint array to be sorted
len	length of arrays

◆ SCIPsortDownLongPtr()

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

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

Parameters

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

Referenced by greedyCliqueAlgorithm().

◆ SCIPsortDownLongPtrInt()

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

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

Parameters

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

◆ SCIPsortDownLongPtrRealBool()

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

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

Parameters

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

◆ SCIPsortDownLongPtrRealRealBool()

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

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

Parameters

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

◆ SCIPsortDownLongPtrRealRealIntBool()

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

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

Parameters

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

◆ SCIPsortDownLongPtrPtrInt()

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

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

Parameters

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

◆ SCIPsortDownLongPtrPtrIntInt()

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

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

Parameters

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

◆ SCIPsortDownLongPtrPtrBoolInt()

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

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

Parameters

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

◆ SCIPsortDownPtrIntIntBoolBool()

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

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

Parameters

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

◆ SCIPsortDownIntPtrIntIntBoolBool()

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

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

Parameters

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

◆ SCIPsortedvecInsertInd()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtr()

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

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

Parameters

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

Referenced by addNodesInformation(), and SCIPdialogAddEntry().

◆ SCIPsortedvecInsertPtrPtr()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrReal()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrBool()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrRealInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrRealRealInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrRealRealBoolBool()

void SCIPsortedvecInsertPtrRealRealBoolBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		SCIP_Bool	field4val,
		int *	len,
		int *	pos
	)

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

Parameters

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

◆ SCIPsortedvecInsertPtrRealRealIntBool()

void SCIPsortedvecInsertPtrRealRealIntBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		int	field3val,
		SCIP_Bool	field4val,
		int *	len,
		int *	pos
	)

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

Parameters

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

◆ SCIPsortedvecInsertPtrRealBool()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrReal()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrRealIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrRealInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrRealBool()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrLongInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertPtrPtrLongIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealBoolPtr()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealPtr()

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

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

Parameters

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

Referenced by SCIPvaluehistoryFind().

◆ SCIPsortedvecInsertReal()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealIntLong()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealIntPtr()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealRealPtr()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealPtrPtrInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealPtrPtrIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealLongRealInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealRealIntInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealRealRealInt()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealRealRealPtr()

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

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

Parameters

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

◆ SCIPsortedvecInsertRealRealRealBoolPtr()

void SCIPsortedvecInsertRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		void *	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters

realarray1	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
realarray3	third SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertRealRealRealBoolBoolPtr()

void SCIPsortedvecInsertRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		SCIP_Bool	field4val,
		void *	field5val,
		int *	len,
		int *	pos
	)

insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

Parameters

realarray1	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
realarray3	third SCIP_Real array where an element is to be inserted
boolarray1	SCIP_Bool array where an element is to be inserted
boolarray2	SCIP_Bool array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
field5val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertInt()

void SCIPsortedvecInsertInt	(	int *	intarray,
		int	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an array of ints in non-decreasing order

Parameters

intarray	int array where an element is to be inserted
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

Referenced by hessLagSparsitySetNzFlagForExpr().

◆ SCIPsortedvecInsertIntInt()

void SCIPsortedvecInsertIntInt	(	int *	intarray1,
		int *	intarray2,
		int	keyval,
		int	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

Referenced by profileInsertTimepoint().

◆ SCIPsortedvecInsertIntPtr()

void SCIPsortedvecInsertIntPtr	(	int *	intarray,
		void **	ptrarray,
		int	keyval,
		void *	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntReal()

void SCIPsortedvecInsertIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		int	keyval,
		SCIP_Real	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be inserted
realarray	real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntIntInt()

void SCIPsortedvecInsertIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		int	keyval,
		int	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
intarray3	third int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntIntLong()

void SCIPsortedvecInsertIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		int	keyval,
		int	field1val,
		SCIP_Longint	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
longarray	SCIP_Longint array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntRealLong()

void SCIPsortedvecInsertIntRealLong	(	int *	intarray,
		SCIP_Real *	realarray,
		SCIP_Longint *	longarray,
		int	keyval,
		SCIP_Real	field1val,
		SCIP_Longint	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be inserted
realarray	SCIP_Real where an element is to be inserted
longarray	SCIP_Longint array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntIntPtr()

void SCIPsortedvecInsertIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		int	keyval,
		int	field1val,
		void *	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

Parameters

intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntIntReal()

void SCIPsortedvecInsertIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	keyval,
		int	field1val,
		SCIP_Real	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order

Parameters

intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
realarray	real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntPtrReal()

void SCIPsortedvecInsertIntPtrReal	(	int *	intarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		int	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

Referenced by conflictsetAddBound().

◆ SCIPsortedvecInsertIntIntIntPtr()

void SCIPsortedvecInsertIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		int	keyval,
		int	field1val,
		int	field2val,
		void *	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

Parameters

intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
intarray3	second int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntIntIntReal()

void SCIPsortedvecInsertIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		int	keyval,
		int	field1val,
		int	field2val,
		SCIP_Real	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

Parameters

intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
intarray3	second int array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntPtrIntReal()

void SCIPsortedvecInsertIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	keyval,
		void *	field1val,
		int	field2val,
		SCIP_Real	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order

Parameters

intarray1	first int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
intarray2	second int array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLong()

void SCIPsortedvecInsertLong	(	SCIP_Longint *	longarray,
		SCIP_Longint	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an array of Longints, sorted in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtr()

void SCIPsortedvecInsertLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Longint	keyval,
		void *	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrInt()

void SCIPsortedvecInsertLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		SCIP_Longint	keyval,
		void *	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrRealBool()

void SCIPsortedvecInsertLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_Longint	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrRealRealBool()

void SCIPsortedvecInsertLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		SCIP_Longint	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Real	field3val,
		SCIP_Bool	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrRealRealIntBool()

void SCIPsortedvecInsertLongPtrRealRealIntBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_Longint	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Real	field3val,
		int	field4val,
		SCIP_Bool	field5val,
		int *	len,
		int *	pos
	)

insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
field5val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrPtrInt()

void SCIPsortedvecInsertLongPtrPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Longint	keyval,
		void *	field1val,
		void *	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrPtrIntInt()

void SCIPsortedvecInsertLongPtrPtrIntInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Longint	keyval,
		void *	field1val,
		void *	field2val,
		int	field3val,
		int	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertLongPtrPtrBoolInt()

void SCIPsortedvecInsertLongPtrPtrBoolInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Bool *	boolarray,
		int *	intarray,
		SCIP_Longint	keyval,
		void *	field1val,
		void *	field2val,
		SCIP_Bool	field3val,
		int	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
intarray	int array to be sorted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertPtrIntIntBoolBool()

void SCIPsortedvecInsertPtrIntIntBoolBool	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		int	field1val,
		int	field2val,
		SCIP_Bool	field3val,
		SCIP_Bool	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array to be sorted
intarray1	first int array to be permuted in the same way
intarray2	second int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertIntPtrIntIntBoolBool()

void SCIPsortedvecInsertIntPtrIntIntBoolBool	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		int *	intarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		int	keyval,
		void *	field1val,
		int	field2val,
		int	field3val,
		SCIP_Bool	field4val,
		SCIP_Bool	field5val,
		int *	len,
		int *	pos
	)

insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order

Parameters

intarray1	int array to be sorted
ptrarray	pointer array to be permuted in the same way
intarray2	second int array to be permuted in the same way
intarray3	thrid int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
field5val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownInd()

void SCIPsortedvecInsertDownInd	(	int *	indarray,
		SCIP_DECL_SORTINDCOMP((*indcomp))	,
		void *	dataptr,
		int	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an index array in non-increasing order

Parameters

indarray	pointer to the index array where an element is to be inserted
dataptr	pointer to data field that is given to the external compare method
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtr()

void SCIPsortedvecInsertDownPtr	(	void **	ptrarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an array of pointers in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

Referenced by addCliqueDataEntry().

◆ SCIPsortedvecInsertDownPtrPtr()

void SCIPsortedvecInsertDownPtrPtr	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrReal()

void SCIPsortedvecInsertDownPtrReal	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Real	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrInt()

void SCIPsortedvecInsertDownPtrInt	(	void **	ptrarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		int	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrBool()

void SCIPsortedvecInsertDownPtrBool	(	void **	ptrarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Bool	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrIntInt()

void SCIPsortedvecInsertDownPtrIntInt	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		int	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrRealInt()

void SCIPsortedvecInsertDownPtrRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Real	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrRealBool()

void SCIPsortedvecInsertDownPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Real	field1val,
		SCIP_Bool	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrInt()

void SCIPsortedvecInsertDownPtrPtrInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrReal()

void SCIPsortedvecInsertDownPtrPtrReal	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrIntInt()

void SCIPsortedvecInsertDownPtrPtrIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		int	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrRealIntInt()

void SCIPsortedvecInsertDownPtrRealIntInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		SCIP_Real	field1val,
		int	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrRealInt()

void SCIPsortedvecInsertDownPtrPtrRealInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrRealBool()

void SCIPsortedvecInsertDownPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrLongInt()

void SCIPsortedvecInsertDownPtrPtrLongInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		SCIP_Longint	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
longarray	SCIP_Longint array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrPtrLongIntInt()

void SCIPsortedvecInsertDownPtrPtrLongIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		void *	field1val,
		SCIP_Longint	field2val,
		int	field3val,
		int	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
longarray	SCIP_Longint array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownReal()

void SCIPsortedvecInsertDownReal	(	SCIP_Real *	realarray,
		SCIP_Real	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an array of Reals, sorted in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealBoolPtr()

void SCIPsortedvecInsertDownRealBoolPtr	(	SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Bool	field1val,
		void *	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
ptrarray	pointer array to be permuted in the same way
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealPtr()

void SCIPsortedvecInsertDownRealPtr	(	SCIP_Real *	realarray,
		void **	ptrarray,
		SCIP_Real	keyval,
		void *	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealPtrPtr()

void SCIPsortedvecInsertDownRealPtrPtr	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real	keyval,
		void *	field1val,
		void *	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealInt()

void SCIPsortedvecInsertDownRealInt	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Real	keyval,
		int	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealIntInt()

void SCIPsortedvecInsertDownRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real	keyval,
		int	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
intarray1	int array where an element is to be inserted
intarray2	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealInt()

void SCIPsortedvecInsertDownRealRealInt	(	SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
realarray2	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealIntLong()

void SCIPsortedvecInsertDownRealIntLong	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Longint *	longarray,
		SCIP_Real	keyval,
		int	field1val,
		SCIP_Longint	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array to be sorted
intarray	int array to be permuted in the same way
longarray	SCIP_Longint array to be permuted in the same way
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealIntPtr()

void SCIPsortedvecInsertDownRealIntPtr	(	SCIP_Real *	realarray,
		int *	intarray,
		void **	ptrarray,
		SCIP_Real	keyval,
		int	field1val,
		void *	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealPtr()

void SCIPsortedvecInsertDownRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		void *	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order

Parameters

realarray1	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealPtrPtr()

void SCIPsortedvecInsertDownRealRealPtrPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		void *	field2val,
		void *	field3val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order

Parameters

realarray1	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
ptrarray1	pointer array where an element is to be inserted
ptrarray2	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealPtrPtrInt()

void SCIPsortedvecInsertDownRealPtrPtrInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Real	keyval,
		void *	field1val,
		void *	field2val,
		int	intval,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
ptrarray1	pointer array where an element is to be inserted
ptrarray2	pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
intval	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealPtrPtrIntInt()

void SCIPsortedvecInsertDownRealPtrPtrIntInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real	keyval,
		void *	field1val,
		void *	field2val,
		int	intval1,
		int	intval2,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be inserted
ptrarray1	pointer array where an element is to be inserted
ptrarray2	pointer array where an element is to be inserted
intarray1	int array where an element is to be inserted
intarray2	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
intval1	additional value of new element
intval2	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealLongRealInt()

void SCIPsortedvecInsertDownRealLongRealInt	(	SCIP_Real *	realarray1,
		SCIP_Longint *	longarray,
		SCIP_Real *	realarray3,
		int *	intarray,
		SCIP_Real	keyval,
		SCIP_Longint	field1val,
		SCIP_Real	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order

Parameters

realarray1	SCIP_Real array where an element is to be inserted
longarray	SCIP_Longint array where an element is to be inserted
realarray3	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealIntInt()

void SCIPsortedvecInsertDownRealRealIntInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		int	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order

Parameters

realarray1	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealRealInt()

void SCIPsortedvecInsertDownRealRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		int *	intarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order

Parameters

realarray1	SCIP_Real array where an element is to be inserted
realarray2	SCIP_Real array where an element is to be inserted
realarray3	SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealRealPtr()

void SCIPsortedvecInsertDownRealRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		void *	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order

Parameters

realarray1	SCIP_Real array where an element is to be inserted
realarray2	SCIP_Real array where an element is to be inserted
realarray3	SCIP_Real array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealRealBoolPtr()

void SCIPsortedvecInsertDownRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		void *	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order

Parameters

realarray1	SCIP_Real array where an element is to be inserted
realarray2	SCIP_Real array where an element is to be inserted
realarray3	SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownRealRealRealBoolBoolPtr()

void SCIPsortedvecInsertDownRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		SCIP_Real	keyval,
		SCIP_Real	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		SCIP_Bool	field4val,
		void *	field5val,
		int *	len,
		int *	pos
	)

insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order

Parameters

realarray1	SCIP_Real array where an element is to be inserted
realarray2	SCIP_Real array where an element is to be inserted
realarray3	SCIP_Real array where an element is to be inserted
boolarray1	SCIP_Bool array where an element is to be inserted
boolarray2	SCIP_Bool array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
field5val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownInt()

void SCIPsortedvecInsertDownInt	(	int *	intarray,
		int	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an array of ints in non-increasing order

Parameters

intarray	int array where an element is to be inserted
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntInt()

void SCIPsortedvecInsertDownIntInt	(	int *	intarray1,
		int *	intarray2,
		int	keyval,
		int	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntReal()

void SCIPsortedvecInsertDownIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		int	keyval,
		SCIP_Real	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order

Parameters

intarray	int array where an element is to be inserted
realarray	real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntIntInt()

void SCIPsortedvecInsertDownIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		int	keyval,
		int	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
intarray3	third int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntIntLong()

void SCIPsortedvecInsertDownIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		int	keyval,
		int	field1val,
		SCIP_Longint	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
longarray	SCIP_Longint array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntIntPtr()

void SCIPsortedvecInsertDownIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		int	keyval,
		int	field1val,
		void *	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntIntReal()

void SCIPsortedvecInsertDownIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	keyval,
		int	field1val,
		SCIP_Real	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
realarray	real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntPtr()

void SCIPsortedvecInsertDownIntPtr	(	int *	intarray,
		void **	ptrarray,
		int	keyval,
		void *	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order

Parameters

intarray	int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntIntIntPtr()

void SCIPsortedvecInsertDownIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		int	keyval,
		int	field1val,
		int	field2val,
		void *	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	int array where an element is to be inserted
intarray3	int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntIntIntReal()

void SCIPsortedvecInsertDownIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		int	keyval,
		int	field1val,
		int	field2val,
		SCIP_Real	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of ints/int/ints/reals, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
intarray2	int array where an element is to be inserted
intarray3	int array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntPtrIntReal()

void SCIPsortedvecInsertDownIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	keyval,
		void *	field1val,
		int	field2val,
		SCIP_Real	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-increasing order

Parameters

intarray1	int array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
intarray2	int array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLong()

void SCIPsortedvecInsertDownLong	(	SCIP_Longint *	longarray,
		SCIP_Longint	keyval,
		int *	len,
		int *	pos
	)

insert a new element into an array of Longints, sorted in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
keyval	key value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtr()

void SCIPsortedvecInsertDownLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Longint	keyval,
		void *	field1val,
		int *	len,
		int *	pos
	)

insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrInt()

void SCIPsortedvecInsertDownLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		SCIP_Longint	keyval,
		void *	field1val,
		int	field2val,
		int *	len,
		int *	pos
	)

insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrRealBool()

void SCIPsortedvecInsertDownLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_Longint	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Bool	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrRealRealBool()

void SCIPsortedvecInsertDownLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		SCIP_Longint	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Real	field3val,
		SCIP_Bool	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrRealRealIntBool()

void SCIPsortedvecInsertDownLongPtrRealRealIntBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_Longint	keyval,
		void *	field1val,
		SCIP_Real	field2val,
		SCIP_Real	field3val,
		int	field4val,
		SCIP_Bool	field5val,
		int *	len,
		int *	pos
	)

insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray	pointer array where an element is to be inserted
realarray	first SCIP_Real array where an element is to be inserted
realarray2	second SCIP_Real array where an element is to be inserted
intarray	int array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
field5val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrPtrInt()

void SCIPsortedvecInsertDownLongPtrPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Longint	keyval,
		void *	field1val,
		void *	field2val,
		int	field3val,
		int *	len,
		int *	pos
	)

insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrPtrIntInt()

void SCIPsortedvecInsertDownLongPtrPtrIntInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Longint	keyval,
		void *	field1val,
		void *	field2val,
		int	field3val,
		int	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
intarray1	first int array where an element is to be inserted
intarray2	second int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownLongPtrPtrBoolInt()

void SCIPsortedvecInsertDownLongPtrPtrBoolInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Bool *	boolarray,
		int *	intarray,
		SCIP_Longint	keyval,
		void *	field1val,
		void *	field2val,
		SCIP_Bool	field3val,
		int	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be inserted
ptrarray1	first pointer array where an element is to be inserted
ptrarray2	second pointer array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
intarray	int array where an element is to be inserted
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownPtrIntIntBoolBool()

void SCIPsortedvecInsertDownPtrIntIntBoolBool	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		void *	keyval,
		int	field1val,
		int	field2val,
		SCIP_Bool	field3val,
		SCIP_Bool	field4val,
		int *	len,
		int *	pos
	)

insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array to be sorted
intarray1	first int array to be permuted in the same way
intarray2	second int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecInsertDownIntPtrIntIntBoolBool()

void SCIPsortedvecInsertDownIntPtrIntIntBoolBool	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		int *	intarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		int	keyval,
		void *	field1val,
		int	field2val,
		int	field3val,
		SCIP_Bool	field4val,
		SCIP_Bool	field5val,
		int *	len,
		int *	pos
	)

insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order

Parameters

intarray1	int array to be sorted
ptrarray	pointer array to be permuted in the same way
intarray2	second int array to be permuted in the same way
intarray3	thrid int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
keyval	key value of new element
field1val	additional value of new element
field2val	additional value of new element
field3val	additional value of new element
field4val	additional value of new element
field5val	additional value of new element
len	pointer to length of arrays (will be increased by 1)
pos	pointer to store the insertion position, or NULL

◆ SCIPsortedvecDelPosInd()

void SCIPsortedvecDelPosInd	(	int *	indarray,
		SCIP_DECL_SORTINDCOMP((*indcomp))	,
		void *	dataptr,
		int	pos,
		int *	len
	)

delete the element at the given position from an index array in non-decreasing order

Parameters

indarray	pointer to the index array where an element is to be deleted
dataptr	pointer to data field that is given to the external compare method
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtr()

void SCIPsortedvecDelPosPtr	(	void **	ptrarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from an array of pointers in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

Referenced by removeNode().

◆ SCIPsortedvecDelPosPtrPtr()

void SCIPsortedvecDelPosPtrPtr	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrReal()

void SCIPsortedvecDelPosPtrReal	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrInt()

void SCIPsortedvecDelPosPtrInt	(	void **	ptrarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrBool()

void SCIPsortedvecDelPosPtrBool	(	void **	ptrarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
pos	array position of element to be deleted
len	pointer to length of arrays (will be increased by 1)

◆ SCIPsortedvecDelPosPtrIntInt()

void SCIPsortedvecDelPosPtrIntInt	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrRealInt()

void SCIPsortedvecDelPosPtrRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrRealRealInt()

void SCIPsortedvecDelPosPtrRealRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of pointers/RealsReals//ints, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrRealRealBoolBool()

void SCIPsortedvecDelPosPtrRealRealBoolBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of pointers/RealsReals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
boolarray1	SCIP_Bool array where an element is to be deleted
boolarray2	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrRealRealIntBool()

void SCIPsortedvecDelPosPtrRealRealIntBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of pointers/RealsReals/ints/SCIP_Bools, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrRealBool()

void SCIPsortedvecDelPosPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrInt()

void SCIPsortedvecDelPosPtrPtrInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrReal()

void SCIPsortedvecDelPosPtrPtrReal	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrIntInt()

void SCIPsortedvecDelPosPtrPtrIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrRealIntInt()

void SCIPsortedvecDelPosPtrRealIntInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrRealInt()

void SCIPsortedvecDelPosPtrPtrRealInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrRealBool()

void SCIPsortedvecDelPosPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrLongInt()

void SCIPsortedvecDelPosPtrPtrLongInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrPtrLongIntInt()

void SCIPsortedvecDelPosPtrPtrLongIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

deletes the element at the given position from five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealBoolPtr()

void SCIPsortedvecDelPosRealBoolPtr	(	SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters

realarray	SCIP_Real array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
ptrarray	pointer array to be permuted in the same way
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealPtr()

void SCIPsortedvecDelPosRealPtr	(	SCIP_Real *	realarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosReal()

void SCIPsortedvecDelPosReal	(	SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from an arrays of Reals, sorted in non-decreasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealInt()

void SCIPsortedvecDelPosRealInt	(	SCIP_Real *	realarray,
		int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealIntInt()

void SCIPsortedvecDelPosRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealIntLong()

void SCIPsortedvecDelPosRealIntLong	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Longint *	longarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealIntPtr()

void SCIPsortedvecDelPosRealIntPtr	(	SCIP_Real *	realarray,
		int *	intarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealRealPtr()

void SCIPsortedvecDelPosRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order

Parameters

realarray1	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealPtrPtrInt()

void SCIPsortedvecDelPosRealPtrPtrInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order

Parameters

realarray	first SCIP_Real array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealPtrPtrIntInt()

void SCIPsortedvecDelPosRealPtrPtrIntInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		int	pos,
		int *	len
	)

delete the element at the given position from five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order

Parameters

realarray	first SCIP_Real array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealLongRealInt()

void SCIPsortedvecDelPosRealLongRealInt	(	SCIP_Real *	realarray1,
		SCIP_Longint *	longarray,
		SCIP_Real *	realarray3,
		int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealRealIntInt()

void SCIPsortedvecDelPosRealRealIntInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray1,
		int *	intarray2,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealRealRealInt()

void SCIPsortedvecDelPosRealRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealRealRealPtr()

void SCIPsortedvecDelPosRealRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealRealRealBoolPtr()

void SCIPsortedvecDelPosRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosRealRealRealBoolBoolPtr()

void SCIPsortedvecDelPosRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
boolarray1	SCIP_Bool array where an element is to be deleted
boolarray2	SCIP_Bool array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosInt()

void SCIPsortedvecDelPosInt	(	int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from an array of ints in non-decreasing order

Parameters

intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntInt()

void SCIPsortedvecDelPosIntInt	(	int *	intarray1,
		int *	intarray2,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntReal()

void SCIPsortedvecDelPosIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be deleted
realarray	real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntIntInt()

void SCIPsortedvecDelPosIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
intarray3	third int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntIntLong()

void SCIPsortedvecDelPosIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntRealLong()

void SCIPsortedvecDelPosIntRealLong	(	int *	intarray,
		SCIP_Real *	realarray,
		SCIP_Longint *	longarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntIntPtr()

void SCIPsortedvecDelPosIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntIntReal()

void SCIPsortedvecDelPosIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
realarray	real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntPtr()

void SCIPsortedvecDelPosIntPtr	(	int *	intarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntPtrReal()

void SCIPsortedvecDelPosIntPtrReal	(	int *	intarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order

Parameters

intarray	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

Referenced by conflictsetAddBound().

◆ SCIPsortedvecDelPosIntIntIntPtr()

void SCIPsortedvecDelPosIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
intarray3	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntIntIntReal()

void SCIPsortedvecDelPosIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
intarray3	int array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntPtrIntReal()

void SCIPsortedvecDelPosIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
intarray2	int array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLong()

void SCIPsortedvecDelPosLong	(	SCIP_Longint *	longarray,
		int	pos,
		int *	len
	)

delete the element at the given position from an array of Longints, sorted by in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtr()

void SCIPsortedvecDelPosLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrInt()

void SCIPsortedvecDelPosLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrRealBool()

void SCIPsortedvecDelPosLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrRealRealBool()

void SCIPsortedvecDelPosLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		int	pos,
		int *	len
	)

delete the element at the given position from five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrRealRealIntBool()

void SCIPsortedvecDelPosLongPtrRealRealIntBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		int	pos,
		int *	len
	)

delete the element at the given position from six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrPtrInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrPtrIntInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosLongPtrPtrBoolInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosPtrIntIntBoolBool()

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

ptrarray	pointer array to be sorted
intarray1	first int array to be permuted in the same way
intarray2	second int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosIntPtrIntIntBoolBool()

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

intarray1	int array to be sorted
ptrarray	pointer array to be permuted in the same way
intarray2	second int array to be permuted in the same way
intarray3	thrid int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownInd()

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

indarray	pointer to the index array where an element is to be deleted
dataptr	pointer to data field that is given to the external compare method
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtr()

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

ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtr()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrReal()

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

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrInt()

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

ptrarray	pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrBool()

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

ptrarray	pointer array where an element is to be inserted
boolarray	SCIP_Bool array where an element is to be inserted
pos	array position of element to be deleted
len	pointer to length of arrays (will be increased by 1)

◆ SCIPsortedvecDelPosDownPtrIntInt()

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

ptrarray	pointer array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrRealInt()

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

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrRealBool()

void SCIPsortedvecDelPosDownPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order

Parameters

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrInt()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrReal()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrIntInt()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrRealIntInt()

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

ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrRealInt()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrRealBool()

void SCIPsortedvecDelPosDownPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	pos,
		int *	len
	)

deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order

Parameters

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrLongInt()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrPtrLongIntInt()

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

ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownReal()

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

realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealBoolPtr()

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

realarray	SCIP_Real array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
ptrarray	pointer array to be permuted in the same way
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealPtr()

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

realarray	SCIP_Real array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealInt()

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

realarray	SCIP_Real array where an element is to be deleted
intarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealIntInt()

void SCIPsortedvecDelPosDownRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		int	pos,
		int *	len
	)

delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order

Parameters

realarray	SCIP_Real array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealIntLong()

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

realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealIntPtr()

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

realarray	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealInt()

void SCIPsortedvecDelPosDownRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order

Parameters

realarray1	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
intarray	integer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealPtr()

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

realarray1	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealPtrPtr()

void SCIPsortedvecDelPosDownRealRealPtrPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		int	pos,
		int *	len
	)

delete the element at the given position from three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order

Parameters

realarray1	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
ptrarray1	pointer array where an element is to be deleted
ptrarray2	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealPtrPtr()

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

realarray	first SCIP_Real array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealPtrPtrInt()

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

realarray	first SCIP_Real array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealPtrPtrIntInt()

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

realarray	first SCIP_Real array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealLongRealInt()

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

realarray1	SCIP_Real array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealIntInt()

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

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealRealInt()

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

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealRealPtr()

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

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealRealBoolPtr()

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

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr()

void SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order

Parameters

realarray1	SCIP_Real array where an element is to be deleted
realarray2	SCIP_Real array where an element is to be deleted
realarray3	SCIP_Real array where an element is to be deleted
boolarray1	SCIP_Bool array where an element is to be deleted
boolarray2	SCIP_Bool array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownInt()

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

intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntInt()

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

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntReal()

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

intarray	int array where an element is to be deleted
realarray	real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntIntInt()

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

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
intarray3	third int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntIntLong()

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

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntIntPtr()

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

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntIntReal()

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

intarray1	int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
realarray	real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntPtr()

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

intarray	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntIntIntPtr()

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

intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
intarray3	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntIntIntReal()

void SCIPsortedvecDelPosDownIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		int	pos,
		int *	len
	)

delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order

Parameters

intarray1	int array where an element is to be deleted
intarray2	int array where an element is to be deleted
intarray3	int array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntPtrIntReal()

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

intarray1	int array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
intarray2	int array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLong()

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

longarray	SCIP_Longint array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtr()

void SCIPsortedvecDelPosDownLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int	pos,
		int *	len
	)

delete the element at the given position from two arrays of Long/pointer, sorted by the first array in non-increasing order

Parameters

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrRealBool()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrRealRealBool()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrRealRealIntBool()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray	pointer array where an element is to be deleted
realarray	first SCIP_Real array where an element is to be deleted
realarray2	second SCIP_Real array where an element is to be deleted
intarray	int array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrPtrInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrPtrIntInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
intarray1	first int array where an element is to be deleted
intarray2	second int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownLongPtrPtrBoolInt()

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

longarray	SCIP_Longint array where an element is to be deleted
ptrarray1	first pointer array where an element is to be deleted
ptrarray2	second pointer array where an element is to be deleted
boolarray	SCIP_Bool array where an element is to be deleted
intarray	int array where an element is to be deleted
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownPtrIntIntBoolBool()

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

ptrarray	pointer array to be sorted
intarray1	first int array to be permuted in the same way
intarray2	second int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecDelPosDownIntPtrIntIntBoolBool()

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

intarray1	int array to be sorted
ptrarray	pointer array to be permuted in the same way
intarray2	second int array to be permuted in the same way
intarray3	thrid int array to be permuted in the same way
boolarray1	first SCIP_Bool array to be permuted in the same way
boolarray2	second SCIP_Bool array to be permuted in the same way
pos	array position of element to be deleted
len	pointer to length of arrays (will be decreased by 1)

◆ SCIPsortedvecFindInd()

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

indarray	index array to be searched
dataptr	pointer to data field that is given to the external compare method
val	value to search
len	length of array
pos	pointer to store position of element

◆ SCIPsortedvecFindPtr()

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

ptrarray	pointer array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

Referenced by addAdjacentVars(), addExprViolScoresAuxVars(), addSCVarIndicator(), bilinTermAddAuxExpr(), checkSolution(), computeAndConstraintInfos(), consdataSort(), correctConshdlrdata(), dropVarEvent(), exprIsSemicontinuous(), findAggregation(), getSCVarDataInd(), implicsSearchVar(), mod2rowUnlinkCol(), nlrowSearchLinearCoef(), printNLRow(), removeNode(), SCIPcliqueAddVar(), SCIPvarGetActiveRepresentatives(), SCIPwriteOpb(), updateConsanddataUses(), varIsSemicontinuous(), vboundsSearchPos(), writeOpbObjective(), and writeOpbRelevantAnds().

◆ SCIPsortedvecFindReal()

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

realarray	SCIP_Real array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

Referenced by SCIPvaluehistoryFind().

◆ SCIPsortedvecFindInt()

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

intarray	int array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

Referenced by addRowMark(), buildBlockGraph(), checkVariable(), consdataCheck(), determineMaxDistance(), findLabelIdx(), getRowAggregationCandidates(), hessLagAddExpr(), hessLagSparsitySetNzFlagForExpr(), SCIP_DECL_NLHDLRINITSEPA(), SCIPcalcMultihashSize(), SCIPnlpiOracleChgLinearCoefs(), and SCIPprofileFindLeft().

◆ SCIPsortedvecFindLong()

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

longarray	SCIP_Longint array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

◆ SCIPsortedvecFindDownInd()

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

indarray	index array to be searched
dataptr	pointer to data field that is given to the external compare method
val	value to search
len	length of array
pos	pointer to store position of element

◆ SCIPsortedvecFindDownPtr()

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

ptrarray	pointer array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

Referenced by preprocessCliques().

◆ SCIPsortedvecFindDownReal()

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

realarray	SCIP_Real array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

Referenced by computeLiftingData().

◆ SCIPsortedvecFindDownInt()

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

intarray	int array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

◆ SCIPsortedvecFindDownLong()

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

longarray	SCIP_Longint array to be searched
val	value to search
len	length of array
pos	pointer to store position of element

SCIP

Detailed Description

Functions

Function Documentation

◆ SCIP_DECL_SORTPTRCOMP()

◆ SCIP_DECL_SORTINDCOMP() [1/2]

◆ SCIP_DECL_SORTINDCOMP() [2/2]

◆ SCIPsort()

◆ SCIPsortInd()

◆ SCIPsortPtr()

◆ SCIPsortPtrPtr()

◆ SCIPsortPtrReal()

◆ SCIPsortPtrInt()

◆ SCIPsortPtrBool()

◆ SCIPsortPtrIntInt()

◆ SCIPsortPtrRealInt()

◆ SCIPsortPtrRealRealInt()

◆ SCIPsortPtrRealRealBoolBool()

◆ SCIPsortPtrRealRealIntBool()

◆ SCIPsortPtrRealBool()

◆ SCIPsortPtrRealReal()

◆ SCIPsortPtrPtrInt()

◆ SCIPsortPtrPtrReal()

◆ SCIPsortPtrPtrIntInt()

◆ SCIPsortPtrRealIntInt()

◆ SCIPsortPtrPtrRealInt()

◆ SCIPsortPtrPtrRealBool()

◆ SCIPsortPtrPtrLongInt()

◆ SCIPsortPtrPtrLongIntInt()

◆ SCIPsortReal()

◆ SCIPsortRealPtr()

◆ SCIPsortRealInt()

◆ SCIPsortRealIntInt()

◆ SCIPsortRealBoolPtr()

◆ SCIPsortRealIntLong()

◆ SCIPsortRealIntPtr()

◆ SCIPsortRealRealPtr()

◆ SCIPsortRealPtrPtrInt()

◆ SCIPsortRealPtrPtrIntInt()

◆ SCIPsortRealLongRealInt()

◆ SCIPsortRealRealIntInt()

◆ SCIPsortRealRealRealInt()

◆ SCIPsortRealRealRealPtr()

◆ SCIPsortRealRealRealBoolPtr()

◆ SCIPsortRealRealRealBoolBoolPtr()

◆ SCIPsortInt()

◆ SCIPsortIntInt()

◆ SCIPsortIntPtr()

◆ SCIPsortIntReal()

◆ SCIPsortIntIntInt()

◆ SCIPsortIntIntLong()

◆ SCIPsortIntRealLong()

◆ SCIPsortIntIntPtr()

◆ SCIPsortIntIntReal()

◆ SCIPsortIntPtrReal()

◆ SCIPsortIntIntIntPtr()

◆ SCIPsortIntIntIntReal()

◆ SCIPsortIntPtrIntReal()

◆ SCIPsortLong()

◆ SCIPsortLongPtr()

◆ SCIPsortLongPtrInt()

◆ SCIPsortLongPtrRealBool()

◆ SCIPsortLongPtrRealRealBool()

◆ SCIPsortLongPtrRealRealIntBool()

◆ SCIPsortLongPtrPtrInt()

◆ SCIPsortLongPtrPtrIntInt()

◆ SCIPsortLongPtrPtrBoolInt()

◆ SCIPsortPtrIntIntBoolBool()

◆ SCIPsortIntPtrIntIntBoolBool()

◆ SCIPsortDown()

◆ SCIPsortDownInd()

◆ SCIPsortDownPtr()

◆ SCIPsortDownPtrPtr()

◆ SCIPsortDownPtrReal()

◆ SCIPsortDownPtrInt()

◆ SCIPsortDownPtrBool()

◆ SCIPsortDownPtrIntInt()

◆ SCIPsortDownPtrRealInt()

◆ SCIPsortDownPtrRealBool()

◆ SCIPsortDownPtrPtrInt()