Scippy

SCIP

Solving Constraint Integer Programs

Algorithms for (Weighted) Median Selection

Detailed Description

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

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

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

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

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

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

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

Functions

void SCIPselectInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len)
 
void SCIPselectWeightedInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrRealReal (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrRealReal (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectReal (SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedReal (SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealPtr (SCIP_Real *realarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealPtr (SCIP_Real *realarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealInt (SCIP_Real *realarray, int *intarray, int k, int len)
 
void SCIPselectWeightedRealInt (SCIP_Real *realarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
 
void SCIPselectWeightedRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int k, int len)
 
void SCIPselectWeightedRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int k, int len)
 
void SCIPselectWeightedRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int k, int len)
 
void SCIPselectWeightedRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectInt (int *intarray, int k, int len)
 
void SCIPselectWeightedInt (int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntInt (int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedIntInt (int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntPtr (int *intarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedIntPtr (int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntReal (int *intarray, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedIntReal (int *intarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntIntInt (int *intarray1, int *intarray2, int *intarray3, int k, int len)
 
void SCIPselectWeightedIntIntInt (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int k, int len)
 
void SCIPselectWeightedIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int k, int len)
 
void SCIPselectWeightedIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLong (SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedLong (SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtr (SCIP_Longint *longarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedLongPtr (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int k, int len)
 
void SCIPselectWeightedLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int k, int len)
 
void SCIPselectWeightedLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int k, int len)
 
void SCIPselectWeightedLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int k, int len)
 
void SCIPselectWeightedLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
 
void SCIPselectWeightedLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int k, int len)
 
void SCIPselectWeightedLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int k, int len)
 
void SCIPselectWeightedIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len)
 
void SCIPselectWeightedDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownReal (SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedDownReal (SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealPtr (SCIP_Real *realarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealPtr (SCIP_Real *realarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealInt (SCIP_Real *realarray, int *intarray, int k, int len)
 
void SCIPselectDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedDownRealInt (SCIP_Real *realarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectWeightedDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, int k, int len)
 
void SCIPselectWeightedDownRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, int k, int len)
 
void SCIPselectWeightedDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
 
void SCIPselectWeightedDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int k, int len)
 
void SCIPselectWeightedDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int k, int len)
 
void SCIPselectWeightedDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int k, int len)
 
void SCIPselectWeightedDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownInt (int *intarray, int k, int len)
 
void SCIPselectWeightedDownInt (int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntInt (int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedDownIntInt (int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntPtr (int *intarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownIntPtr (int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntReal (int *intarray, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedDownIntReal (int *intarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, int k, int len)
 
void SCIPselectWeightedDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int k, int len)
 
void SCIPselectWeightedDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLong (SCIP_Longint *longarray, int k, int len)
 
void SCIPselectWeightedDownLong (SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtr (SCIP_Longint *longarray, void **ptrarray, int k, int len)
 
void SCIPselectWeightedDownLongPtr (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int k, int len)
 
void SCIPselectWeightedDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int k, int len)
 
void SCIPselectWeightedDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int k, int len)
 
void SCIPselectWeightedDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int k, int len)
 
void SCIPselectWeightedDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
 
void SCIPselectWeightedDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
 
void SCIPselectWeightedDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int k, int len)
 
void SCIPselectWeightedDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
void SCIPselectWeightedDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
void SCIPselectDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int k, int len)
 
void SCIPselectWeightedDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 

Function Documentation

◆ SCIPselectInd()

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

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

Parameters
indarraypointer to the index array to be sorted
dataptrpointer to data field that is given to the external compare method
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

Referenced by alnsFixMoreVariables().

◆ SCIPselectWeightedInd()

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

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

Parameters
indarraypointer to the index array to be sorted
dataptrpointer to data field that is given to the external compare method
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtr()

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

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

Parameters
ptrarraypointer array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

Referenced by doSeparation().

◆ SCIPselectWeightedPtr()

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

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

Parameters
ptrarraypointer array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtr()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtr()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrReal()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrReal()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrBool()

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

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

Parameters
ptrarraypointer array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrBool()

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

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

Parameters
ptrarraypointer array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrRealInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealRealInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarray1SCIP_Real array to be permuted in the same way
realarray2SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrRealRealInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarray1SCIP_Real array to be permuted in the same way
realarray2SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealBool()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrRealBool()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealReal()

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

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

Parameters
ptrarraypointer array to be sorted
realarray1first SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrRealReal()

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

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

Parameters
ptrarraypointer array to be sorted
realarray1first SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrReal()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrReal()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrRealIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrRealIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrRealInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrRealInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrRealBool()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrRealBool()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrLongInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrLongInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrPtrLongIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrPtrLongIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectReal()

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

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

Parameters
realarraySCIP_Real array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedReal()

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

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

Parameters
realarraySCIP_Real array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealBoolPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealBoolPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealIntLong()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealIntLong()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealIntPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealIntPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealPtr()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealRealPtr()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealPtrPtrInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealPtrPtrInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarrayint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealPtrPtrIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarray1int array to be sorted
intarray2int array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealPtrPtrIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarray1int array to be sorted
intarray2int array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealLongRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
longarraySCIP_Longint array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealLongRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
longarraySCIP_Longint array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealIntInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealRealIntInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealRealRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealRealRealPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealRealRealBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectRealRealRealBoolBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarray1SCIP_Bool array to be permuted in the same way
boolarray2SCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealRealRealBoolBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarray1SCIP_Bool array to be permuted in the same way
boolarray2SCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectInt()

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

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

Parameters
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedInt()

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

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

Parameters
intarrayint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtr()

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

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

Parameters
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntPtr()

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

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

Parameters
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntReal()

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

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

Parameters
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntReal()

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

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

Parameters
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
intarray3third int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
intarray3third int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntLong()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntIntLong()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntRealLong()

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

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

Parameters
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntRealLong()

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

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

Parameters
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtrReal()

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

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

Parameters
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayreal array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntPtrReal()

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

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

Parameters
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayreal array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtrIntReal()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntPtrIntReal()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLong()

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

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

Parameters
longarraySCIP_Longint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLong()

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

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

Parameters
longarraySCIP_Longint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtr()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtr()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrRealRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrRealRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrRealRealIntBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrRealRealIntBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrPtrIntInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrPtrIntInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectLongPtrPtrBoolInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLongPtrPtrBoolInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
intarrayint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectPtrIntIntBoolBool()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrIntIntBoolBool()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectIntPtrIntIntBoolBool()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedIntPtrIntIntBoolBool()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownInd()

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

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

Parameters
indarraypointer to the index array to be sorted
dataptrpointer to data field that is given to the external compare method
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

Referenced by alnsUnfixVariables().

◆ SCIPselectWeightedDownInd()

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

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

Parameters
indarraypointer to the index array to be sorted
dataptrpointer to data field that is given to the external compare method
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtr()

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

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

Parameters
ptrarraypointer array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtr()

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

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

Parameters
ptrarraypointer array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtr()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtr()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrReal()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrReal()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrBool()

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

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

Parameters
ptrarraypointer array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrBool()

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

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

Parameters
ptrarraypointer array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrRealInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrRealInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrRealBool()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrRealBool()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrReal()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrReal()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrRealIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrRealIntInt()

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

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

Parameters
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrRealInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrRealInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrRealBool()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrRealBool()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrLongInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrLongInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrPtrLongIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrPtrLongIntInt()

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

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

Parameters
ptrarray1first pointer array to be sorted
ptrarray2second pointer array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownReal()

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

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

Parameters
realarraySCIP_Real array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownReal()

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

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

Parameters
realarraySCIP_Real array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

Referenced by SCIPsolveConcurrent().

◆ SCIPselectDownRealIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectWeightedDownRealIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealBoolPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealBoolPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealIntLong()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealIntLong()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealIntPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealIntPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
intarrayint array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealInt()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
intarrayinteger array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealInt()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
intarrayinteger array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

Referenced by SCIPsolveKnapsackApproximatelyLT().

◆ SCIPselectDownRealRealPtr()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealPtr()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealPtrPtr()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealPtrPtr()

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

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

Parameters
realarray1first SCIP_Real array to be sorted
realarray2second SCIP_Real array to be permuted in the same way
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtrPtrInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealPtrPtrInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarrayint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtrPtrIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarray1int array to be sorted
intarray2int array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealPtrPtrIntInt()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
intarray1int array to be sorted
intarray2int array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealLongRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
longarraySCIP_Longint array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealLongRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
longarraySCIP_Longint array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

Referenced by SCIPsolveKnapsackApproximately().

◆ SCIPselectDownRealRealIntInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealIntInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealRealInt()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealRealPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealPtrPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealPtrPtr()

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

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

Parameters
realarraySCIP_Real array to be sorted
ptrarray1pointer array to be permuted in the same way
ptrarray2pointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealRealBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownRealRealRealBoolBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarray1SCIP_Bool array to be permuted in the same way
boolarray2SCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealRealBoolBoolPtr()

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

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

Parameters
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
realarray3SCIP_Real array to be permuted in the same way
boolarray1SCIP_Bool array to be permuted in the same way
boolarray2SCIP_Bool array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownInt()

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

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

Parameters
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownInt()

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

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

Parameters
intarrayint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntPtr()

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

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

Parameters
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntPtr()

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

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

Parameters
intarrayint array to be sorted
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntReal()

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

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

Parameters
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntReal()

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

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

Parameters
intarrayint array to be sorted
realarrayreal array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
intarray3third int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntIntInt()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
intarray3third int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntLong()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntIntLong()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
longarraySCIP_Longint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2second int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntIntIntPtr()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntIntIntReal()

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

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

Parameters
intarray1int array to be sorted
intarray2int array to be permuted in the same way
intarray3int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntPtrIntReal()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntPtrIntReal()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2int array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLong()

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

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

Parameters
longarraySCIP_Longint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLong()

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

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

Parameters
longarraySCIP_Longint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtr()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtr()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrRealRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrRealRealBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrRealRealIntBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrRealRealIntBool()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarraypointer array to be permuted in the same way
realarrayfirst SCIP_Real array to be permuted in the same way
realarray2second SCIP_Real array to be permuted in the same way
intarrayint array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrPtrInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarrayint array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrPtrIntInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrPtrIntInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownLongPtrPtrBoolInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLongPtrPtrBoolInt()

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

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

Parameters
longarraySCIP_Longint array to be sorted
ptrarray1first pointer array to be permuted in the same way
ptrarray2second pointer array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
intarrayint array to be sorted
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownPtrIntIntBoolBool()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtrIntIntBoolBool()

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

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

Parameters
ptrarraypointer array to be sorted
intarray1first int array to be permuted in the same way
intarray2second int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed

◆ SCIPselectDownIntPtrIntIntBoolBool()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownIntPtrIntIntBoolBool()

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

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

Parameters
intarray1int array to be sorted
ptrarraypointer array to be permuted in the same way
intarray2second int array to be permuted in the same way
intarray3thrid int array to be permuted in the same way
boolarray1first SCIP_Bool array to be permuted in the same way
boolarray2second SCIP_Bool array to be permuted in the same way
weights(optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1)
capacitythe maximum capacity that is exceeded by the median
lenlength of arrays
medianpospointer to store the index of the weighted median, or NULL, if not needed