# SCIP

Solving Constraint Integer Programs

Algorithms for (Weighted) Median Selection

## Detailed Description

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

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

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

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

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

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

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

## Functions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## ◆ SCIPselectInd()

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

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

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

Referenced by alnsFixMoreVariables().

## ◆ SCIPselectWeightedInd()

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

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

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

## ◆ SCIPselectPtr()

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

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

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

Referenced by doSeparation().

## ◆ SCIPselectWeightedPtr()

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

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

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

## ◆ SCIPselectPtrPtr()

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

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

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

## ◆ SCIPselectWeightedPtrPtr()

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

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

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

## ◆ SCIPselectPtrReal()

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

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

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

## ◆ SCIPselectWeightedPtrReal()

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

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

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

## ◆ SCIPselectPtrInt()

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

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

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

## ◆ SCIPselectWeightedPtrInt()

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

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

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

## ◆ SCIPselectPtrBool()

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

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

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

## ◆ SCIPselectWeightedPtrBool()

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

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

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

## ◆ SCIPselectPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrIntInt()

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

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

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

## ◆ SCIPselectPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedPtrRealInt()

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

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

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

## ◆ SCIPselectPtrRealRealInt()

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

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

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

## ◆ SCIPselectWeightedPtrRealRealInt()

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

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

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

## ◆ SCIPselectPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedPtrRealBool()

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

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

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

## ◆ SCIPselectPtrRealReal()

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

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

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

## ◆ SCIPselectWeightedPtrRealReal()

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

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

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

## ◆ SCIPselectPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrInt()

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

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

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

## ◆ SCIPselectPtrPtrReal()

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

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

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

## ◆ SCIPselectWeightedPtrPtrReal()

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

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

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

## ◆ SCIPselectPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrIntInt()

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

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

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

## ◆ SCIPselectPtrRealIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrRealIntInt()

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

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

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

## ◆ SCIPselectPtrPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrRealInt()

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

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

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

## ◆ SCIPselectPtrPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedPtrPtrRealBool()

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

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

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

## ◆ SCIPselectPtrPtrLongInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrLongInt()

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

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

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

## ◆ SCIPselectPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectWeightedPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectReal()

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

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

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

## ◆ SCIPselectWeightedReal()

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

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

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

## ◆ SCIPselectRealPtr()

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

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

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

## ◆ SCIPselectWeightedRealPtr()

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

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

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

## ◆ SCIPselectRealInt()

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

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

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

## ◆ SCIPselectWeightedRealInt()

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

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

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

## ◆ SCIPselectRealIntInt()

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

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

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

## ◆ SCIPselectWeightedRealIntInt()

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

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

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

## ◆ SCIPselectRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedRealBoolPtr()

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

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

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

## ◆ SCIPselectRealIntLong()

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

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

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

## ◆ SCIPselectWeightedRealIntLong()

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

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

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

## ◆ SCIPselectRealIntPtr()

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

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

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

## ◆ SCIPselectWeightedRealIntPtr()

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

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

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

## ◆ SCIPselectRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealPtr()

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

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

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

## ◆ SCIPselectRealPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedRealPtrPtrInt()

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

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

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

## ◆ SCIPselectRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectRealLongRealInt()

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

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

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

## ◆ SCIPselectWeightedRealLongRealInt()

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

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

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

## ◆ SCIPselectRealRealIntInt()

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

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

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

## ◆ SCIPselectWeightedRealRealIntInt()

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

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

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

## ◆ SCIPselectRealRealRealInt()

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

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

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

## ◆ SCIPselectWeightedRealRealRealInt()

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

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

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

## ◆ SCIPselectRealRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealRealPtr()

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

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

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

## ◆ SCIPselectRealRealRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealRealBoolPtr()

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

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

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

## ◆ SCIPselectRealRealRealBoolBoolPtr()

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

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

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

## ◆ SCIPselectWeightedRealRealRealBoolBoolPtr()

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

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

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

