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
void	SCIPselectInd (int indarray, SCIP_DECL_SORTINDCOMP((indcomp)), void *dataptr, int k, int len)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

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)

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

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)

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

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

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

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

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

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

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

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)

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

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)

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

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)

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

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

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

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

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

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

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

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)

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

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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

◆ SCIPselectWeightedPtrRealRealInt()

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

◆ SCIPselectPtrRealBool()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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

◆ SCIPselectRealPtr()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

◆ SCIPselectWeightedPtrRealRealInt()

◆ 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()

◆ SCIPselectIntPtr()

◆ SCIPselectWeightedIntPtr()