  # 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, ..., 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, \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)

## ◆ SCIPselectInd()

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

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

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

Referenced by alnsFixMoreVariables().

## ◆ SCIPselectWeightedInd()

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

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

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

## ◆ SCIPselectPtr()

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

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

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

Referenced by doSeparation().

## ◆ SCIPselectWeightedPtr()

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

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

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

## ◆ SCIPselectPtrPtr()

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

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

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

## ◆ SCIPselectWeightedPtrPtr()

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

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

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

## ◆ SCIPselectPtrReal()

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

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

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

## ◆ SCIPselectWeightedPtrReal()

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

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

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

## ◆ SCIPselectPtrInt()

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

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

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

## ◆ SCIPselectWeightedPtrInt()

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

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

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

## ◆ SCIPselectPtrBool()

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

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

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

## ◆ SCIPselectWeightedPtrBool()

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

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

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

## ◆ SCIPselectPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrIntInt()

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

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

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

## ◆ SCIPselectPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedPtrRealInt()

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

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

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

## ◆ SCIPselectPtrRealRealInt()

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

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

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

## ◆ SCIPselectWeightedPtrRealRealInt()

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

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

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

## ◆ SCIPselectPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedPtrRealBool()

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

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

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

## ◆ SCIPselectPtrRealReal()

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

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

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

## ◆ SCIPselectWeightedPtrRealReal()

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

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

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

## ◆ SCIPselectPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrInt()

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

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

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

## ◆ SCIPselectPtrPtrReal()

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

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

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

## ◆ SCIPselectWeightedPtrPtrReal()

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

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

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

## ◆ SCIPselectPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrIntInt()

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

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

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

## ◆ SCIPselectPtrRealIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrRealIntInt()

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

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

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

## ◆ SCIPselectPtrPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrRealInt()

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

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

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

## ◆ SCIPselectPtrPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedPtrPtrRealBool()

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

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

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

## ◆ SCIPselectPtrPtrLongInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrLongInt()

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

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

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

## ◆ SCIPselectPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectReal()

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

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

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

## ◆ SCIPselectWeightedReal()

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

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

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

## ◆ SCIPselectRealPtr()

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

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

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

## ◆ SCIPselectWeightedRealPtr()

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

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

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

## ◆ SCIPselectRealInt()

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

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

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

## ◆ SCIPselectWeightedRealInt()

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

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

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

## ◆ SCIPselectRealIntInt()

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

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

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

## ◆ SCIPselectWeightedRealIntInt()

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

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

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

## ◆ SCIPselectRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedRealBoolPtr()

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

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

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

## ◆ SCIPselectRealIntLong()

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

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

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

## ◆ SCIPselectWeightedRealIntLong()

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

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

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

## ◆ SCIPselectRealIntPtr()

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

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

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

## ◆ SCIPselectWeightedRealIntPtr()

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

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

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

## ◆ SCIPselectRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealPtr()

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

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

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

## ◆ SCIPselectRealPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedRealPtrPtrInt()

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

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

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

## ◆ SCIPselectRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectRealLongRealInt()

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

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

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

## ◆ SCIPselectWeightedRealLongRealInt()

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

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

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

## ◆ SCIPselectRealRealIntInt()

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

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

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

## ◆ SCIPselectWeightedRealRealIntInt()

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

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

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

## ◆ SCIPselectRealRealRealInt()

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

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

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

## ◆ SCIPselectWeightedRealRealRealInt()

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

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

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

## ◆ SCIPselectRealRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealRealPtr()

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

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

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

## ◆ SCIPselectRealRealRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealRealBoolPtr()

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

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

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

## ◆ SCIPselectRealRealRealBoolBoolPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealRealBoolBoolPtr()

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

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

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

## ◆ SCIPselectInt()

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

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

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

## ◆ SCIPselectWeightedInt()

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

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

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

## ◆ SCIPselectIntInt()

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

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

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

## ◆ SCIPselectWeightedIntInt()

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

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

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

## ◆ SCIPselectIntPtr()

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

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

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

## ◆ SCIPselectWeightedIntPtr()

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

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

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

## ◆ SCIPselectIntReal()

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

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

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

## ◆ SCIPselectWeightedIntReal()

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

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

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