## ◆ SCIPselectInt()

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

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

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

## ◆ SCIPselectWeightedInt()

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

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

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

## ◆ SCIPselectIntInt()

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

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

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

## ◆ SCIPselectWeightedIntInt()

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

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

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

## ◆ SCIPselectIntPtr()

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

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

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

## ◆ SCIPselectWeightedIntPtr()

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

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

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

## ◆ SCIPselectIntReal()

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

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

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

## ◆ SCIPselectWeightedIntReal()

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

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

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

## ◆ SCIPselectIntIntInt()

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

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

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

## ◆ SCIPselectWeightedIntIntInt()

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

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

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

## ◆ SCIPselectIntIntLong()

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

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

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

## ◆ SCIPselectWeightedIntIntLong()

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

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

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

## ◆ SCIPselectIntRealLong()

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

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

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

## ◆ SCIPselectWeightedIntRealLong()

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

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

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

## ◆ SCIPselectIntIntPtr()

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

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

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

## ◆ SCIPselectWeightedIntIntPtr()

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

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

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

## ◆ SCIPselectIntIntReal()

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

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

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

## ◆ SCIPselectWeightedIntIntReal()

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

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

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

## ◆ SCIPselectIntPtrReal()

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

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

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

## ◆ SCIPselectWeightedIntPtrReal()

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

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

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

## ◆ SCIPselectIntIntIntPtr()

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

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

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

## ◆ SCIPselectWeightedIntIntIntPtr()

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

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

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

## ◆ SCIPselectIntIntIntReal()

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

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

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

## ◆ SCIPselectWeightedIntIntIntReal()

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

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

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

## ◆ SCIPselectIntPtrIntReal()

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

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

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

## ◆ SCIPselectWeightedIntPtrIntReal()

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

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

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

## ◆ SCIPselectLong()

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

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

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

## ◆ SCIPselectWeightedLong()

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

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

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

## ◆ SCIPselectLongPtr()

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

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

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

## ◆ SCIPselectWeightedLongPtr()

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

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

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

## ◆ SCIPselectLongPtrInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrInt()

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

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

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

## ◆ SCIPselectLongPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedLongPtrRealBool()

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

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

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

## ◆ SCIPselectLongPtrRealRealBool()

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

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

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

## ◆ SCIPselectWeightedLongPtrRealRealBool()

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

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

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

## ◆ SCIPselectLongPtrRealRealIntBool()

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

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

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

## ◆ SCIPselectWeightedLongPtrRealRealIntBool()

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

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

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

## ◆ SCIPselectLongPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrPtrInt()

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

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

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

## ◆ SCIPselectLongPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrPtrIntInt()

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

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

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

## ◆ SCIPselectLongPtrPtrBoolInt()

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

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

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

## ◆ SCIPselectWeightedLongPtrPtrBoolInt()

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

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

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

## ◆ SCIPselectPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectWeightedPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectIntPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectWeightedIntPtrIntIntBoolBool()

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

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

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

## ◆ SCIPselectDownInd()

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

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

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

Referenced by alnsUnfixVariables().

## ◆ SCIPselectWeightedDownInd()

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

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

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

## ◆ SCIPselectDownPtr()

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

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

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

## ◆ SCIPselectWeightedDownPtr()

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

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

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

## ◆ SCIPselectDownPtrPtr()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtr()

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

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

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

## ◆ SCIPselectDownPtrReal()

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

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

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

## ◆ SCIPselectWeightedDownPtrReal()

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

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

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

## ◆ SCIPselectDownPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrInt()

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

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

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

## ◆ SCIPselectDownPtrBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrBool()

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

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

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

## ◆ SCIPselectDownPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrIntInt()

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

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

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

## ◆ SCIPselectDownPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrRealInt()

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

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

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

## ◆ SCIPselectDownPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrRealBool()

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

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

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

## ◆ SCIPselectDownPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrInt()

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

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

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

