public methods for the selection of (weighted) k-median.
The methods in this group perform a selection of the (weighted) \( k \)-median from an unsorted array of elements. The necessary element swaps are performed in-place on the array of keys. The necessary permutations are also performed on up to six associated arrays.
For methods that perform complete in place sorting, see Sorting Algorithms.
For an array a containing n elements \( a[0], ..., a[n-1] \) and an integer \( 0 \leq k \leq n - 1 \) , we call an element \( a[i] \) \( k \)-median if there exists a permutation \( \pi \) of the array indices such that \( \pi(i) = k \) and \( a[\pi^{-1}(j)] \leq a[i] \) for \( j = 0, \dots, k-1 \) and \( a[\pi^{-1}(j)] > a[i] \) for \( j = k + 1,\dots,n - 1 \). The \( k \)-median is hence an element that would appear at position \( k \) after sorting the input array. Note that there may exist several \( k \)-medians if the array elements are not unique, only its key value \( a[i] \).
In order to determine the \( k \)-median, the algorithm selects a pivot element and determines the array position for this pivot like quicksort. In contrast to quicksort, however, one recursion can be saved during the selection process. After a single iteration that placed the pivot at position \( p \) , the algorithm either terminates if \( p = k \), or it continues in the left half of the array if \( p > k \), or in the right half of the array if \( p < k \).
After the algorithm terminates, the \( k \)-median can be accessed by accessing the array element at position \( k \).
A weighted median denotes the generalization of the \( k \)-median to arbitrary, nonnegative associated weights \( w[0], \dots, w[n-1] \in \mathbb{R}\) and a capacity \( 0 \leq C \in \mathbb{R} \). An element \( a[i] \) is called weighted median if there exists a permutation that satisfies the same weak sorting as above and in addition \( W:= \sum_{j = 0}^{k - 1}w[\pi^{-1}(j)] < C\), but \( W + w[i] \geq C\). In other words, the weighted median is the first element in the weak sorting such that its weight together with the sum of all preceding item weights reach or exceed the given capacity \( C \). If all weights are equal to \( 1 \) and the capacity is \( C = k + 0.5\), the weighted median becomes the \( k \)-median.
Functions | |
void | SCIPselectInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len) |
void | SCIPselectWeightedInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectPtrRealRealBoolBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectPtrRealRealIntBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrRealRealInt (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectWeightedPtrRealRealBoolBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectWeightedPtrRealRealIntBool (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrRealReal (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrRealReal (void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectReal (SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedReal (SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealPtr (SCIP_Real *realarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealPtr (SCIP_Real *realarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealInt (SCIP_Real *realarray, int *intarray, int k, int len) |
void | SCIPselectWeightedRealInt (SCIP_Real *realarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len) |
void | SCIPselectWeightedRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int k, int len) |
void | SCIPselectWeightedRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int k, int len) |
void | SCIPselectWeightedRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int k, int len) |
void | SCIPselectWeightedRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectInt (int *intarray, int k, int len) |
void | SCIPselectWeightedInt (int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntInt (int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedIntInt (int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntPtr (int *intarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedIntPtr (int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntReal (int *intarray, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedIntReal (int *intarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntIntInt (int *intarray1, int *intarray2, int *intarray3, int k, int len) |
void | SCIPselectWeightedIntIntInt (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedIntRealLong (int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int k, int len) |
void | SCIPselectWeightedIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedIntPtrReal (int *intarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int k, int len) |
void | SCIPselectWeightedIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLong (SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedLong (SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtr (SCIP_Longint *longarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedLongPtr (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int k, int len) |
void | SCIPselectWeightedLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int k, int len) |
void | SCIPselectWeightedLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int k, int len) |
void | SCIPselectWeightedLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int k, int len) |
void | SCIPselectWeightedLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len) |
void | SCIPselectWeightedLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int k, int len) |
void | SCIPselectWeightedLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int k, int len) |
void | SCIPselectWeightedIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len) |
void | SCIPselectWeightedDownInd (int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtr (void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtr (void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrReal (void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrInt (void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrBool (void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrIntInt (void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrRealInt (void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrRealBool (void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrInt (void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrReal (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrIntInt (void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrRealIntInt (void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrRealInt (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrRealBool (void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrLongInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrPtrLongIntInt (void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownReal (SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedDownReal (SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealPtr (SCIP_Real *realarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealPtr (SCIP_Real *realarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealInt (SCIP_Real *realarray, int *intarray, int k, int len) |
void | SCIPselectDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedDownRealInt (SCIP_Real *realarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectWeightedDownRealIntInt (SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealBoolPtr (SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedDownRealIntLong (SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealIntPtr (SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, int k, int len) |
void | SCIPselectWeightedDownRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, int k, int len) |
void | SCIPselectWeightedDownRealRealPtrPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len) |
void | SCIPselectWeightedDownRealPtrPtrInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedDownRealPtrPtrIntInt (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int k, int len) |
void | SCIPselectWeightedDownRealLongRealInt (SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedDownRealRealIntInt (SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int k, int len) |
void | SCIPselectWeightedDownRealRealRealInt (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealRealRealPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int k, int len) |
void | SCIPselectWeightedDownRealPtrPtr (SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealRealRealBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownRealRealRealBoolBoolPtr (SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownInt (int *intarray, int k, int len) |
void | SCIPselectWeightedDownInt (int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntInt (int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedDownIntInt (int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntPtr (int *intarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownIntPtr (int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntReal (int *intarray, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedDownIntReal (int *intarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, int k, int len) |
void | SCIPselectWeightedDownIntIntInt (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedDownIntIntLong (int *intarray1, int *intarray2, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownIntIntPtr (int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedDownIntIntReal (int *intarray1, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownIntIntIntPtr (int *intarray1, int *intarray2, int *intarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedDownIntIntIntReal (int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int k, int len) |
void | SCIPselectWeightedDownIntPtrIntReal (int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLong (SCIP_Longint *longarray, int k, int len) |
void | SCIPselectWeightedDownLong (SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtr (SCIP_Longint *longarray, void **ptrarray, int k, int len) |
void | SCIPselectWeightedDownLongPtr (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, int k, int len) |
void | SCIPselectWeightedDownLongPtrInt (SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int k, int len) |
void | SCIPselectWeightedDownLongPtrRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int k, int len) |
void | SCIPselectWeightedDownLongPtrRealRealBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int k, int len) |
void | SCIPselectWeightedDownLongPtrRealRealIntBool (SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len) |
void | SCIPselectWeightedDownLongPtrPtrInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len) |
void | SCIPselectWeightedDownLongPtrPtrIntInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int k, int len) |
void | SCIPselectWeightedDownLongPtrPtrBoolInt (SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len) |
void | SCIPselectWeightedDownPtrIntIntBoolBool (void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
void | SCIPselectDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int k, int len) |
void | SCIPselectWeightedDownIntPtrIntIntBoolBool (int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos) |
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.
indarray | pointer to the index array to be sorted |
dataptr | pointer to data field that is given to the external compare method |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
Referenced by alnsFixMoreVariables(), and LNSFixMoreVariables().
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.
indarray | pointer to the index array to be sorted |
dataptr | pointer to data field that is given to the external compare method |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
Referenced by doSeparation().
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.
ptrarray | pointer array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool.
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.
ptrarray | pointer array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray1 | SCIP_Real array to be permuted in the same way |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray1 | SCIP_Real array to be permuted in the same way |
realarray2 | SCIP_Real array to be permuted in the same way |
boolarray1 | SCIP_Bool array to be permuted in the same way |
boolarray2 | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
realarray1 | SCIP_Real array to be permuted in the same way |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
realarray1 | SCIP_Real array to be permuted in the same way |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray1 | SCIP_Real array to be permuted in the same way |
realarray2 | SCIP_Real array to be permuted in the same way |
boolarray1 | SCIP_Bool array to be permuted in the same way |
boolarray2 | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray | pointer array to be sorted |
realarray1 | SCIP_Real array to be permuted in the same way |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray | pointer array to be sorted |
realarray1 | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray1 | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
Referenced by solveSingleRowLP().
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.
realarray | SCIP_Real array to be sorted |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray1 | int array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray1 | int array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
realarray | SCIP_Real array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint, and SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray1 | int array to be sorted |
intarray2 | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray1 | int array to be sorted |
intarray2 | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
longarray | SCIP_Longint array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint, and SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
longarray | SCIP_Longint array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray1 | int array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray1 | int array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray1 | SCIP_Bool array to be permuted in the same way |
boolarray2 | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray1 | SCIP_Bool array to be permuted in the same way |
boolarray2 | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
intarray | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray | int array to be sorted |
realarray | real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray | int array to be sorted |
realarray | real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
intarray3 | third int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
intarray3 | third int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
intarray | int array to be sorted |
realarray | real array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint, and SCIP_Real.
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.
intarray | int array to be sorted |
realarray | real array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
intarray | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, and SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
intarray | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool.
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
intarray3 | thrid int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool.
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
intarray3 | thrid int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
indarray | pointer to the index array to be sorted |
dataptr | pointer to data field that is given to the external compare method |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
Referenced by alnsUnfixVariables(), and LNSUnfixVariables().
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.
indarray | pointer to the index array to be sorted |
dataptr | pointer to data field that is given to the external compare method |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool.
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.
ptrarray | pointer array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray | pointer array to be sorted |
realarray | SCIP_Real array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
ptrarray1 | first pointer array to be sorted |
ptrarray2 | second pointer array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
Referenced by SCIPsolveConcurrent().
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.
realarray | SCIP_Real array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
realarray | SCIP_Real array to be sorted |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint, and SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
intarray | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
intarray | integer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
intarray | integer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
Referenced by SCIPsolveKnapsackApproximatelyLT().
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.
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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
realarray1 | first SCIP_Real array to be sorted |
realarray2 | second SCIP_Real array to be permuted in the same way |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray1 | int array to be sorted |
intarray2 | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
intarray1 | int array to be sorted |
intarray2 | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
longarray | SCIP_Longint array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint, and SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
longarray | SCIP_Longint array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
Referenced by SCIPsolveKnapsackApproximately(), and SCIPsolveKnapsackExactly().
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray1 | int array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
intarray1 | int array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
realarray | SCIP_Real array to be sorted |
ptrarray1 | pointer array to be permuted in the same way |
ptrarray2 | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray1 | SCIP_Bool array to be permuted in the same way |
boolarray2 | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
realarray1 | SCIP_Real array to be sorted |
realarray2 | SCIP_Real array to be permuted in the same way |
realarray3 | SCIP_Real array to be permuted in the same way |
boolarray1 | SCIP_Bool array to be permuted in the same way |
boolarray2 | SCIP_Bool array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
intarray | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
Referenced by createSepaData().
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.
intarray | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray | int array to be sorted |
realarray | real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray | int array to be sorted |
realarray | real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
intarray3 | third int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
intarray3 | third int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
longarray | SCIP_Longint array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | second int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
intarray2 | int array to be permuted in the same way |
intarray3 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Real.
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | int array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray | pointer array to be permuted in the same way |
realarray | first SCIP_Real array to be permuted in the same way |
realarray2 | second SCIP_Real array to be permuted in the same way |
intarray | int array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray | int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Longint, and SCIP_Real.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
intarray | int array to be sorted |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool, and SCIP_Longint.
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.
longarray | SCIP_Longint array to be sorted |
ptrarray1 | first pointer array to be permuted in the same way |
ptrarray2 | second pointer array to be permuted in the same way |
boolarray | SCIP_Bool array to be permuted in the same way |
intarray | int array to be sorted |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
References SCIP_Bool, SCIP_Longint, and SCIP_Real.
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool.
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.
ptrarray | pointer array to be sorted |
intarray1 | first int array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
intarray3 | thrid int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
k | the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 |
len | length of arrays |
References SCIP_Bool.
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.
intarray1 | int array to be sorted |
ptrarray | pointer array to be permuted in the same way |
intarray2 | second int array to be permuted in the same way |
intarray3 | thrid int array to be permuted in the same way |
boolarray1 | first SCIP_Bool array to be permuted in the same way |
boolarray2 | second SCIP_Bool array to be permuted in the same way |
weights | (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) |
capacity | the maximum capacity that is exceeded by the median |
len | length of arrays |
medianpos | pointer to store the index of the weighted median, or NULL, if not needed |