## ◆ SCIPselectIntIntInt()

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

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

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

## ◆ SCIPselectWeightedIntIntInt()

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

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

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

## ◆ SCIPselectIntIntLong()

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

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

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

## ◆ SCIPselectWeightedIntIntLong()

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

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

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

## ◆ SCIPselectIntRealLong()

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

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

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

## ◆ SCIPselectWeightedIntRealLong()

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

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

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

## ◆ SCIPselectIntIntPtr()

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

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

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

## ◆ SCIPselectWeightedIntIntPtr()

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

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

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

## ◆ SCIPselectIntIntReal()

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

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

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

## ◆ SCIPselectWeightedIntIntReal()

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

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

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

## ◆ SCIPselectIntPtrReal()

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

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

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

## ◆ SCIPselectWeightedIntPtrReal()

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

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

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

## ◆ SCIPselectIntIntIntPtr()

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

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

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

## ◆ SCIPselectWeightedIntIntIntPtr()

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

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

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

## ◆ SCIPselectIntIntIntReal()

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

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

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

## ◆ SCIPselectWeightedIntIntIntReal()

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

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

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

## ◆ SCIPselectIntPtrIntReal()

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

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

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

## ◆ SCIPselectWeightedIntPtrIntReal()

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

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

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

## ◆ SCIPselectLong()

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

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

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

## ◆ SCIPselectWeightedLong()

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

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

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

## ◆ SCIPselectLongPtr()

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

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

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

## ◆ SCIPselectWeightedLongPtr()

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

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

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

## ◆ SCIPselectLongPtrInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrInt()

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

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

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

## ◆ SCIPselectLongPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedLongPtrRealBool()

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

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

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

## ◆ SCIPselectLongPtrRealRealBool()

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

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

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

## ◆ SCIPselectWeightedLongPtrRealRealBool()

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

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

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

## ◆ SCIPselectLongPtrRealRealIntBool()

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

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

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

## ◆ SCIPselectWeightedLongPtrRealRealIntBool()

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

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

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

## ◆ SCIPselectLongPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrPtrInt()

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

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

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

## ◆ SCIPselectLongPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrPtrIntInt()

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

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

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

## ◆ SCIPselectLongPtrPtrBoolInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrPtrBoolInt()

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

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

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

## ◆ SCIPselectPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectWeightedPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectIntPtrIntIntBoolBool()

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

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

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedIntPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectDownInd()

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

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

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

Referenced by alnsUnfixVariables().

## ◆ SCIPselectWeightedDownInd()

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

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

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

## ◆ SCIPselectDownPtr()

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

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

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

## ◆ SCIPselectWeightedDownPtr()

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

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

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

## ◆ SCIPselectDownPtrPtr()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtr()

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

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

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

## ◆ SCIPselectDownPtrReal()

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

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

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

## ◆ SCIPselectWeightedDownPtrReal()

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

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

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

## ◆ SCIPselectDownPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrInt()

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

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

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

## ◆ SCIPselectDownPtrBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrBool()

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

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

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

## ◆ SCIPselectDownPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrIntInt()

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

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

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

## ◆ SCIPselectDownPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrRealInt()

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

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

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

## ◆ SCIPselectDownPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrRealBool()

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

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

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

## ◆ SCIPselectDownPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrInt()

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

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

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

## ◆ SCIPselectDownPtrPtrReal()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrReal()

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

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

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

## ◆ SCIPselectDownPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrIntInt()

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

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

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

## ◆ SCIPselectDownPtrRealIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrRealIntInt()

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

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

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

## ◆ SCIPselectDownPtrPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrRealInt()

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

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

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

## ◆ SCIPselectDownPtrPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrRealBool()

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

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

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

## ◆ SCIPselectDownPtrPtrLongInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrLongInt()

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

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

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

## ◆ SCIPselectDownPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectDownReal()

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

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

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

## ◆ SCIPselectWeightedDownReal()

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

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

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

## ◆ SCIPselectDownRealPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealPtr()

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

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

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

## ◆ SCIPselectDownRealInt()

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

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

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

Referenced by SCIPsolveConcurrent().

## ◆ SCIPselectDownRealIntInt()

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

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

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

## ◆ SCIPselectWeightedDownRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealIntInt()

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

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

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

