Detailed Description

public methods for the selection of (weighted) k-median.

The methods in this group perform a selection of the (weighted) \( k \)-median from an unsorted array of elements. The necessary element swaps are performed in-place on the array of keys. The necessary permutations are also performed on up to six associated arrays.

For methods that perform complete in place sorting, see Sorting Algorithms.

For an array a containing n elements \( a[0], ..., a[n-1] \) and an integer \( 0 \leq k \leq n - 1 \) , we call an element \( a[i] \) \( k \)-median if there exists a permutation \( \pi \) of the array indices such that \( \pi(i) = k \) and \( a[\pi^{-1}(j)] \leq a[i] \) for \( j = 0, \dots, k-1 \) and \( a[\pi^{-1}(j)] > a[i] \) for \( j = k + 1,\dots,n - 1 \). The \( k \)-median is hence an element that would appear at position \( k \) after sorting the input array. Note that there may exist several \( k \)-medians if the array elements are not unique, only its key value \( a[i] \).

In order to determine the \( k \)-median, the algorithm selects a pivot element and determines the array position for this pivot like quicksort. In contrast to quicksort, however, one recursion can be saved during the selection process. After a single iteration that placed the pivot at position \( p \) , the algorithm either terminates if \( p = k \), or it continues in the left half of the array if \( p > k \), or in the right half of the array if \( p < k \).

After the algorithm terminates, the \( k \)-median can be accessed by accessing the array element at position \( k \).

A weighted median denotes the generalization of the \( k \)-median to arbitrary, nonnegative associated weights \( w[0], \dots, w[n-1] \in \mathbb{R}\) and a capacity \( 0 \leq C \in \mathbb{R} \). An element \( a[i] \) is called weighted median if there exists a permutation that satisfies the same weak sorting as above and in addition \( W:= \sum_{j = 0}^{k - 1}w[\pi^{-1}(j)] < C\), but \( W + w[i] \geq C\). In other words, the weighted median is the first element in the weak sorting such that its weight together with the sum of all preceding item weights reach or exceed the given capacity \( C \). If all weights are equal to \( 1 \) and the capacity is \( C = k + 0.5\), the weighted median becomes the \( k \)-median.

