Scippy

SCIP

Solving Constraint Integer Programs

Algorithms for (Weighted) Median Selection

Detailed Description

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

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

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

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

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

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

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

Functions

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 SCIPselectPtrRealRealBoolBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
 
SCIP_EXPORT void SCIPselectPtrRealRealIntBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, 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 SCIPselectWeightedPtrRealRealBoolBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
SCIP_EXPORT void SCIPselectWeightedPtrRealRealIntBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
 
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)
 

Function Documentation

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

Referenced by alnsFixMoreVariables().

◆ SCIPselectWeightedInd()

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

◆ SCIPselectPtr()

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
ptrarraypointer array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

Referenced by doSeparation().

◆ SCIPselectWeightedPtr()

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

◆ SCIPselectPtrPtr()

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

◆ SCIPselectWeightedPtrPtr()

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

◆ SCIPselectPtrReal()

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

◆ SCIPselectWeightedPtrReal()

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

◆ SCIPselectPtrInt()

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

◆ SCIPselectWeightedPtrInt()

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

◆ SCIPselectPtrBool()

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

◆ SCIPselectWeightedPtrBool()

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

◆ SCIPselectPtrIntInt()

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

◆ SCIPselectWeightedPtrIntInt()

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

◆ SCIPselectPtrRealInt()

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

◆ SCIPselectWeightedPtrRealInt()

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

◆ SCIPselectPtrRealRealInt()

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

◆ SCIPselectPtrRealRealBoolBool()

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

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

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

◆ SCIPselectPtrRealRealIntBool()

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

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

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

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

◆ SCIPselectWeightedPtrRealRealBoolBool()

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

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

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

◆ SCIPselectWeightedPtrRealRealIntBool()

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

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

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

◆ 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
ptrarraypointer array to be sorted
realarraySCIP_Real array to be permuted in the same way
boolarraySCIP_Bool array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedPtrRealBool()

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

◆ SCIPselectPtrRealReal()

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

◆ SCIPselectWeightedPtrRealReal()

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

◆ SCIPselectPtrPtrInt()

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

◆ SCIPselectWeightedPtrPtrInt()

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

◆ SCIPselectPtrPtrReal()

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

◆ SCIPselectWeightedPtrPtrReal()

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

◆ SCIPselectPtrPtrIntInt()

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

◆ SCIPselectWeightedPtrPtrIntInt()

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

◆ SCIPselectPtrRealIntInt()

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

◆ SCIPselectWeightedPtrRealIntInt()

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

◆ SCIPselectPtrPtrRealInt()

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

◆ SCIPselectWeightedPtrPtrRealInt()

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

◆ SCIPselectPtrPtrRealBool()

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

◆ SCIPselectWeightedPtrPtrRealBool()

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

◆ SCIPselectPtrPtrLongInt()

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

◆ SCIPselectWeightedPtrPtrLongInt()

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

◆ SCIPselectPtrPtrLongIntInt()

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

◆ SCIPselectWeightedPtrPtrLongIntInt()

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

◆ SCIPselectReal()

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
realarraySCIP_Real array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedReal()

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

Referenced by solveSingleRowLP().

◆ 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
realarraySCIP_Real array to be sorted
ptrarraypointer array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedRealPtr()

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

◆ SCIPselectRealInt()

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

◆ SCIPselectWeightedRealInt()

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

◆ SCIPselectRealIntInt()

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

◆ SCIPselectWeightedRealIntInt()

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

◆ SCIPselectRealBoolPtr()

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

◆ SCIPselectWeightedRealBoolPtr()

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

◆ SCIPselectRealIntLong()

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

◆ SCIPselectWeightedRealIntLong()

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

◆ SCIPselectRealIntPtr()

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

◆ SCIPselectWeightedRealIntPtr()

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

◆ SCIPselectRealRealPtr()

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

◆ SCIPselectWeightedRealRealPtr()

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

◆ SCIPselectRealPtrPtrInt()

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

◆ SCIPselectWeightedRealPtrPtrInt()

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

◆ SCIPselectRealPtrPtrIntInt()

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

◆ SCIPselectWeightedRealPtrPtrIntInt()

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

◆ SCIPselectRealLongRealInt()

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

◆ SCIPselectWeightedRealLongRealInt()

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

◆ SCIPselectRealRealIntInt()

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

◆ SCIPselectWeightedRealRealIntInt()

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

◆ SCIPselectRealRealRealInt()

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

◆ SCIPselectWeightedRealRealRealInt()

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

◆ SCIPselectRealRealRealPtr()

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

◆ SCIPselectWeightedRealRealRealPtr()

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

◆ SCIPselectRealRealRealBoolPtr()

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

◆ SCIPselectWeightedRealRealRealBoolPtr()

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

◆ SCIPselectRealRealRealBoolBoolPtr()

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

◆ SCIPselectWeightedRealRealRealBoolBoolPtr()

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

◆ SCIPselectInt()

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
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedInt()

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

◆ SCIPselectIntInt()

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

◆ SCIPselectWeightedIntInt()

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

◆ SCIPselectIntPtr()

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