## ◆ SCIPselectDownRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealBoolPtr()

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

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

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

## ◆ SCIPselectDownRealIntLong()

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

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

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

## ◆ SCIPselectWeightedDownRealIntLong()

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

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

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

## ◆ SCIPselectDownRealIntPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealIntPtr()

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

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

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

## ◆ SCIPselectDownRealRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealRealInt()

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

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

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

Referenced by SCIPsolveKnapsackApproximatelyLT().

## ◆ SCIPselectDownRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealPtr()

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

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

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

## ◆ SCIPselectDownRealRealPtrPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealPtrPtr()

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

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

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

## ◆ SCIPselectDownRealPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownRealPtrPtrInt()

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

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

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

## ◆ SCIPselectDownRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectDownRealLongRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealLongRealInt()

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

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

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

Referenced by SCIPsolveKnapsackApproximately(), and SCIPsolveKnapsackExactly().

## ◆ SCIPselectDownRealRealIntInt()

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

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

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

## ◆ SCIPselectWeightedDownRealRealIntInt()

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

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

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

## ◆ SCIPselectDownRealRealRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealRealRealInt()

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

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

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

## ◆ SCIPselectDownRealRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealRealPtr()

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

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

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

## ◆ SCIPselectDownRealPtrPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealPtrPtr()

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

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

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

## ◆ SCIPselectDownRealRealRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealRealBoolPtr()

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

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

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

## ◆ SCIPselectDownRealRealRealBoolBoolPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealRealBoolBoolPtr()

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

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

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

## ◆ SCIPselectDownInt()

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

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

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

## ◆ SCIPselectWeightedDownInt()

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

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

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

## ◆ SCIPselectDownIntInt()

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

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

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

## ◆ SCIPselectWeightedDownIntInt()

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

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

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

## ◆ SCIPselectDownIntPtr()

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

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

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

## ◆ SCIPselectWeightedDownIntPtr()

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

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

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

## ◆ SCIPselectDownIntReal()

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

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

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

## ◆ SCIPselectWeightedDownIntReal()

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

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

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

## ◆ SCIPselectDownIntIntInt()

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

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

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

## ◆ SCIPselectWeightedDownIntIntInt()

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

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

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

## ◆ SCIPselectDownIntIntLong()

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

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

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

## ◆ SCIPselectWeightedDownIntIntLong()

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

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

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

## ◆ SCIPselectDownIntIntPtr()

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

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

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

## ◆ SCIPselectWeightedDownIntIntPtr()

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

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

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

## ◆ SCIPselectDownIntIntReal()

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

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

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

## ◆ SCIPselectWeightedDownIntIntReal()

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

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

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

## ◆ SCIPselectDownIntIntIntPtr()

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

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

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

## ◆ SCIPselectWeightedDownIntIntIntPtr()

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

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

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

## ◆ SCIPselectDownIntIntIntReal()

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

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

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

## ◆ SCIPselectWeightedDownIntIntIntReal()

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

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

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

## ◆ SCIPselectDownIntPtrIntReal()

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

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

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

## ◆ SCIPselectWeightedDownIntPtrIntReal()

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

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

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

## ◆ SCIPselectDownLong()

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

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

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

## ◆ SCIPselectWeightedDownLong()

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

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

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

## ◆ SCIPselectDownLongPtr()

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

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

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

## ◆ SCIPselectWeightedDownLongPtr()

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

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

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

## ◆ SCIPselectDownLongPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrInt()

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

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

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

## ◆ SCIPselectDownLongPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrRealBool()

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

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

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

## ◆ SCIPselectDownLongPtrRealRealBool()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrRealRealBool()

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

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

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

## ◆ SCIPselectDownLongPtrRealRealIntBool()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrRealRealIntBool()

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

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

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

## ◆ SCIPselectDownLongPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrPtrInt()

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

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

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

## ◆ SCIPselectDownLongPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrPtrIntInt()

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

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

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

## ◆ SCIPselectDownLongPtrPtrBoolInt()

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

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

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

## ◆ SCIPselectWeightedDownLongPtrPtrBoolInt()

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

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

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

## ◆ SCIPselectDownPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectDownIntPtrIntIntBoolBool()

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

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

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntPtrIntIntBoolBool()

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

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

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