## ◆ SCIPselectDownPtrPtrReal()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrReal()

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

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

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

## ◆ SCIPselectDownPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrIntInt()

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

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

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

## ◆ SCIPselectDownPtrRealIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrRealIntInt()

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

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

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

## ◆ SCIPselectDownPtrPtrRealInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrRealInt()

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

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

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

## ◆ SCIPselectDownPtrPtrRealBool()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrRealBool()

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

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

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

## ◆ SCIPselectDownPtrPtrLongInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrLongInt()

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

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

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

## ◆ SCIPselectDownPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectWeightedDownPtrPtrLongIntInt()

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

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

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

## ◆ SCIPselectDownReal()

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

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

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

## ◆ SCIPselectWeightedDownReal()

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

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

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

## ◆ SCIPselectDownRealPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealPtr()

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

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

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

## ◆ SCIPselectDownRealInt()

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

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

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

Referenced by SCIPsolveConcurrent().

## ◆ SCIPselectDownRealIntInt()

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

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

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

## ◆ SCIPselectWeightedDownRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealIntInt()

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

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

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

## ◆ SCIPselectDownRealBoolPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealBoolPtr()

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

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

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

## ◆ SCIPselectDownRealIntLong()

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

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

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

## ◆ SCIPselectWeightedDownRealIntLong()

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

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

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

## ◆ SCIPselectDownRealIntPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealIntPtr()

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

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

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

## ◆ SCIPselectDownRealRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealRealInt()

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

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

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

Referenced by SCIPsolveKnapsackApproximatelyLT().

## ◆ SCIPselectDownRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealPtr()

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

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

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

## ◆ SCIPselectDownRealRealPtrPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealPtrPtr()

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

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

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

## ◆ SCIPselectDownRealPtrPtrInt()

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

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

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

## ◆ SCIPselectWeightedDownRealPtrPtrInt()

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

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

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

## ◆ SCIPselectDownRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectWeightedDownRealPtrPtrIntInt()

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

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

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

## ◆ SCIPselectDownRealLongRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealLongRealInt()

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

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

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

Referenced by SCIPsolveKnapsackApproximately(), and SCIPsolveKnapsackExactly().

## ◆ SCIPselectDownRealRealIntInt()

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

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

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

## ◆ SCIPselectWeightedDownRealRealIntInt()

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

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

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

## ◆ SCIPselectDownRealRealRealInt()

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

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

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

## ◆ SCIPselectWeightedDownRealRealRealInt()

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

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

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

## ◆ SCIPselectDownRealRealRealPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealRealRealPtr()

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

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

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

## ◆ SCIPselectDownRealPtrPtr()

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

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

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

## ◆ SCIPselectWeightedDownRealPtrPtr()

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

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

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

## ◆ SCIPselectDownRealRealRealBoolPtr()

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

partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownRealRealRealBoolPtr()

 SCIP_EXPORT void SCIPselectWeightedDownRealRealRealBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray, void ** ptrarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownRealRealRealBoolBoolPtr()

 SCIP_EXPORT void SCIPselectDownRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, int k, int len )

partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray1 SCIP_Bool array to be permuted in the same way boolarray2 SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownRealRealRealBoolBoolPtr()

 SCIP_EXPORT void SCIPselectWeightedDownRealRealRealBoolBoolPtr ( SCIP_Real * realarray1, SCIP_Real * realarray2, SCIP_Real * realarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, void ** ptrarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 realarray1 SCIP_Real array to be sorted realarray2 SCIP_Real array to be permuted in the same way realarray3 SCIP_Real array to be permuted in the same way boolarray1 SCIP_Bool array to be permuted in the same way boolarray2 SCIP_Bool array to be permuted in the same way ptrarray pointer array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownInt()

 SCIP_EXPORT void SCIPselectDownInt ( int * intarray, int k, int len )

partial sort array of ints in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray int array to be sorted k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownInt()

 SCIP_EXPORT void SCIPselectWeightedDownInt ( int * intarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort array of ints in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray int array to be sorted weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntInt()

 SCIP_EXPORT void SCIPselectDownIntInt ( int * intarray1, int * intarray2, int k, int len )

partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntInt()

 SCIP_EXPORT void SCIPselectWeightedDownIntInt ( int * intarray1, int * intarray2, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntPtr()

 SCIP_EXPORT void SCIPselectDownIntPtr ( int * intarray, void ** ptrarray, int k, int len )

partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray int array to be sorted ptrarray pointer array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntPtr()

 SCIP_EXPORT void SCIPselectWeightedDownIntPtr ( int * intarray, void ** ptrarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray int array to be sorted ptrarray pointer array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntReal()

 SCIP_EXPORT void SCIPselectDownIntReal ( int * intarray, SCIP_Real * realarray, int k, int len )

partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray int array to be sorted realarray real array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntReal()

 SCIP_EXPORT void SCIPselectWeightedDownIntReal ( int * intarray, SCIP_Real * realarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray int array to be sorted realarray real array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntIntInt()

 SCIP_EXPORT void SCIPselectDownIntIntInt ( int * intarray1, int * intarray2, int * intarray3, int k, int len )

partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way intarray3 third int array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntIntInt()

 SCIP_EXPORT void SCIPselectWeightedDownIntIntInt ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way intarray3 third int array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntIntLong()

 SCIP_EXPORT void SCIPselectDownIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, int k, int len )

partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntIntLong()

 SCIP_EXPORT void SCIPselectWeightedDownIntIntLong ( int * intarray1, int * intarray2, SCIP_Longint * longarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way longarray SCIP_Longint array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntIntPtr()

 SCIP_EXPORT void SCIPselectDownIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, int k, int len )

partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way ptrarray pointer array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntIntPtr()

 SCIP_EXPORT void SCIPselectWeightedDownIntIntPtr ( int * intarray1, int * intarray2, void ** ptrarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way ptrarray pointer array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntIntReal()

 SCIP_EXPORT void SCIPselectDownIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, int k, int len )

partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntIntReal()

 SCIP_EXPORT void SCIPselectWeightedDownIntIntReal ( int * intarray1, int * intarray2, SCIP_Real * realarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 second int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntIntIntPtr()

 SCIP_EXPORT void SCIPselectDownIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, int k, int len )

partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way ptrarray pointer array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntIntIntPtr()

 SCIP_EXPORT void SCIPselectWeightedDownIntIntIntPtr ( int * intarray1, int * intarray2, int * intarray3, void ** ptrarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way ptrarray pointer array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntIntIntReal()

 SCIP_EXPORT void SCIPselectDownIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, int k, int len )

partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntIntIntReal()

 SCIP_EXPORT void SCIPselectWeightedDownIntIntIntReal ( int * intarray1, int * intarray2, int * intarray3, SCIP_Real * realarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted intarray2 int array to be permuted in the same way intarray3 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntPtrIntReal()

 SCIP_EXPORT void SCIPselectDownIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, int k, int len )

partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntPtrIntReal()

 SCIP_EXPORT void SCIPselectWeightedDownIntPtrIntReal ( int * intarray1, void ** ptrarray, int * intarray2, SCIP_Real * realarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 int array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLong()

 SCIP_EXPORT void SCIPselectDownLong ( SCIP_Longint * longarray, int k, int len )

partial sort an array of Longints in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLong()

 SCIP_EXPORT void SCIPselectWeightedDownLong ( SCIP_Longint * longarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort an array of Longints in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtr()

 SCIP_EXPORT void SCIPselectDownLongPtr ( SCIP_Longint * longarray, void ** ptrarray, int k, int len )

partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtr()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtr ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrInt()

 SCIP_EXPORT void SCIPselectDownLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, int k, int len )

partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way intarray int array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrInt()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrInt ( SCIP_Longint * longarray, void ** ptrarray, int * intarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way intarray int array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrRealBool()

 SCIP_EXPORT void SCIPselectDownLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, int k, int len )

partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrRealBool()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Bool * boolarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrRealRealBool()

 SCIP_EXPORT void SCIPselectDownLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, int k, int len )

partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrRealRealBool()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrRealRealBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, SCIP_Bool * boolarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrRealRealIntBool()

 SCIP_EXPORT void SCIPselectDownLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, int k, int len )

partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrRealRealIntBool()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrRealRealIntBool ( SCIP_Longint * longarray, void ** ptrarray, SCIP_Real * realarray, SCIP_Real * realarray2, int * intarray, SCIP_Bool * boolarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray pointer array to be permuted in the same way realarray first SCIP_Real array to be permuted in the same way realarray2 second SCIP_Real array to be permuted in the same way intarray int array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrPtrInt()

 SCIP_EXPORT void SCIPselectDownLongPtrPtrInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray, int k, int len )

partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray int array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrPtrInt()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrPtrInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray int array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrPtrIntInt()

 SCIP_EXPORT void SCIPselectDownLongPtrPtrIntInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, int k, int len )

partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrPtrIntInt()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrPtrIntInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, int * intarray1, int * intarray2, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownLongPtrPtrBoolInt()

 SCIP_EXPORT void SCIPselectDownLongPtrPtrBoolInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, SCIP_Bool * boolarray, int * intarray, int k, int len )

partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way intarray int array to be sorted k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownLongPtrPtrBoolInt()

 SCIP_EXPORT void SCIPselectWeightedDownLongPtrPtrBoolInt ( SCIP_Longint * longarray, void ** ptrarray1, void ** ptrarray2, SCIP_Bool * boolarray, int * intarray, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 longarray SCIP_Longint array to be sorted ptrarray1 first pointer array to be permuted in the same way ptrarray2 second pointer array to be permuted in the same way boolarray SCIP_Bool array to be permuted in the same way intarray int array to be sorted weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownPtrIntIntBoolBool()

 SCIP_EXPORT void SCIPselectDownPtrIntIntBoolBool ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , int k, int len )

partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownPtrIntIntBoolBool()

 SCIP_EXPORT void SCIPselectWeightedDownPtrIntIntBoolBool ( void ** ptrarray, int * intarray1, int * intarray2, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)) , SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 ptrarray pointer array to be sorted intarray1 first int array to be permuted in the same way intarray2 second int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed

## ◆ SCIPselectDownIntPtrIntIntBoolBool()

 SCIP_EXPORT void SCIPselectDownIntPtrIntIntBoolBool ( int * intarray1, void ** ptrarray, int * intarray2, int * intarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, int k, int len )

partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the k-th element, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way k the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 len length of arrays

## ◆ SCIPselectWeightedDownIntPtrIntIntBoolBool()

 SCIP_EXPORT void SCIPselectWeightedDownIntPtrIntIntBoolBool ( int * intarray1, void ** ptrarray, int * intarray2, int * intarray3, SCIP_Bool * boolarray1, SCIP_Bool * boolarray2, SCIP_Real * weights, SCIP_Real capacity, int len, int * medianpos )

partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the weighted median w.r.t. weights and capacity, see Algorithms for (Weighted) Median Selection for more information.

Parameters
 intarray1 int array to be sorted ptrarray pointer array to be permuted in the same way intarray2 second int array to be permuted in the same way intarray3 thrid int array to be permuted in the same way boolarray1 first SCIP_Bool array to be permuted in the same way boolarray2 second SCIP_Bool array to be permuted in the same way weights (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) capacity the maximum capacity that is exceeded by the median len length of arrays medianpos pointer to store the index of the weighted median, or NULL, if not needed