Algorithms for Median Selection

Detailed Description

public methods for the selection of the k-median.

The methods in this group perform a selection of the \( 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 critical item 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 critical item 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)] \leq C\), but \( W + w[i] > C\). In other words, the critical item is the first element in the weak sorting whose cumulative weight strictly exceeds the given capacity \( C \). If all weights are equal to \( 1 \) and the capacity is \( C = k + 0.5\), the critical item 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	SCIPselectPtrRealRealBoolBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
void	SCIPselectPtrRealRealIntBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, 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	SCIPselectWeightedPtrRealRealBoolBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
void	SCIPselectWeightedPtrRealRealIntBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
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	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	SCIPselectRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int k, int len)
void	SCIPselectWeightedRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, 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	SCIPselectIntIntPtrPtr (int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, int k, int len)
void	SCIPselectIntIntPtrPtrInterval (int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, SCIP_INTERVAL *intervalarray, int k, int len)
void	SCIPselectWeightedIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
void	SCIPselectWeightedIntIntPtrPtr (int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
void	SCIPselectWeightedIntIntPtrPtrInterval (int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, SCIP_INTERVAL *intervalarray, 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 Median Selection for more information.

Parameters

indarray	pointer to the index array to be sorted
-	data element comparator
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

References SCIP_DECL_SORTINDCOMP, and SCIPselectInd().

Referenced by alnsFixMoreVariables(), LNSFixMoreVariables(), and SCIPselectInd().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTINDCOMP, SCIP_Real, and SCIPselectWeightedInd().

Referenced by SCIPselectWeightedInd().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectPtr().

Referenced by doSeparation(), and SCIPselectPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtr().

Referenced by SCIPselectWeightedPtr().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrPtr().

Referenced by SCIPselectPtrPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrPtr().

Referenced by SCIPselectWeightedPtrPtr().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrReal().

Referenced by SCIPselectPtrReal().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrReal().

Referenced by SCIPselectWeightedPtrReal().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrInt().

Referenced by SCIPselectPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrInt().

Referenced by SCIPselectWeightedPtrInt().

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 Median Selection for more information.

Parameters

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrBool().

Referenced by SCIPselectPtrBool().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrBool().

Referenced by SCIPselectWeightedPtrBool().

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrIntInt().

Referenced by SCIPselectPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrIntInt().

Referenced by SCIPselectWeightedPtrIntInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrRealInt().

Referenced by SCIPselectPtrRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrRealInt().

Referenced by SCIPselectWeightedPtrRealInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrRealRealInt().

Referenced by SCIPselectPtrRealRealInt().

SCIPselectPtrRealRealBoolBool()

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

partial sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order around the k-th element, see Algorithms for 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
boolarray1	SCIP_Bool array to be permuted in the same way
boolarray2	SCIP_Bool array to be permuted in the same way
-	data element comparator
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrRealRealBoolBool().

Referenced by SCIPselectPtrRealRealBoolBool().

SCIPselectPtrRealRealIntBool()

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

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

Parameters

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrRealRealIntBool().

Referenced by SCIPselectPtrRealRealIntBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrRealRealInt().

Referenced by SCIPselectWeightedPtrRealRealInt().

SCIPselectWeightedPtrRealRealBoolBool()

void SCIPselectWeightedPtrRealRealBoolBool	(	void **	ptrarray,
		SCIP_Real *	realarray1,
		SCIP_Real *	realarray2,
		SCIP_Bool *	boolarray1,
		SCIP_Bool *	boolarray2,
		SCIP_DECL_SORTPTRCOMP((*ptrcomp))	,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos )

partial sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order around the critical item w.r.t. weights and capacity, see Algorithms for 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
boolarray1	SCIP_Bool array to be permuted in the same way
boolarray2	SCIP_Bool array to be permuted in the same way
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrRealRealBoolBool().

Referenced by SCIPselectWeightedPtrRealRealBoolBool().

SCIPselectWeightedPtrRealRealIntBool()

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

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

Parameters

ptrarray	pointer array to be sorted
realarray1	SCIP_Real array to be permuted in the same way
realarray2	SCIP_Real array to be permuted in the same way
intarray	int array to be permuted in the same way
boolarray	SCIP_Bool array to be permuted in the same way
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrRealRealIntBool().

Referenced by SCIPselectWeightedPtrRealRealIntBool().

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrRealBool().

Referenced by SCIPselectPtrRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrRealBool().

Referenced by SCIPselectWeightedPtrRealBool().

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrPtrInt().

Referenced by SCIPselectPtrPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrPtrInt().

Referenced by SCIPselectWeightedPtrPtrInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrPtrReal().

Referenced by SCIPselectPtrPtrReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrPtrReal().

Referenced by SCIPselectWeightedPtrPtrReal().

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrPtrIntInt().

Referenced by SCIPselectPtrPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrPtrIntInt().

Referenced by SCIPselectWeightedPtrPtrIntInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrRealIntInt().

Referenced by SCIPselectPtrRealIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrRealIntInt().

Referenced by SCIPselectWeightedPtrRealIntInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrPtrRealInt().

Referenced by SCIPselectPtrPtrRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrPtrRealInt().

Referenced by SCIPselectWeightedPtrPtrRealInt().

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectPtrPtrRealBool().

Referenced by SCIPselectPtrPtrRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrPtrRealBool().

Referenced by SCIPselectWeightedPtrPtrRealBool().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, and SCIPselectPtrPtrLongInt().

Referenced by SCIPselectPtrPtrLongInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, SCIP_Real, and SCIPselectWeightedPtrPtrLongInt().

Referenced by SCIPselectWeightedPtrPtrLongInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, and SCIPselectPtrPtrLongIntInt().

Referenced by SCIPselectPtrPtrLongIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, SCIP_Real, and SCIPselectWeightedPtrPtrLongIntInt().

Referenced by SCIPselectWeightedPtrPtrLongIntInt().

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

References SCIP_Real, and SCIPselectReal().

Referenced by SCIPselectReal().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Real, and SCIPselectWeightedReal().

Referenced by SCIPselectWeightedReal(), and solveSingleRowLP().

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

References SCIP_Real, and SCIPselectRealPtr().

Referenced by SCIPselectRealPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealPtr().

Referenced by SCIPselectWeightedRealPtr().

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

References SCIP_Real, and SCIPselectRealInt().

Referenced by SCIPselectRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealInt().

Referenced by SCIPselectWeightedRealInt().

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

References SCIP_Real, and SCIPselectRealIntInt().

Referenced by SCIPselectRealIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealIntInt().

Referenced by SCIPselectWeightedRealIntInt().

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

References SCIP_Bool, SCIP_Real, and SCIPselectRealBoolPtr().

Referenced by SCIPselectRealBoolPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedRealBoolPtr().

Referenced by SCIPselectWeightedRealBoolPtr().

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

References SCIP_Longint, SCIP_Real, and SCIPselectRealIntLong().

Referenced by SCIPselectRealIntLong().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedRealIntLong().

Referenced by SCIPselectWeightedRealIntLong().

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

References SCIP_Real, and SCIPselectRealIntPtr().

Referenced by SCIPselectRealIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealIntPtr().

Referenced by SCIPselectWeightedRealIntPtr().

SCIPselectRealPtrPtr()

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

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

Parameters

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

References SCIP_Real, and SCIPselectRealPtrPtr().

Referenced by SCIPselectRealPtrPtr().

SCIPselectWeightedRealPtrPtr()

void SCIPselectWeightedRealPtrPtr	(	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/Pointer/Pointer, sorted by first array in non-decreasing order around the critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Real, and SCIPselectWeightedRealPtrPtr().

Referenced by SCIPselectWeightedRealPtrPtr().

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

References SCIP_Real, and SCIPselectRealRealPtr().

Referenced by SCIPselectRealRealPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealRealPtr().

Referenced by SCIPselectWeightedRealRealPtr().

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

References SCIP_Real, and SCIPselectRealPtrPtrInt().

Referenced by SCIPselectRealPtrPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealPtrPtrInt().

Referenced by SCIPselectWeightedRealPtrPtrInt().

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

References SCIP_Real, and SCIPselectRealPtrPtrIntInt().

Referenced by SCIPselectRealPtrPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealPtrPtrIntInt().

Referenced by SCIPselectWeightedRealPtrPtrIntInt().

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

References SCIP_Longint, SCIP_Real, and SCIPselectRealLongRealInt().

Referenced by SCIPselectRealLongRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedRealLongRealInt().

Referenced by SCIPselectWeightedRealLongRealInt().

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

References SCIP_Real, and SCIPselectRealRealIntInt().

Referenced by SCIPselectRealRealIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealRealIntInt().

Referenced by SCIPselectWeightedRealRealIntInt().

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

References SCIP_Real, and SCIPselectRealRealRealInt().

Referenced by SCIPselectRealRealRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealRealRealInt().

Referenced by SCIPselectWeightedRealRealRealInt().

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

References SCIP_Real, and SCIPselectRealRealRealPtr().

Referenced by SCIPselectRealRealRealPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedRealRealRealPtr().

Referenced by SCIPselectWeightedRealRealRealPtr().

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

References SCIP_Bool, SCIP_Real, and SCIPselectRealRealRealBoolPtr().

Referenced by SCIPselectRealRealRealBoolPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedRealRealRealBoolPtr().

Referenced by SCIPselectWeightedRealRealRealBoolPtr().

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

References SCIP_Bool, SCIP_Real, and SCIPselectRealRealRealBoolBoolPtr().

Referenced by SCIPselectRealRealRealBoolBoolPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedRealRealRealBoolBoolPtr().

Referenced by SCIPselectWeightedRealRealRealBoolBoolPtr().

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

References SCIPselectInt().

Referenced by SCIPselectInt().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Real, and SCIPselectWeightedInt().

Referenced by SCIPselectWeightedInt().

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

References SCIPselectIntInt().

Referenced by SCIPselectIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntInt().

Referenced by SCIPselectWeightedIntInt().

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

References SCIPselectIntPtr().

Referenced by SCIPselectIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntPtr().

Referenced by SCIPselectWeightedIntPtr().

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

References SCIP_Real, and SCIPselectIntReal().

Referenced by SCIPselectIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntReal().

Referenced by SCIPselectWeightedIntReal().

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

References SCIPselectIntIntInt().

Referenced by SCIPselectIntIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntInt().

Referenced by SCIPselectWeightedIntIntInt().

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

References SCIP_Longint, and SCIPselectIntIntLong().

Referenced by SCIPselectIntIntLong().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedIntIntLong().

Referenced by SCIPselectWeightedIntIntLong().

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

References SCIP_Longint, SCIP_Real, and SCIPselectIntRealLong().

Referenced by SCIPselectIntRealLong().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedIntRealLong().

Referenced by SCIPselectWeightedIntRealLong().

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

References SCIPselectIntIntPtr().

Referenced by SCIPselectIntIntPtr().

SCIPselectIntIntPtrPtr()

void SCIPselectIntIntPtrPtr	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		int	k,
		int	len )

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

Parameters

intarray1	int array to be sorted
intarray2	second int 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

References SCIPselectIntIntPtrPtr().

Referenced by SCIPselectIntIntPtrPtr().

SCIPselectIntIntPtrPtrInterval()

void SCIPselectIntIntPtrPtrInterval	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_INTERVAL *	intervalarray,
		int	k,
		int	len )

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

Parameters

intarray1	int array to be sorted
intarray2	second int 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
intervalarray	interval array where an element is to be deleted
k	the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
len	length of arrays

References SCIPselectIntIntPtrPtrInterval().

Referenced by SCIPselectIntIntPtrPtrInterval().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntPtr().

Referenced by SCIPselectWeightedIntIntPtr().

SCIPselectWeightedIntIntPtrPtr()

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

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

Parameters

intarray1	int array to be sorted
intarray2	second int 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntPtrPtr().

Referenced by SCIPselectWeightedIntIntPtrPtr().

SCIPselectWeightedIntIntPtrPtrInterval()

void SCIPselectWeightedIntIntPtrPtrInterval	(	int *	intarray1,
		int *	intarray2,
		void **	ptrarray1,
		void **	ptrarray2,
		SCIP_INTERVAL *	intervalarray,
		SCIP_Real *	weights,
		SCIP_Real	capacity,
		int	len,
		int *	medianpos )

partial sort of five joint arrays of ints/ints/pointers/pointers/interval, sorted by first array in non-decreasing order around the critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

intarray1	int array to be sorted
intarray2	second int 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
intervalarray	interval array where an element is to be deleted
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntPtrPtrInterval().

Referenced by SCIPselectWeightedIntIntPtrPtrInterval().

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

References SCIP_Real, and SCIPselectIntIntReal().

Referenced by SCIPselectIntIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntReal().

Referenced by SCIPselectWeightedIntIntReal().

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

References SCIP_Real, and SCIPselectIntPtrReal().

Referenced by SCIPselectIntPtrReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntPtrReal().

Referenced by SCIPselectWeightedIntPtrReal().

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

References SCIPselectIntIntIntPtr().

Referenced by SCIPselectIntIntIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntIntPtr().

Referenced by SCIPselectWeightedIntIntIntPtr().

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

References SCIP_Real, and SCIPselectIntIntIntReal().

Referenced by SCIPselectIntIntIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntIntIntReal().

Referenced by SCIPselectWeightedIntIntIntReal().

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

References SCIP_Real, and SCIPselectIntPtrIntReal().

Referenced by SCIPselectIntPtrIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedIntPtrIntReal().

Referenced by SCIPselectWeightedIntPtrIntReal().

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

References SCIP_Longint, and SCIPselectLong().

Referenced by SCIPselectLong().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedLong().

Referenced by SCIPselectWeightedLong().

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

References SCIP_Longint, and SCIPselectLongPtr().

Referenced by SCIPselectLongPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtr().

Referenced by SCIPselectWeightedLongPtr().

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

References SCIP_Longint, and SCIPselectLongPtrInt().

Referenced by SCIPselectLongPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrInt().

Referenced by SCIPselectWeightedLongPtrInt().

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

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectLongPtrRealBool().

Referenced by SCIPselectLongPtrRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrRealBool().

Referenced by SCIPselectWeightedLongPtrRealBool().

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

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectLongPtrRealRealBool().

Referenced by SCIPselectLongPtrRealRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrRealRealBool().

Referenced by SCIPselectWeightedLongPtrRealRealBool().

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

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectLongPtrRealRealIntBool().

Referenced by SCIPselectLongPtrRealRealIntBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrRealRealIntBool().

Referenced by SCIPselectWeightedLongPtrRealRealIntBool().

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

References SCIP_Longint, and SCIPselectLongPtrPtrInt().

Referenced by SCIPselectLongPtrPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrPtrInt().

Referenced by SCIPselectWeightedLongPtrPtrInt().

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

References SCIP_Longint, and SCIPselectLongPtrPtrIntInt().

Referenced by SCIPselectLongPtrPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrPtrIntInt().

Referenced by SCIPselectWeightedLongPtrPtrIntInt().

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

References SCIP_Bool, SCIP_Longint, and SCIPselectLongPtrPtrBoolInt().

Referenced by SCIPselectLongPtrPtrBoolInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedLongPtrPtrBoolInt().

Referenced by SCIPselectWeightedLongPtrPtrBoolInt().

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, and SCIPselectPtrIntIntBoolBool().

Referenced by SCIPselectPtrIntIntBoolBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedPtrIntIntBoolBool().

Referenced by SCIPselectWeightedPtrIntIntBoolBool().

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

References SCIP_Bool, and SCIPselectIntPtrIntIntBoolBool().

Referenced by SCIPselectIntPtrIntIntBoolBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedIntPtrIntIntBoolBool().

Referenced by SCIPselectWeightedIntPtrIntIntBoolBool().

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 Median Selection for more information.

Parameters

indarray	pointer to the index array to be sorted
-	data element comparator
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

References SCIP_DECL_SORTINDCOMP, and SCIPselectDownInd().

Referenced by alnsUnfixVariables(), LNSUnfixVariables(), and SCIPselectDownInd().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTINDCOMP, SCIP_Real, and SCIPselectWeightedDownInd().

Referenced by SCIPselectWeightedDownInd().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtr().

Referenced by SCIPselectDownPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

ptrarray	pointer array to be sorted
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtr().

Referenced by SCIPselectWeightedDownPtr().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrPtr().

Referenced by SCIPselectDownPtrPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrPtr().

Referenced by SCIPselectWeightedDownPtrPtr().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrReal().

Referenced by SCIPselectDownPtrReal().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrReal().

Referenced by SCIPselectWeightedDownPtrReal().

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 Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrInt().

Referenced by SCIPselectDownPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrInt().

Referenced by SCIPselectWeightedDownPtrInt().

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 Median Selection for more information.

Parameters

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrBool().

Referenced by SCIPselectDownPtrBool().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrBool().

Referenced by SCIPselectWeightedDownPtrBool().

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrIntInt().

Referenced by SCIPselectDownPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrIntInt().

Referenced by SCIPselectWeightedDownPtrIntInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrRealInt().

Referenced by SCIPselectDownPtrRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrRealInt().

Referenced by SCIPselectWeightedDownPtrRealInt().

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrRealBool().

Referenced by SCIPselectDownPtrRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrRealBool().

Referenced by SCIPselectWeightedDownPtrRealBool().

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrPtrInt().

Referenced by SCIPselectDownPtrPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrPtrInt().

Referenced by SCIPselectWeightedDownPtrPtrInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrPtrReal().

Referenced by SCIPselectDownPtrPtrReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrPtrReal().

Referenced by SCIPselectWeightedDownPtrPtrReal().

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

References SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrPtrIntInt().

Referenced by SCIPselectDownPtrPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrPtrIntInt().

Referenced by SCIPselectWeightedDownPtrPtrIntInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrRealIntInt().

Referenced by SCIPselectDownPtrRealIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrRealIntInt().

Referenced by SCIPselectWeightedDownPtrRealIntInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrPtrRealInt().

Referenced by SCIPselectDownPtrPtrRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrPtrRealInt().

Referenced by SCIPselectWeightedDownPtrPtrRealInt().

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectDownPtrPtrRealBool().

Referenced by SCIPselectDownPtrPtrRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrPtrRealBool().

Referenced by SCIPselectWeightedDownPtrPtrRealBool().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, and SCIPselectDownPtrPtrLongInt().

Referenced by SCIPselectDownPtrPtrLongInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownPtrPtrLongInt().

Referenced by SCIPselectWeightedDownPtrPtrLongInt().

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

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, and SCIPselectDownPtrPtrLongIntInt().

Referenced by SCIPselectDownPtrPtrLongIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_DECL_SORTPTRCOMP, SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownPtrPtrLongIntInt().

Referenced by SCIPselectWeightedDownPtrPtrLongIntInt().

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

References SCIP_Real, and SCIPselectDownReal().

Referenced by SCIPselectDownReal().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Real, and SCIPselectWeightedDownReal().

Referenced by SCIPselectWeightedDownReal().

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

References SCIP_Real, and SCIPselectDownRealPtr().

Referenced by SCIPselectDownRealPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealPtr().

Referenced by SCIPselectWeightedDownRealPtr().

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

References SCIP_Real, and SCIPselectDownRealInt().

Referenced by SCIPselectDownRealInt(), and 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 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

References SCIP_Real, and SCIPselectDownRealIntInt().

Referenced by SCIPselectDownRealIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealInt().

Referenced by SCIPselectWeightedDownRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealIntInt().

Referenced by SCIPselectWeightedDownRealIntInt().

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

References SCIP_Bool, SCIP_Real, and SCIPselectDownRealBoolPtr().

Referenced by SCIPselectDownRealBoolPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedDownRealBoolPtr().

Referenced by SCIPselectWeightedDownRealBoolPtr().

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

References SCIP_Longint, SCIP_Real, and SCIPselectDownRealIntLong().

Referenced by SCIPselectDownRealIntLong().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownRealIntLong().

Referenced by SCIPselectWeightedDownRealIntLong().

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

References SCIP_Real, and SCIPselectDownRealIntPtr().

Referenced by SCIPselectDownRealIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealIntPtr().

Referenced by SCIPselectWeightedDownRealIntPtr().

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

References SCIP_Real, and SCIPselectDownRealRealInt().

Referenced by SCIPselectDownRealRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealRealInt().

Referenced by SCIPselectWeightedDownRealRealInt(), and 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 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

References SCIP_Real, and SCIPselectDownRealRealPtr().

Referenced by SCIPselectDownRealRealPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealRealPtr().

Referenced by SCIPselectWeightedDownRealRealPtr().

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

References SCIP_Real, and SCIPselectDownRealRealPtrPtr().

Referenced by SCIPselectDownRealRealPtrPtr().

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 critical item 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealRealPtrPtr().

Referenced by SCIPselectWeightedDownRealRealPtrPtr().

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

References SCIP_Real, and SCIPselectDownRealPtrPtrInt().

Referenced by SCIPselectDownRealPtrPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealPtrPtrInt().

Referenced by SCIPselectWeightedDownRealPtrPtrInt().

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

References SCIP_Real, and SCIPselectDownRealPtrPtrIntInt().

Referenced by SCIPselectDownRealPtrPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealPtrPtrIntInt().

Referenced by SCIPselectWeightedDownRealPtrPtrIntInt().

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

References SCIP_Longint, SCIP_Real, and SCIPselectDownRealLongRealInt().

Referenced by SCIPselectDownRealLongRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownRealLongRealInt().

Referenced by SCIPselectWeightedDownRealLongRealInt(), 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 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

References SCIP_Real, and SCIPselectDownRealRealIntInt().

Referenced by SCIPselectDownRealRealIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealRealIntInt().

Referenced by SCIPselectWeightedDownRealRealIntInt().

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

References SCIP_Real, and SCIPselectDownRealRealRealInt().

Referenced by SCIPselectDownRealRealRealInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealRealRealInt().

Referenced by SCIPselectWeightedDownRealRealRealInt().

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

References SCIP_Real, and SCIPselectDownRealRealRealPtr().

Referenced by SCIPselectDownRealRealRealPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealRealRealPtr().

Referenced by SCIPselectWeightedDownRealRealRealPtr().

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

References SCIP_Real, and SCIPselectDownRealPtrPtr().

Referenced by SCIPselectDownRealPtrPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownRealPtrPtr().

Referenced by SCIPselectWeightedDownRealPtrPtr().

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

References SCIP_Bool, SCIP_Real, and SCIPselectDownRealRealRealBoolPtr().

Referenced by SCIPselectDownRealRealRealBoolPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedDownRealRealRealBoolPtr().

Referenced by SCIPselectWeightedDownRealRealRealBoolPtr().

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

References SCIP_Bool, SCIP_Real, and SCIPselectDownRealRealRealBoolBoolPtr().

Referenced by SCIPselectDownRealRealRealBoolBoolPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedDownRealRealRealBoolBoolPtr().

Referenced by SCIPselectWeightedDownRealRealRealBoolBoolPtr().

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

References SCIPselectDownInt().

Referenced by SCIPselectDownInt().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Real, and SCIPselectWeightedDownInt().

Referenced by SCIPselectWeightedDownInt().

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

References SCIPselectDownIntInt().

Referenced by SCIPselectDownIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntInt().

Referenced by SCIPselectWeightedDownIntInt().

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

References SCIPselectDownIntPtr().

Referenced by createSepaData(), and SCIPselectDownIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntPtr().

Referenced by SCIPselectWeightedDownIntPtr().

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

References SCIP_Real, and SCIPselectDownIntReal().

Referenced by SCIPselectDownIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntReal().

Referenced by SCIPselectWeightedDownIntReal().

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

References SCIPselectDownIntIntInt().

Referenced by SCIPselectDownIntIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntIntInt().

Referenced by SCIPselectWeightedDownIntIntInt().

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

References SCIP_Longint, and SCIPselectDownIntIntLong().

Referenced by SCIPselectDownIntIntLong().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownIntIntLong().

Referenced by SCIPselectWeightedDownIntIntLong().

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

References SCIPselectDownIntIntPtr().

Referenced by SCIPselectDownIntIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntIntPtr().

Referenced by SCIPselectWeightedDownIntIntPtr().

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

References SCIP_Real, and SCIPselectDownIntIntReal().

Referenced by SCIPselectDownIntIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntIntReal().

Referenced by SCIPselectWeightedDownIntIntReal().

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

References SCIPselectDownIntIntIntPtr().

Referenced by SCIPselectDownIntIntIntPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntIntIntPtr().

Referenced by SCIPselectWeightedDownIntIntIntPtr().

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

References SCIP_Real, and SCIPselectDownIntIntIntReal().

Referenced by SCIPselectDownIntIntIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntIntIntReal().

Referenced by SCIPselectWeightedDownIntIntIntReal().

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

References SCIP_Real, and SCIPselectDownIntPtrIntReal().

Referenced by SCIPselectDownIntPtrIntReal().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Real, and SCIPselectWeightedDownIntPtrIntReal().

Referenced by SCIPselectWeightedDownIntPtrIntReal().

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

References SCIP_Longint, and SCIPselectDownLong().

Referenced by SCIPselectDownLong().

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 critical item w.r.t. weights and capacity, see Algorithms for Median Selection for more information.

Parameters

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

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLong().

Referenced by SCIPselectWeightedDownLong().

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

References SCIP_Longint, and SCIPselectDownLongPtr().

Referenced by SCIPselectDownLongPtr().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtr().

Referenced by SCIPselectWeightedDownLongPtr().

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

References SCIP_Longint, and SCIPselectDownLongPtrInt().

Referenced by SCIPselectDownLongPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrInt().

Referenced by SCIPselectWeightedDownLongPtrInt().

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

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectDownLongPtrRealBool().

Referenced by SCIPselectDownLongPtrRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrRealBool().

Referenced by SCIPselectWeightedDownLongPtrRealBool().

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

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectDownLongPtrRealRealBool().

Referenced by SCIPselectDownLongPtrRealRealBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrRealRealBool().

Referenced by SCIPselectWeightedDownLongPtrRealRealBool().

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

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectDownLongPtrRealRealIntBool().

Referenced by SCIPselectDownLongPtrRealRealIntBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrRealRealIntBool().

Referenced by SCIPselectWeightedDownLongPtrRealRealIntBool().

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

References SCIP_Longint, and SCIPselectDownLongPtrPtrInt().

Referenced by SCIPselectDownLongPtrPtrInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrPtrInt().

Referenced by SCIPselectWeightedDownLongPtrPtrInt().

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

References SCIP_Longint, and SCIPselectDownLongPtrPtrIntInt().

Referenced by SCIPselectDownLongPtrPtrIntInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrPtrIntInt().

Referenced by SCIPselectWeightedDownLongPtrPtrIntInt().

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

References SCIP_Bool, SCIP_Longint, and SCIPselectDownLongPtrPtrBoolInt().

Referenced by SCIPselectDownLongPtrPtrBoolInt().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Longint, SCIP_Real, and SCIPselectWeightedDownLongPtrPtrBoolInt().

Referenced by SCIPselectWeightedDownLongPtrPtrBoolInt().

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

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, and SCIPselectDownPtrIntIntBoolBool().

Referenced by SCIPselectDownPtrIntIntBoolBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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
-	data element comparator
weights	(optional), nonnegative weights array for the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_DECL_SORTPTRCOMP, SCIP_Real, and SCIPselectWeightedDownPtrIntIntBoolBool().

Referenced by SCIPselectWeightedDownPtrIntIntBoolBool().

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

References SCIP_Bool, and SCIPselectDownIntPtrIntIntBoolBool().

Referenced by SCIPselectDownIntPtrIntIntBoolBool().

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 critical item w.r.t. weights and capacity, see Algorithms for 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 the critical item, or NULL (all weights are equal to one)
capacity	the maximum capacity that is exceeded by the critical item
len	length of arrays
medianpos	pointer to store the index of the critical item, or NULL, if not needed

References SCIP_Bool, SCIP_Real, and SCIPselectWeightedDownIntPtrIntIntBoolBool().

Referenced by SCIPselectWeightedDownIntPtrIntIntBoolBool().