◆ SCIPselectWeightedIntPtr()

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

◆ SCIPselectIntReal()

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

◆ SCIPselectWeightedIntReal()

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

◆ SCIPselectIntIntInt()

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

◆ SCIPselectWeightedIntIntInt()

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

◆ SCIPselectIntIntLong()

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

◆ SCIPselectWeightedIntIntLong()

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

◆ SCIPselectIntRealLong()

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

◆ SCIPselectWeightedIntRealLong()

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

◆ SCIPselectIntIntPtr()

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

◆ SCIPselectWeightedIntIntPtr()

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

◆ SCIPselectIntIntReal()

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

◆ SCIPselectWeightedIntIntReal()

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

◆ SCIPselectIntPtrReal()

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

◆ SCIPselectWeightedIntPtrReal()

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

◆ SCIPselectIntIntIntPtr()

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

◆ SCIPselectWeightedIntIntIntPtr()

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

◆ SCIPselectIntIntIntReal()

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

◆ SCIPselectWeightedIntIntIntReal()

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

◆ SCIPselectIntPtrIntReal()

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

◆ SCIPselectWeightedIntPtrIntReal()

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

◆ SCIPselectLong()

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
longarraySCIP_Longint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedLong()

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

◆ SCIPselectLongPtr()

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

◆ SCIPselectWeightedLongPtr()

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

◆ SCIPselectLongPtrInt()

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

◆ SCIPselectWeightedLongPtrInt()

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

◆ SCIPselectLongPtrRealBool()

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

◆ SCIPselectWeightedLongPtrRealBool()

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

◆ SCIPselectLongPtrRealRealBool()

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

◆ SCIPselectWeightedLongPtrRealRealBool()

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

◆ SCIPselectLongPtrRealRealIntBool()

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

◆ SCIPselectWeightedLongPtrRealRealIntBool()

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

◆ SCIPselectLongPtrPtrInt()

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

◆ SCIPselectWeightedLongPtrPtrInt()

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

◆ SCIPselectLongPtrPtrIntInt()

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

◆ SCIPselectWeightedLongPtrPtrIntInt()

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

◆ SCIPselectLongPtrPtrBoolInt()

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

◆ SCIPselectWeightedLongPtrPtrBoolInt()

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

◆ SCIPselectPtrIntIntBoolBool()

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

◆ SCIPselectWeightedPtrIntIntBoolBool()

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

◆ SCIPselectIntPtrIntIntBoolBool()

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

◆ SCIPselectWeightedIntPtrIntIntBoolBool()

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

◆ SCIPselectDownInd()

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

Referenced by alnsUnfixVariables().

◆ SCIPselectWeightedDownInd()

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

◆ SCIPselectDownPtr()

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
ptrarraypointer array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownPtr()

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

◆ SCIPselectDownPtrPtr()

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

◆ SCIPselectWeightedDownPtrPtr()

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

◆ SCIPselectDownPtrReal()

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

◆ SCIPselectWeightedDownPtrReal()

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

◆ SCIPselectDownPtrInt()

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

◆ SCIPselectWeightedDownPtrInt()

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

◆ SCIPselectDownPtrBool()

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

◆ SCIPselectWeightedDownPtrBool()

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

◆ SCIPselectDownPtrIntInt()

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

◆ SCIPselectWeightedDownPtrIntInt()

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

◆ SCIPselectDownPtrRealInt()

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

◆ SCIPselectWeightedDownPtrRealInt()

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

◆ SCIPselectDownPtrRealBool()

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

◆ SCIPselectWeightedDownPtrRealBool()

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

◆ SCIPselectDownPtrPtrInt()

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

◆ SCIPselectWeightedDownPtrPtrInt()

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

◆ SCIPselectDownPtrPtrReal()

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

◆ SCIPselectWeightedDownPtrPtrReal()

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

◆ SCIPselectDownPtrPtrIntInt()

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

◆ SCIPselectWeightedDownPtrPtrIntInt()

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

◆ SCIPselectDownPtrRealIntInt()

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

◆ SCIPselectWeightedDownPtrRealIntInt()

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

◆ SCIPselectDownPtrPtrRealInt()

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

◆ SCIPselectWeightedDownPtrPtrRealInt()

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

◆ SCIPselectDownPtrPtrRealBool()

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

◆ SCIPselectWeightedDownPtrPtrRealBool()

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

◆ SCIPselectDownPtrPtrLongInt()

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

◆ SCIPselectWeightedDownPtrPtrLongInt()

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

◆ SCIPselectDownPtrPtrLongIntInt()

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

◆ SCIPselectWeightedDownPtrPtrLongIntInt()

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

◆ SCIPselectDownReal()

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
realarraySCIP_Real array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownReal()

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

◆ SCIPselectDownRealPtr()

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

◆ SCIPselectWeightedDownRealPtr()

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

◆ SCIPselectDownRealInt()

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

Referenced by SCIPsolveConcurrent().

◆ SCIPselectDownRealIntInt()

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

◆ SCIPselectWeightedDownRealInt()

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

◆ SCIPselectWeightedDownRealIntInt()

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