Functions
SCIP_EXPORT void	SCIPselectInd (int indarray, SCIP_DECL_SORTINDCOMP((indcomp)), void *dataptr, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedInd (int indarray, SCIP_DECL_SORTINDCOMP((indcomp)), void dataptr, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtr (void *ptrarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtr (void *ptrarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrPtr (void ptrarray1, void ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtr (void ptrarray1, void ptrarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrReal (void *ptrarray, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrReal (void *ptrarray, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrInt (void *ptrarray, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrInt (void *ptrarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrBool (void *ptrarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrBool (void *ptrarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrIntInt (void *ptrarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrIntInt (void *ptrarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrRealInt (void *ptrarray, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrRealInt (void *ptrarray, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrRealRealInt (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

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

SCIP_EXPORT void	SCIPselectWeightedPtrRealRealInt (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectWeightedPtrRealRealIntBool (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrRealBool (void *ptrarray, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrRealBool (void *ptrarray, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrRealReal (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrRealReal (void *ptrarray, SCIP_Real realarray1, SCIP_Real realarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrInt (void ptrarray1, void ptrarray2, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrInt (void ptrarray1, void ptrarray2, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrReal (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrReal (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrIntInt (void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrIntInt (void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrRealIntInt (void *ptrarray, SCIP_Real realarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrRealIntInt (void *ptrarray, SCIP_Real realarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrRealInt (void ptrarray1, void ptrarray2, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrRealInt (void ptrarray1, void ptrarray2, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrRealBool (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrRealBool (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrLongInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrLongInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrPtrLongIntInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrPtrLongIntInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectReal (SCIP_Real *realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedReal (SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealPtr (SCIP_Real realarray, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealPtr (SCIP_Real realarray, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealInt (SCIP_Real realarray, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealInt (SCIP_Real realarray, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectRealIntInt (SCIP_Real realarray, int intarray1, int *intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealIntInt (SCIP_Real realarray, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealBoolPtr (SCIP_Real realarray, SCIP_Bool boolarray, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealBoolPtr (SCIP_Real realarray, SCIP_Bool boolarray, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealIntLong (SCIP_Real realarray, int intarray, SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealIntLong (SCIP_Real realarray, int intarray, SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealIntPtr (SCIP_Real realarray, int intarray, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealIntPtr (SCIP_Real realarray, int intarray, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealPtrPtrInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealPtrPtrInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectRealPtrPtrIntInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray1, int *intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealPtrPtrIntInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealLongRealInt (SCIP_Real realarray1, SCIP_Longint longarray, SCIP_Real realarray3, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealLongRealInt (SCIP_Real realarray1, SCIP_Longint longarray, SCIP_Real realarray3, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectRealRealIntInt (SCIP_Real realarray1, SCIP_Real realarray2, int intarray1, int intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealRealIntInt (SCIP_Real realarray1, SCIP_Real realarray2, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectRealRealRealInt (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealRealRealInt (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectRealRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealRealRealBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealRealRealBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectRealRealRealBoolBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray1, SCIP_Bool boolarray2, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedRealRealRealBoolBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray1, SCIP_Bool boolarray2, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectInt (int *intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedInt (int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntInt (int intarray1, int intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntInt (int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectIntPtr (int intarray, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntPtr (int intarray, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntReal (int intarray, SCIP_Real realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntReal (int intarray, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectIntIntInt (int intarray1, int intarray2, int *intarray3, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntIntInt (int intarray1, int intarray2, int intarray3, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntIntLong (int intarray1, int intarray2, SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntIntLong (int intarray1, int intarray2, SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntRealLong (int intarray, SCIP_Real realarray, SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntRealLong (int intarray, SCIP_Real realarray, SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntIntPtr (int intarray1, int intarray2, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntIntPtr (int intarray1, int intarray2, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntIntReal (int intarray1, int intarray2, SCIP_Real *realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntIntReal (int intarray1, int intarray2, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntPtrReal (int intarray, void ptrarray, SCIP_Real realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntPtrReal (int intarray, void ptrarray, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectIntIntIntPtr (int intarray1, int intarray2, int intarray3, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntIntIntPtr (int intarray1, int intarray2, int intarray3, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectIntIntIntReal (int intarray1, int intarray2, int intarray3, SCIP_Real realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntIntIntReal (int intarray1, int intarray2, int intarray3, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectIntPtrIntReal (int intarray1, void ptrarray, int intarray2, SCIP_Real *realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntPtrIntReal (int intarray1, void ptrarray, int intarray2, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectLong (SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLong (SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectLongPtr (SCIP_Longint longarray, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtr (SCIP_Longint longarray, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectLongPtrInt (SCIP_Longint longarray, void ptrarray, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtrInt (SCIP_Longint longarray, void ptrarray, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectLongPtrRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Bool *boolarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtrRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectLongPtrRealRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Real realarray2, SCIP_Bool boolarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtrRealRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Real realarray2, SCIP_Bool boolarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

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

SCIP_EXPORT void	SCIPselectWeightedLongPtrRealRealIntBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Real realarray2, int intarray, SCIP_Bool boolarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectLongPtrPtrInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtrPtrInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectLongPtrPtrIntInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray1, int *intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtrPtrIntInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectLongPtrPtrBoolInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, SCIP_Bool boolarray, int *intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedLongPtrPtrBoolInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, SCIP_Bool boolarray, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectPtrIntIntBoolBool (void *ptrarray, int intarray1, int intarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedPtrIntIntBoolBool (void *ptrarray, int intarray1, int intarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectIntPtrIntIntBoolBool (int intarray1, void ptrarray, int intarray2, int intarray3, SCIP_Bool boolarray1, SCIP_Bool *boolarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedIntPtrIntIntBoolBool (int intarray1, void ptrarray, int intarray2, int intarray3, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownInd (int indarray, SCIP_DECL_SORTINDCOMP((indcomp)), void *dataptr, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownInd (int indarray, SCIP_DECL_SORTINDCOMP((indcomp)), void dataptr, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtr (void *ptrarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtr (void *ptrarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtr (void ptrarray1, void ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtr (void ptrarray1, void ptrarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrReal (void *ptrarray, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrReal (void *ptrarray, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrInt (void *ptrarray, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrInt (void *ptrarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrBool (void *ptrarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrBool (void *ptrarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrIntInt (void *ptrarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrIntInt (void *ptrarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownPtrRealInt (void *ptrarray, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrRealInt (void *ptrarray, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownPtrRealBool (void *ptrarray, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrRealBool (void *ptrarray, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrInt (void ptrarray1, void ptrarray2, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrInt (void ptrarray1, void ptrarray2, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrReal (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrReal (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrIntInt (void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrIntInt (void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrRealIntInt (void *ptrarray, SCIP_Real realarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrRealIntInt (void *ptrarray, SCIP_Real realarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrRealInt (void ptrarray1, void ptrarray2, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrRealInt (void ptrarray1, void ptrarray2, SCIP_Real realarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrRealBool (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrRealBool (void ptrarray1, void ptrarray2, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrLongInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrLongInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrPtrLongIntInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrPtrLongIntInt (void ptrarray1, void ptrarray2, SCIP_Longint longarray, int intarray1, int intarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownReal (SCIP_Real *realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownReal (SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealPtr (SCIP_Real realarray, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealPtr (SCIP_Real realarray, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealInt (SCIP_Real realarray, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectDownRealIntInt (SCIP_Real realarray, int intarray1, int *intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealInt (SCIP_Real realarray, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectWeightedDownRealIntInt (SCIP_Real realarray, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealBoolPtr (SCIP_Real realarray, SCIP_Bool boolarray, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealBoolPtr (SCIP_Real realarray, SCIP_Bool boolarray, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealIntLong (SCIP_Real realarray, int intarray, SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealIntLong (SCIP_Real realarray, int intarray, SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealIntPtr (SCIP_Real realarray, int intarray, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealIntPtr (SCIP_Real realarray, int intarray, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealInt (SCIP_Real realarray1, SCIP_Real realarray2, int *intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealInt (SCIP_Real realarray1, SCIP_Real realarray2, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealPtrPtr (SCIP_Real realarray1, SCIP_Real realarray2, void ptrarray1, void ptrarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealPtrPtr (SCIP_Real realarray1, SCIP_Real realarray2, void ptrarray1, void ptrarray2, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownRealPtrPtrInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealPtrPtrInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownRealPtrPtrIntInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray1, int *intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealPtrPtrIntInt (SCIP_Real realarray, void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealLongRealInt (SCIP_Real realarray1, SCIP_Longint longarray, SCIP_Real realarray3, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealLongRealInt (SCIP_Real realarray1, SCIP_Longint longarray, SCIP_Real realarray3, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealIntInt (SCIP_Real realarray1, SCIP_Real realarray2, int intarray1, int intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealIntInt (SCIP_Real realarray1, SCIP_Real realarray2, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealRealInt (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealRealInt (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealRealPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealPtrPtr (SCIP_Real realarray, void ptrarray1, void *ptrarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealPtrPtr (SCIP_Real realarray, void ptrarray1, void ptrarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealRealBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealRealBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownRealRealRealBoolBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray1, SCIP_Bool boolarray2, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownRealRealRealBoolBoolPtr (SCIP_Real realarray1, SCIP_Real realarray2, SCIP_Real realarray3, SCIP_Bool boolarray1, SCIP_Bool boolarray2, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownInt (int *intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownInt (int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntInt (int intarray1, int intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntInt (int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownIntPtr (int intarray, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntPtr (int intarray, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntReal (int intarray, SCIP_Real realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntReal (int intarray, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownIntIntInt (int intarray1, int intarray2, int *intarray3, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntIntInt (int intarray1, int intarray2, int intarray3, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntIntLong (int intarray1, int intarray2, SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntIntLong (int intarray1, int intarray2, SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntIntPtr (int intarray1, int intarray2, void **ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntIntPtr (int intarray1, int intarray2, void *ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntIntReal (int intarray1, int intarray2, SCIP_Real *realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntIntReal (int intarray1, int intarray2, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntIntIntPtr (int intarray1, int intarray2, int intarray3, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntIntIntPtr (int intarray1, int intarray2, int intarray3, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownIntIntIntReal (int intarray1, int intarray2, int intarray3, SCIP_Real realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntIntIntReal (int intarray1, int intarray2, int intarray3, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownIntPtrIntReal (int intarray1, void ptrarray, int intarray2, SCIP_Real *realarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntPtrIntReal (int intarray1, void ptrarray, int intarray2, SCIP_Real realarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownLong (SCIP_Longint *longarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLong (SCIP_Longint longarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtr (SCIP_Longint longarray, void *ptrarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtr (SCIP_Longint longarray, void ptrarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtrInt (SCIP_Longint longarray, void ptrarray, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrInt (SCIP_Longint longarray, void ptrarray, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtrRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Bool *boolarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Bool boolarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtrRealRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Real realarray2, SCIP_Bool boolarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrRealRealBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Real realarray2, SCIP_Bool boolarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

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

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrRealRealIntBool (SCIP_Longint longarray, void ptrarray, SCIP_Real realarray, SCIP_Real realarray2, int intarray, SCIP_Bool boolarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtrPtrInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrPtrInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtrPtrIntInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray1, int *intarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrPtrIntInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, int intarray1, int intarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownLongPtrPtrBoolInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, SCIP_Bool boolarray, int *intarray, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownLongPtrPtrBoolInt (SCIP_Longint longarray, void ptrarray1, void ptrarray2, SCIP_Bool boolarray, int intarray, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

SCIP_EXPORT void	SCIPselectDownPtrIntIntBoolBool (void *ptrarray, int intarray1, int intarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownPtrIntIntBoolBool (void *ptrarray, int intarray1, int intarray2, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_DECL_SORTPTRCOMP((ptrcomp)), SCIP_Real weights, SCIP_Real capacity, int len, int medianpos)

SCIP_EXPORT void	SCIPselectDownIntPtrIntIntBoolBool (int intarray1, void ptrarray, int intarray2, int intarray3, SCIP_Bool boolarray1, SCIP_Bool *boolarray2, int k, int len)

SCIP_EXPORT void	SCIPselectWeightedDownIntPtrIntIntBoolBool (int intarray1, void ptrarray, int intarray2, int intarray3, SCIP_Bool boolarray1, SCIP_Bool boolarray2, SCIP_Real weights, SCIP_Real capacity, int len, int *medianpos)

Function Documentation

◆ SCIPselectInd()

SCIP_EXPORT void SCIPselectInd	(	int *	indarray,
		SCIP_DECL_SORTINDCOMP((*indcomp))	,
		void *	dataptr,
		int	k,
		int	len
	)

partial sort an index array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

indarray	pointer to the index array to be sorted
dataptr	pointer to data field that is given to the external compare method
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

Referenced by alnsFixMoreVariables().

◆ SCIPselectWeightedInd()

SCIP_EXPORT void SCIPselectWeightedInd	(	int *	indarray,
		SCIP_DECL_SORTINDCOMP((*indcomp))	,
		void *	dataptr,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort an index array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

indarray	pointer to the index array to be sorted
dataptr	pointer to data field that is given to the external compare method
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtr()

SCIP_EXPORT void SCIPselectPtr	(	void **	ptrarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of an array of pointers in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

Referenced by doSeparation().

◆ SCIPselectWeightedPtr()

SCIP_EXPORT void SCIPselectWeightedPtr	(	void **	ptrarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of an array of pointers in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtr()

SCIP_EXPORT void SCIPselectPtrPtr	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray1	first pointer array to be sorted
ptrarray2	second pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtr()

SCIP_EXPORT void SCIPselectWeightedPtrPtr	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray1	first pointer array to be sorted
ptrarray2	second pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrReal()

SCIP_EXPORT void SCIPselectPtrReal	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
realarray	SCIP_Real array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrReal()

SCIP_EXPORT void SCIPselectWeightedPtrReal	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
realarray	SCIP_Real array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrInt()

SCIP_EXPORT void SCIPselectPtrInt	(	void **	ptrarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
intarray	int array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrInt()

SCIP_EXPORT void SCIPselectWeightedPtrInt	(	void **	ptrarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
intarray	int array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrBool()

SCIP_EXPORT void SCIPselectPtrBool	(	void **	ptrarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrBool()

SCIP_EXPORT void SCIPselectWeightedPtrBool	(	void **	ptrarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrIntInt()

SCIP_EXPORT void SCIPselectPtrIntInt	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedPtrIntInt	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealInt()

SCIP_EXPORT void SCIPselectPtrRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrRealInt()

SCIP_EXPORT void SCIPselectWeightedPtrRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealRealInt()

SCIP_EXPORT void SCIPselectPtrRealRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectPtrRealRealIntBool()

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

partial sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrRealRealInt()

SCIP_EXPORT void SCIPselectWeightedPtrRealRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectWeightedPtrRealRealIntBool()

SCIP_EXPORT void SCIPselectWeightedPtrRealRealIntBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealBool()

SCIP_EXPORT void SCIPselectPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrRealBool()

SCIP_EXPORT void SCIPselectWeightedPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealReal()

SCIP_EXPORT void SCIPselectPtrRealReal	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrRealReal()

SCIP_EXPORT void SCIPselectWeightedPtrRealReal	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrInt()

SCIP_EXPORT void SCIPselectPtrPtrInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrInt()

SCIP_EXPORT void SCIPselectWeightedPtrPtrInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrReal()

SCIP_EXPORT void SCIPselectPtrPtrReal	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrReal()

SCIP_EXPORT void SCIPselectWeightedPtrPtrReal	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrIntInt()

SCIP_EXPORT void SCIPselectPtrPtrIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedPtrPtrIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealIntInt()

SCIP_EXPORT void SCIPselectPtrRealIntInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrRealIntInt()

SCIP_EXPORT void SCIPselectWeightedPtrRealIntInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrRealInt()

SCIP_EXPORT void SCIPselectPtrPtrRealInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrRealInt()

SCIP_EXPORT void SCIPselectWeightedPtrPtrRealInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrRealBool()

SCIP_EXPORT void SCIPselectPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrRealBool()

SCIP_EXPORT void SCIPselectWeightedPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrLongInt()

SCIP_EXPORT void SCIPselectPtrPtrLongInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrLongInt()

SCIP_EXPORT void SCIPselectWeightedPtrPtrLongInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrLongIntInt()

SCIP_EXPORT void SCIPselectPtrPtrLongIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrPtrLongIntInt()

SCIP_EXPORT void SCIPselectWeightedPtrPtrLongIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectReal()

SCIP_EXPORT void SCIPselectReal	(	SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort an array of Reals in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedReal()

SCIP_EXPORT void SCIPselectWeightedReal	(	SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort an array of Reals in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

Referenced by solveSingleRowLP().

◆ SCIPselectRealPtr()

SCIP_EXPORT void SCIPselectRealPtr	(	SCIP_Real *	realarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
ptrarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealPtr()

SCIP_EXPORT void SCIPselectWeightedRealPtr	(	SCIP_Real *	realarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
ptrarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealInt()

SCIP_EXPORT void SCIPselectRealInt	(	SCIP_Real *	realarray,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
intarray	int array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealInt()

SCIP_EXPORT void SCIPselectWeightedRealInt	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
intarray	int array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealIntInt()

SCIP_EXPORT void SCIPselectRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealIntInt()

SCIP_EXPORT void SCIPselectWeightedRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealBoolPtr()

SCIP_EXPORT void SCIPselectRealBoolPtr	(	SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealBoolPtr()

SCIP_EXPORT void SCIPselectWeightedRealBoolPtr	(	SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealIntLong()

SCIP_EXPORT void SCIPselectRealIntLong	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealIntLong()

SCIP_EXPORT void SCIPselectWeightedRealIntLong	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealIntPtr()

SCIP_EXPORT void SCIPselectRealIntPtr	(	SCIP_Real *	realarray,
		int *	intarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealIntPtr()

SCIP_EXPORT void SCIPselectWeightedRealIntPtr	(	SCIP_Real *	realarray,
		int *	intarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealPtr()

SCIP_EXPORT void SCIPselectRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealRealPtr()

SCIP_EXPORT void SCIPselectWeightedRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealPtrPtrInt()

SCIP_EXPORT void SCIPselectRealPtrPtrInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealPtrPtrInt()

SCIP_EXPORT void SCIPselectWeightedRealPtrPtrInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealPtrPtrIntInt()

SCIP_EXPORT void SCIPselectRealPtrPtrIntInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealPtrPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedRealPtrPtrIntInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealLongRealInt()

SCIP_EXPORT void SCIPselectRealLongRealInt	(	SCIP_Real *	realarray1,
		SCIP_Longint *	longarray,
		SCIP_Real *	realarray3,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealLongRealInt()

SCIP_EXPORT void SCIPselectWeightedRealLongRealInt	(	SCIP_Real *	realarray1,
		SCIP_Longint *	longarray,
		SCIP_Real *	realarray3,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealIntInt()

SCIP_EXPORT void SCIPselectRealRealIntInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealRealIntInt()

SCIP_EXPORT void SCIPselectWeightedRealRealIntInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealInt()

SCIP_EXPORT void SCIPselectRealRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealRealRealInt()

SCIP_EXPORT void SCIPselectWeightedRealRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealPtr()

SCIP_EXPORT void SCIPselectRealRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealRealRealPtr()

SCIP_EXPORT void SCIPselectWeightedRealRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealBoolPtr()

SCIP_EXPORT void SCIPselectRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealRealRealBoolPtr()

SCIP_EXPORT void SCIPselectWeightedRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealBoolBoolPtr()

SCIP_EXPORT void SCIPselectRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedRealRealRealBoolBoolPtr()

SCIP_EXPORT void SCIPselectWeightedRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectInt()

SCIP_EXPORT void SCIPselectInt	(	int *	intarray,
		int	k,
		int	len
	)

partial sort array of ints in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedInt()

SCIP_EXPORT void SCIPselectWeightedInt	(	int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort array of ints in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntInt()

SCIP_EXPORT void SCIPselectIntInt	(	int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray1	int array to be sorted
intarray2	second int array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntInt()

SCIP_EXPORT void SCIPselectWeightedIntInt	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray1	int array to be sorted
intarray2	second int array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtr()

SCIP_EXPORT void SCIPselectIntPtr	(	int *	intarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
ptrarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntPtr()

SCIP_EXPORT void SCIPselectWeightedIntPtr	(	int *	intarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
ptrarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntReal()

SCIP_EXPORT void SCIPselectIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
realarray	real array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntReal()

SCIP_EXPORT void SCIPselectWeightedIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
realarray	real array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntInt()

SCIP_EXPORT void SCIPselectIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntIntInt()

SCIP_EXPORT void SCIPselectWeightedIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntLong()

SCIP_EXPORT void SCIPselectIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntIntLong()

SCIP_EXPORT void SCIPselectWeightedIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntRealLong()

SCIP_EXPORT void SCIPselectIntRealLong	(	int *	intarray,
		SCIP_Real *	realarray,
		SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntRealLong()

SCIP_EXPORT void SCIPselectWeightedIntRealLong	(	int *	intarray,
		SCIP_Real *	realarray,
		SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntPtr()

SCIP_EXPORT void SCIPselectIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntIntPtr()

SCIP_EXPORT void SCIPselectWeightedIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntReal()

SCIP_EXPORT void SCIPselectIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntIntReal()

SCIP_EXPORT void SCIPselectWeightedIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtrReal()

SCIP_EXPORT void SCIPselectIntPtrReal	(	int *	intarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntPtrReal()

SCIP_EXPORT void SCIPselectWeightedIntPtrReal	(	int *	intarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntIntPtr()

SCIP_EXPORT void SCIPselectIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntIntIntPtr()

SCIP_EXPORT void SCIPselectWeightedIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntIntReal()

SCIP_EXPORT void SCIPselectIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntIntIntReal()

SCIP_EXPORT void SCIPselectWeightedIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtrIntReal()

SCIP_EXPORT void SCIPselectIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntPtrIntReal()

SCIP_EXPORT void SCIPselectWeightedIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLong()

SCIP_EXPORT void SCIPselectLong	(	SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort an array of Longints in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLong()

SCIP_EXPORT void SCIPselectWeightedLong	(	SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort an array of Longints in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtr()

SCIP_EXPORT void SCIPselectLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
ptrarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtr()

SCIP_EXPORT void SCIPselectWeightedLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
ptrarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrInt()

SCIP_EXPORT void SCIPselectLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrInt()

SCIP_EXPORT void SCIPselectWeightedLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrRealBool()

SCIP_EXPORT void SCIPselectLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		int	k,
		int	len
	)

partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrRealBool()

SCIP_EXPORT void SCIPselectWeightedLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrRealRealBool()

SCIP_EXPORT void SCIPselectLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		int	k,
		int	len
	)

partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrRealRealBool()

SCIP_EXPORT void SCIPselectWeightedLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrRealRealIntBool()

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

partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrRealRealIntBool()

SCIP_EXPORT void SCIPselectWeightedLongPtrRealRealIntBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrPtrInt()

SCIP_EXPORT void SCIPselectLongPtrPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrPtrInt()

SCIP_EXPORT void SCIPselectWeightedLongPtrPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrPtrIntInt()

SCIP_EXPORT void SCIPselectLongPtrPtrIntInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedLongPtrPtrIntInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrPtrBoolInt()

SCIP_EXPORT void SCIPselectLongPtrPtrBoolInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Bool *	boolarray,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedLongPtrPtrBoolInt()

SCIP_EXPORT void SCIPselectWeightedLongPtrPtrBoolInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Bool *	boolarray,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectPtrIntIntBoolBool	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectWeightedPtrIntIntBoolBool	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectIntPtrIntIntBoolBool	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		int *	intarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		int	k,
		int	len
	)

partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedIntPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectWeightedIntPtrIntIntBoolBool	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		int *	intarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownInd()

SCIP_EXPORT void SCIPselectDownInd	(	int *	indarray,
		SCIP_DECL_SORTINDCOMP((*indcomp))	,
		void *	dataptr,
		int	k,
		int	len
	)

partial sort an index array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

indarray	pointer to the index array to be sorted
dataptr	pointer to data field that is given to the external compare method
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

Referenced by alnsUnfixVariables().

◆ SCIPselectWeightedDownInd()

SCIP_EXPORT void SCIPselectWeightedDownInd	(	int *	indarray,
		SCIP_DECL_SORTINDCOMP((*indcomp))	,
		void *	dataptr,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort an index array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

indarray	pointer to the index array to be sorted
dataptr	pointer to data field that is given to the external compare method
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtr()

SCIP_EXPORT void SCIPselectDownPtr	(	void **	ptrarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of an array of pointers in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtr()

SCIP_EXPORT void SCIPselectWeightedDownPtr	(	void **	ptrarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of an array of pointers in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtr()

SCIP_EXPORT void SCIPselectDownPtrPtr	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray1	first pointer array to be sorted
ptrarray2	second pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtr()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtr	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray1	first pointer array to be sorted
ptrarray2	second pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrReal()

SCIP_EXPORT void SCIPselectDownPtrReal	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
realarray	SCIP_Real array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrReal()

SCIP_EXPORT void SCIPselectWeightedDownPtrReal	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
realarray	SCIP_Real array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrInt()

SCIP_EXPORT void SCIPselectDownPtrInt	(	void **	ptrarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
intarray	int array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrInt	(	void **	ptrarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
intarray	int array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrBool()

SCIP_EXPORT void SCIPselectDownPtrBool	(	void **	ptrarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrBool()

SCIP_EXPORT void SCIPselectWeightedDownPtrBool	(	void **	ptrarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
boolarray	SCIP_Bool array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrIntInt()

SCIP_EXPORT void SCIPselectDownPtrIntInt	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrIntInt	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrRealInt()

SCIP_EXPORT void SCIPselectDownPtrRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrRealInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrRealInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrRealBool()

SCIP_EXPORT void SCIPselectDownPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrRealBool()

SCIP_EXPORT void SCIPselectWeightedDownPtrRealBool	(	void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrInt()

SCIP_EXPORT void SCIPselectDownPtrPtrInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrReal()

SCIP_EXPORT void SCIPselectDownPtrPtrReal	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrReal()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrReal	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrIntInt()

SCIP_EXPORT void SCIPselectDownPtrPtrIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrRealIntInt()

SCIP_EXPORT void SCIPselectDownPtrRealIntInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrRealIntInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrRealIntInt	(	void **	ptrarray,
		SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrRealInt()

SCIP_EXPORT void SCIPselectDownPtrPtrRealInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrRealInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrRealInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrRealBool()

SCIP_EXPORT void SCIPselectDownPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrRealBool()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrRealBool	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrLongInt()

SCIP_EXPORT void SCIPselectDownPtrPtrLongInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrLongInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrLongInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrLongIntInt()

SCIP_EXPORT void SCIPselectDownPtrPtrLongIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrPtrLongIntInt()

SCIP_EXPORT void SCIPselectWeightedDownPtrPtrLongIntInt	(	void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Longint *	longarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownReal()

SCIP_EXPORT void SCIPselectDownReal	(	SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort an array of Reals in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownReal()

SCIP_EXPORT void SCIPselectWeightedDownReal	(	SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort an array of Reals in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtr()

SCIP_EXPORT void SCIPselectDownRealPtr	(	SCIP_Real *	realarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
ptrarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealPtr	(	SCIP_Real *	realarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
ptrarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealInt()

SCIP_EXPORT void SCIPselectDownRealInt	(	SCIP_Real *	realarray,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
intarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

Referenced by SCIPsolveConcurrent().

◆ SCIPselectDownRealIntInt()

SCIP_EXPORT void SCIPselectDownRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real 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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealInt()

SCIP_EXPORT void SCIPselectWeightedDownRealInt	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real array to be sorted
intarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectWeightedDownRealIntInt()

SCIP_EXPORT void SCIPselectWeightedDownRealIntInt	(	SCIP_Real *	realarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

realarray	SCIP_Real 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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealBoolPtr()

SCIP_EXPORT void SCIPselectDownRealBoolPtr	(	SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealBoolPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealBoolPtr	(	SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealIntLong()

SCIP_EXPORT void SCIPselectDownRealIntLong	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealIntLong()

SCIP_EXPORT void SCIPselectWeightedDownRealIntLong	(	SCIP_Real *	realarray,
		int *	intarray,
		SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealIntPtr()

SCIP_EXPORT void SCIPselectDownRealIntPtr	(	SCIP_Real *	realarray,
		int *	intarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealIntPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealIntPtr	(	SCIP_Real *	realarray,
		int *	intarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealInt()

SCIP_EXPORT void SCIPselectDownRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealInt()

SCIP_EXPORT void SCIPselectWeightedDownRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

Referenced by SCIPsolveKnapsackApproximatelyLT().

◆ SCIPselectDownRealRealPtr()

SCIP_EXPORT void SCIPselectDownRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealPtrPtr()

SCIP_EXPORT void SCIPselectDownRealRealPtrPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order around the k-th element

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealPtrPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealRealPtrPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtrPtrInt()

SCIP_EXPORT void SCIPselectDownRealPtrPtrInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealPtrPtrInt()

SCIP_EXPORT void SCIPselectWeightedDownRealPtrPtrInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtrPtrIntInt()

SCIP_EXPORT void SCIPselectDownRealPtrPtrIntInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealPtrPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedDownRealPtrPtrIntInt	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealLongRealInt()

SCIP_EXPORT void SCIPselectDownRealLongRealInt	(	SCIP_Real *	realarray1,
		SCIP_Longint *	longarray,
		SCIP_Real *	realarray3,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealLongRealInt()

SCIP_EXPORT void SCIPselectWeightedDownRealLongRealInt	(	SCIP_Real *	realarray1,
		SCIP_Longint *	longarray,
		SCIP_Real *	realarray3,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

Referenced by SCIPsolveKnapsackApproximately(), and SCIPsolveKnapsackExactly().

◆ SCIPselectDownRealRealIntInt()

SCIP_EXPORT void SCIPselectDownRealRealIntInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealIntInt()

SCIP_EXPORT void SCIPselectWeightedDownRealRealIntInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealInt()

SCIP_EXPORT void SCIPselectDownRealRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealRealInt()

SCIP_EXPORT void SCIPselectWeightedDownRealRealRealInt	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealPtr()

SCIP_EXPORT void SCIPselectDownRealRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealRealPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealRealRealPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtrPtr()

SCIP_EXPORT void SCIPselectDownRealPtrPtr	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int	k,
		int	len
	)

partial sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealPtrPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealPtrPtr	(	SCIP_Real *	realarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealBoolPtr()

SCIP_EXPORT void SCIPselectDownRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealRealBoolPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealRealRealBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealBoolBoolPtr()

SCIP_EXPORT void SCIPselectDownRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownRealRealRealBoolBoolPtr()

SCIP_EXPORT void SCIPselectWeightedDownRealRealRealBoolBoolPtr	(	SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Real *	realarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownInt()

SCIP_EXPORT void SCIPselectDownInt	(	int *	intarray,
		int	k,
		int	len
	)

partial sort array of ints in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownInt()

SCIP_EXPORT void SCIPselectWeightedDownInt	(	int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort array of ints in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntInt()

SCIP_EXPORT void SCIPselectDownIntInt	(	int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray1	int array to be sorted
intarray2	second int array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntInt()

SCIP_EXPORT void SCIPselectWeightedDownIntInt	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray1	int array to be sorted
intarray2	second int array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntPtr()

SCIP_EXPORT void SCIPselectDownIntPtr	(	int *	intarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
ptrarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntPtr()

SCIP_EXPORT void SCIPselectWeightedDownIntPtr	(	int *	intarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
ptrarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntReal()

SCIP_EXPORT void SCIPselectDownIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
realarray	real array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntReal()

SCIP_EXPORT void SCIPselectWeightedDownIntReal	(	int *	intarray,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

intarray	int array to be sorted
realarray	real array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntInt()

SCIP_EXPORT void SCIPselectDownIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntIntInt()

SCIP_EXPORT void SCIPselectWeightedDownIntIntInt	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntLong()

SCIP_EXPORT void SCIPselectDownIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntIntLong()

SCIP_EXPORT void SCIPselectWeightedDownIntIntLong	(	int *	intarray1,
		int *	intarray2,
		SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntPtr()

SCIP_EXPORT void SCIPselectDownIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntIntPtr()

SCIP_EXPORT void SCIPselectWeightedDownIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntReal()

SCIP_EXPORT void SCIPselectDownIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntIntReal()

SCIP_EXPORT void SCIPselectWeightedDownIntIntReal	(	int *	intarray1,
		int *	intarray2,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntIntPtr()

SCIP_EXPORT void SCIPselectDownIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntIntIntPtr()

SCIP_EXPORT void SCIPselectWeightedDownIntIntIntPtr	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntIntReal()

SCIP_EXPORT void SCIPselectDownIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntIntIntReal()

SCIP_EXPORT void SCIPselectWeightedDownIntIntIntReal	(	int *	intarray1,
		int *	intarray2,
		int *	intarray3,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntPtrIntReal()

SCIP_EXPORT void SCIPselectDownIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntPtrIntReal()

SCIP_EXPORT void SCIPselectWeightedDownIntPtrIntReal	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		SCIP_Real *	realarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLong()

SCIP_EXPORT void SCIPselectDownLong	(	SCIP_Longint *	longarray,
		int	k,
		int	len
	)

partial sort an array of Longints in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLong()

SCIP_EXPORT void SCIPselectWeightedDownLong	(	SCIP_Longint *	longarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort an array of Longints in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtr()

SCIP_EXPORT void SCIPselectDownLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int	k,
		int	len
	)

partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
ptrarray	pointer array to be permuted in the same way
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtr()

SCIP_EXPORT void SCIPselectWeightedDownLongPtr	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters

longarray	SCIP_Longint array to be sorted
ptrarray	pointer array to be permuted in the same way
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrInt()

SCIP_EXPORT void SCIPselectDownLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrInt()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrRealBool()

SCIP_EXPORT void SCIPselectDownLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		int	k,
		int	len
	)

partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrRealBool()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Bool *	boolarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrRealRealBool()

SCIP_EXPORT void SCIPselectDownLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		int	k,
		int	len
	)

partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrRealRealBool()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrRealRealBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrRealRealIntBool()

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

partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrRealRealIntBool()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrRealRealIntBool	(	SCIP_Longint *	longarray,
		void **	ptrarray,
		SCIP_Real *	realarray,
		SCIP_Real *	realarray2,
		int *	intarray,
		SCIP_Bool *	boolarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrPtrInt()

SCIP_EXPORT void SCIPselectDownLongPtrPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrPtrInt()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrPtrInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrPtrIntInt()

SCIP_EXPORT void SCIPselectDownLongPtrPtrIntInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		int	k,
		int	len
	)

partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrPtrIntInt()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrPtrIntInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		int *	intarray1,
		int *	intarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrPtrBoolInt()

SCIP_EXPORT void SCIPselectDownLongPtrPtrBoolInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Bool *	boolarray,
		int *	intarray,
		int	k,
		int	len
	)

partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownLongPtrPtrBoolInt()

SCIP_EXPORT void SCIPselectWeightedDownLongPtrPtrBoolInt	(	SCIP_Longint *	longarray,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_Bool *	boolarray,
		int *	intarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectDownPtrIntIntBoolBool	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		int	k,
		int	len
	)

partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectWeightedDownPtrIntIntBoolBool	(	void **	ptrarray,
		int *	intarray1,
		int *	intarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectDownIntPtrIntIntBoolBool	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		int *	intarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		int	k,
		int	len
	)

partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

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
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

◆ SCIPselectWeightedDownIntPtrIntIntBoolBool()

SCIP_EXPORT void SCIPselectWeightedDownIntPtrIntIntBoolBool	(	int *	intarray1,
		void **	ptrarray,
		int *	intarray2,
		int *	intarray3,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos
	)

partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

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
weights	(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacity	the maximum capacity that is exceeded by the median
len	length of arrays
medianpos	pointer to store the index of the weighted median, or NULL, if not needed

SCIP

Detailed Description

Functions

Function Documentation

◆ SCIPselectInd()

◆ SCIPselectWeightedInd()

◆ SCIPselectPtr()

◆ SCIPselectWeightedPtr()

◆ SCIPselectPtrPtr()

◆ SCIPselectWeightedPtrPtr()

◆ SCIPselectPtrReal()

◆ SCIPselectWeightedPtrReal()

◆ SCIPselectPtrInt()

◆ SCIPselectWeightedPtrInt()

◆ SCIPselectPtrBool()

◆ SCIPselectWeightedPtrBool()

◆ SCIPselectPtrIntInt()

◆ SCIPselectWeightedPtrIntInt()

◆ SCIPselectPtrRealInt()

◆ SCIPselectWeightedPtrRealInt()

◆ SCIPselectPtrRealRealInt()

◆ SCIPselectPtrRealRealIntBool()

◆ SCIPselectWeightedPtrRealRealInt()

◆ SCIPselectWeightedPtrRealRealIntBool()

◆ SCIPselectPtrRealBool()

◆ SCIPselectWeightedPtrRealBool()

◆ SCIPselectPtrRealReal()

◆ SCIPselectWeightedPtrRealReal()

◆ SCIPselectPtrPtrInt()

◆ SCIPselectWeightedPtrPtrInt()

◆ SCIPselectPtrPtrReal()

◆ SCIPselectWeightedPtrPtrReal()

◆ SCIPselectPtrPtrIntInt()

◆ SCIPselectWeightedPtrPtrIntInt()

◆ SCIPselectPtrRealIntInt()

◆ SCIPselectWeightedPtrRealIntInt()

◆ SCIPselectPtrPtrRealInt()

◆ SCIPselectWeightedPtrPtrRealInt()

◆ SCIPselectPtrPtrRealBool()

◆ SCIPselectWeightedPtrPtrRealBool()

◆ SCIPselectPtrPtrLongInt()

◆ SCIPselectWeightedPtrPtrLongInt()

◆ SCIPselectPtrPtrLongIntInt()

◆ SCIPselectWeightedPtrPtrLongIntInt()

◆ SCIPselectReal()

◆ SCIPselectWeightedReal()

◆ SCIPselectRealPtr()

◆ SCIPselectWeightedRealPtr()

◆ SCIPselectRealInt()

◆ SCIPselectWeightedRealInt()

◆ SCIPselectRealIntInt()

◆ SCIPselectWeightedRealIntInt()

◆ SCIPselectRealBoolPtr()

◆ SCIPselectWeightedRealBoolPtr()

◆ SCIPselectRealIntLong()

◆ SCIPselectWeightedRealIntLong()

◆ SCIPselectRealIntPtr()

◆ SCIPselectWeightedRealIntPtr()

◆ SCIPselectRealRealPtr()

◆ SCIPselectWeightedRealRealPtr()

◆ SCIPselectRealPtrPtrInt()

◆ SCIPselectWeightedRealPtrPtrInt()

◆ SCIPselectRealPtrPtrIntInt()

◆ SCIPselectWeightedRealPtrPtrIntInt()

◆ SCIPselectRealLongRealInt()

◆ SCIPselectWeightedRealLongRealInt()

◆ SCIPselectRealRealIntInt()

◆ SCIPselectWeightedRealRealIntInt()

◆ SCIPselectRealRealRealInt()

◆ SCIPselectWeightedRealRealRealInt()

◆ SCIPselectRealRealRealPtr()

◆ SCIPselectWeightedRealRealRealPtr()

◆ SCIPselectRealRealRealBoolPtr()

◆ SCIPselectWeightedRealRealRealBoolPtr()

◆ SCIPselectRealRealRealBoolBoolPtr()

◆ SCIPselectWeightedRealRealRealBoolBoolPtr()

◆ SCIPselectInt()

◆ SCIPselectWeightedInt()

◆ SCIPselectIntInt()

◆ SCIPselectWeightedIntInt()