◆ SCIPselectDownRealBoolPtr()

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

◆ SCIPselectWeightedDownRealBoolPtr()

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

◆ SCIPselectDownRealIntLong()

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

◆ SCIPselectWeightedDownRealIntLong()

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

◆ SCIPselectDownRealIntPtr()

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

◆ SCIPselectWeightedDownRealIntPtr()

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

◆ SCIPselectDownRealRealInt()

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

◆ SCIPselectWeightedDownRealRealInt()

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

Referenced by SCIPsolveKnapsackApproximatelyLT().

◆ SCIPselectDownRealRealPtr()

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

◆ SCIPselectWeightedDownRealRealPtr()

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

◆ SCIPselectDownRealRealPtrPtr()

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

◆ SCIPselectWeightedDownRealRealPtrPtr()

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

◆ SCIPselectDownRealPtrPtrInt()

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

◆ SCIPselectWeightedDownRealPtrPtrInt()

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

◆ SCIPselectDownRealPtrPtrIntInt()

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

◆ SCIPselectWeightedDownRealPtrPtrIntInt()

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

◆ SCIPselectDownRealLongRealInt()

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

◆ SCIPselectWeightedDownRealLongRealInt()

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

Referenced by SCIPsolveKnapsackApproximately(), 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
realarray1SCIP_Real array to be sorted
realarray2SCIP_Real array to be permuted in the same way
intarray1int array to be permuted in the same way
intarray2int array to be permuted in the same way
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownRealRealIntInt()

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

◆ SCIPselectDownRealRealRealInt()

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

◆ SCIPselectWeightedDownRealRealRealInt()

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

◆ SCIPselectDownRealRealRealPtr()

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

◆ SCIPselectWeightedDownRealRealRealPtr()

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

◆ SCIPselectDownRealPtrPtr()

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

◆ SCIPselectWeightedDownRealPtrPtr()

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

◆ SCIPselectDownRealRealRealBoolPtr()

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

◆ SCIPselectWeightedDownRealRealRealBoolPtr()

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

◆ SCIPselectDownRealRealRealBoolBoolPtr()

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

◆ SCIPselectWeightedDownRealRealRealBoolBoolPtr()

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

◆ SCIPselectDownInt()

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
intarrayint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownInt()

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

◆ SCIPselectDownIntInt()

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

◆ SCIPselectWeightedDownIntInt()

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

◆ SCIPselectDownIntPtr()

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

◆ SCIPselectWeightedDownIntPtr()

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

◆ SCIPselectDownIntReal()

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

◆ SCIPselectWeightedDownIntReal()

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

◆ SCIPselectDownIntIntInt()

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

◆ SCIPselectWeightedDownIntIntInt()

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

◆ SCIPselectDownIntIntLong()

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

◆ SCIPselectWeightedDownIntIntLong()

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

◆ SCIPselectDownIntIntPtr()

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

◆ SCIPselectWeightedDownIntIntPtr()

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

◆ SCIPselectDownIntIntReal()

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

◆ SCIPselectWeightedDownIntIntReal()

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

◆ SCIPselectDownIntIntIntPtr()

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

◆ SCIPselectWeightedDownIntIntIntPtr()

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

◆ SCIPselectDownIntIntIntReal()

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

◆ SCIPselectWeightedDownIntIntIntReal()

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

◆ SCIPselectDownIntPtrIntReal()

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

◆ SCIPselectWeightedDownIntPtrIntReal()

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

◆ SCIPselectDownLong()

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
longarraySCIP_Longint array to be sorted
kthe index of the desired element, must be between 0 (search for maximum/minimum) and len - 1
lenlength of arrays

◆ SCIPselectWeightedDownLong()

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

◆ SCIPselectDownLongPtr()

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

◆ SCIPselectWeightedDownLongPtr()

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

◆ SCIPselectDownLongPtrInt()

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

◆ SCIPselectWeightedDownLongPtrInt()

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

◆ SCIPselectDownLongPtrRealBool()

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

◆ SCIPselectWeightedDownLongPtrRealBool()

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

◆ SCIPselectDownLongPtrRealRealBool()

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

◆ SCIPselectWeightedDownLongPtrRealRealBool()

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

◆ SCIPselectDownLongPtrRealRealIntBool()

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

◆ SCIPselectWeightedDownLongPtrRealRealIntBool()

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

◆ SCIPselectDownLongPtrPtrInt()

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

◆ SCIPselectWeightedDownLongPtrPtrInt()

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

◆ SCIPselectDownLongPtrPtrIntInt()

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

◆ SCIPselectWeightedDownLongPtrPtrIntInt()

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

◆ SCIPselectDownLongPtrPtrBoolInt()

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

◆ SCIPselectWeightedDownLongPtrPtrBoolInt()

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

◆ SCIPselectDownPtrIntIntBoolBool()

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

◆ SCIPselectWeightedDownPtrIntIntBoolBool()

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

◆ SCIPselectDownIntPtrIntIntBoolBool()

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

◆ SCIPselectWeightedDownIntPtrIntIntBoolBool()

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