Scippy

    SCIP

    Solving Constraint Integer Programs

    pub_misc_select.h
    Go to the documentation of this file.
    1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    2/* */
    3/* This file is part of the program and library */
    4/* SCIP --- Solving Constraint Integer Programs */
    5/* */
    6/* Copyright (c) 2002-2025 Zuse Institute Berlin (ZIB) */
    7/* */
    8/* Licensed under the Apache License, Version 2.0 (the "License"); */
    9/* you may not use this file except in compliance with the License. */
    10/* You may obtain a copy of the License at */
    11/* */
    12/* http://www.apache.org/licenses/LICENSE-2.0 */
    13/* */
    14/* Unless required by applicable law or agreed to in writing, software */
    15/* distributed under the License is distributed on an "AS IS" BASIS, */
    16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
    17/* See the License for the specific language governing permissions and */
    18/* limitations under the License. */
    19/* */
    20/* You should have received a copy of the Apache-2.0 license */
    21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
    22/* */
    23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    24
    25/**@file pub_misc_select.h
    26 * @ingroup PUBLICCOREAPI
    27 * @brief methods for selecting (weighted) k-medians
    28 * @author Gregor Hendel
    29 *
    30 * This file contains headers for selecting (weighted) k-medians
    31 */
    32
    33/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
    34
    35#ifndef __SCIP_PUB_MISC_SELECT_H__
    36#define __SCIP_PUB_MISC_SELECT_H__
    37
    38#include "scip/def.h"
    39#include "scip/type_misc.h"
    40#include "scip/intervalarith.h"
    41
    42#ifdef __cplusplus
    43extern "C" {
    44#endif
    45
    46/*
    47 * Selection and weighted selection algorithms
    48 */
    49
    50/**@defgroup SelectionAlgorithms Algorithms for (Weighted) Median Selection
    51 * @ingroup MiscellaneousMethods
    52 * @brief public methods for the selection of (weighted) k-median.
    53 *
    54 * The methods in this group perform a selection of the (weighted) \f$ k \f$-median from an unsorted array of elements.
    55 * The necessary element swaps are performed in-place on the array of keys.
    56 * The necessary permutations are also performed on up to six associated arrays.
    57 *
    58 * For methods that perform complete in place sorting, see \ref SortingAlgorithms.
    59 *
    60 * For an array a containing n elements \f$ a[0], ..., a[n-1] \f$ and an integer \f$ 0 \leq k \leq n - 1 \f$ , we call an element
    61 * \f$ a[i] \f$ \f$ k \f$-median if
    62 * there exists a permutation \f$ \pi \f$ of the array indices such that \f$ \pi(i) = k \f$
    63 * and \f$ a[\pi^{-1}(j)] \leq a[i] \f$
    64 * for \f$ j = 0, \dots, k-1 \f$ and \f$ a[\pi^{-1}(j)] > a[i] \f$ for \f$ j = k + 1,\dots,n - 1 \f$.
    65 * The \f$ k \f$-median is hence an element that would appear at position \f$ k \f$ after sorting the input array.
    66 * Note that there may exist several \f$ k \f$-medians if the array elements are not unique, only its key value \f$ a[i] \f$.
    67 *
    68 * In order to determine the \f$ k \f$-median, the algorithm selects a pivot element and determines the array position for
    69 * this pivot like quicksort. In contrast to quicksort, however, one recursion can be saved during the selection process.
    70 * After a single iteration that placed the pivot at position \f$ p \f$ , the algorithm either terminates if \f$ p = k \f$,
    71 * or it continues in the left half of the array if \f$ p > k \f$, or in the right half of the array if \f$ p < k \f$.
    72 *
    73 * After the algorithm terminates, the \f$ k \f$-median can be accessed by accessing the array element at position \f$ k \f$.
    74 *
    75 * A weighted median denotes the generalization of the \f$ k \f$-median to arbitrary, nonnegative associated
    76 * weights \f$ w[0], \dots, w[n-1] \in \mathbb{R}\f$ and a capacity \f$ 0 \leq C \in \mathbb{R} \f$. An element \f$ a[i] \f$
    77 * is called weighted median if there exists a permutation that satisfies the same weak sorting as above and in addition
    78 * \f$ W:= \sum_{j = 0}^{k - 1}w[\pi^{-1}(j)] < C\f$, but \f$ W + w[i] \geq C\f$. In other words, the weighted median
    79 * is the first element in the weak sorting such that its weight together with the sum of all preceding item weights
    80 * reach or exceed the given capacity \f$ C \f$. If all weights are equal to \f$ 1 \f$ and the capacity is \f$ C = k + 0.5\f$,
    81 * the weighted median becomes the \f$ k \f$-median.
    82 *
    83 * @{
    84 */
    85
    86/** partial sort an index array in non-decreasing order around the \p k-th element,
    87 * see \ref SelectionAlgorithms for more information.
    88 */
    89SCIP_EXPORT
    90void SCIPselectInd(
    91 int* indarray, /**< pointer to the index array to be sorted */
    92 SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
    93 void* dataptr, /**< pointer to data field that is given to the external compare method */
    94 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    95 int len /**< length of arrays */
    96 );
    97
    98
    99/** partial sort an index array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    100 * see \ref SelectionAlgorithms for more information.
    101 */
    102SCIP_EXPORT
    103void SCIPselectWeightedInd(
    104 int* indarray, /**< pointer to the index array to be sorted */
    105 SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
    106 void* dataptr, /**< pointer to data field that is given to the external compare method */
    107 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    108 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    109 int len, /**< length of arrays */
    110 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    111 );
    112
    113
    114/** partial sort of an array of pointers in non-decreasing order around the \p k-th element,
    115 * see \ref SelectionAlgorithms for more information.
    116 */
    117SCIP_EXPORT
    118void SCIPselectPtr(
    119 void** ptrarray, /**< pointer array to be sorted */
    120 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    121 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    122 int len /**< length of arrays */
    123 );
    124
    125
    126/** partial sort of an array of pointers in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    127 * see \ref SelectionAlgorithms for more information.
    128 */
    129SCIP_EXPORT
    130void SCIPselectWeightedPtr(
    131 void** ptrarray, /**< pointer array to be sorted */
    132 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    133 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    134 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    135 int len, /**< length of arrays */
    136 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    137 );
    138
    139
    140/** partial sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    141 * see \ref SelectionAlgorithms for more information.
    142 */
    143SCIP_EXPORT
    144void SCIPselectPtrPtr(
    145 void** ptrarray1, /**< first pointer array to be sorted */
    146 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    147 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    148 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    149 int len /**< length of arrays */
    150 );
    151
    152
    153/** partial sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    154 * see \ref SelectionAlgorithms for more information.
    155 */
    156SCIP_EXPORT
    157void SCIPselectWeightedPtrPtr(
    158 void** ptrarray1, /**< first pointer array to be sorted */
    159 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    160 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    161 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    162 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    163 int len, /**< length of arrays */
    164 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    165 );
    166
    167
    168/** partial sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order around the \p k-th element,
    169 * see \ref SelectionAlgorithms for more information.
    170 */
    171SCIP_EXPORT
    172void SCIPselectPtrReal(
    173 void** ptrarray, /**< pointer array to be sorted */
    174 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    175 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    176 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    177 int len /**< length of arrays */
    178 );
    179
    180
    181/** partial sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    182 * see \ref SelectionAlgorithms for more information.
    183 */
    184SCIP_EXPORT
    185void SCIPselectWeightedPtrReal(
    186 void** ptrarray, /**< pointer array to be sorted */
    187 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    188 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    189 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    190 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    191 int len, /**< length of arrays */
    192 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    193 );
    194
    195
    196/** partial sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order around the \p k-th element,
    197 * see \ref SelectionAlgorithms for more information.
    198 */
    199SCIP_EXPORT
    200void SCIPselectPtrInt(
    201 void** ptrarray, /**< pointer array to be sorted */
    202 int* intarray, /**< int array to be permuted in the same way */
    203 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    204 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    205 int len /**< length of arrays */
    206 );
    207
    208
    209/** partial sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    210 * see \ref SelectionAlgorithms for more information.
    211 */
    212SCIP_EXPORT
    213void SCIPselectWeightedPtrInt(
    214 void** ptrarray, /**< pointer array to be sorted */
    215 int* intarray, /**< int array to be permuted in the same way */
    216 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    217 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    218 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    219 int len, /**< length of arrays */
    220 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    221 );
    222
    223
    224/** partial sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order around the \p k-th element,
    225 * see \ref SelectionAlgorithms for more information.
    226 */
    227SCIP_EXPORT
    228void SCIPselectPtrBool(
    229 void** ptrarray, /**< pointer array to be sorted */
    230 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    231 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    232 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    233 int len /**< length of arrays */
    234 );
    235
    236
    237/** partial sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    238 * see \ref SelectionAlgorithms for more information.
    239 */
    240SCIP_EXPORT
    241void SCIPselectWeightedPtrBool(
    242 void** ptrarray, /**< pointer array to be sorted */
    243 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    244 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    245 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    246 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    247 int len, /**< length of arrays */
    248 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    249 );
    250
    251
    252/** partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    253 * see \ref SelectionAlgorithms for more information.
    254 */
    255SCIP_EXPORT
    256void SCIPselectPtrIntInt(
    257 void** ptrarray, /**< pointer array to be sorted */
    258 int* intarray1, /**< first int array to be permuted in the same way */
    259 int* intarray2, /**< second int array to be permuted in the same way */
    260 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    261 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    262 int len /**< length of arrays */
    263 );
    264
    265
    266/** 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. \p weights and capacity,
    267 * see \ref SelectionAlgorithms for more information.
    268 */
    269SCIP_EXPORT
    270void SCIPselectWeightedPtrIntInt(
    271 void** ptrarray, /**< pointer array to be sorted */
    272 int* intarray1, /**< first int array to be permuted in the same way */
    273 int* intarray2, /**< second int array to be permuted in the same way */
    274 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    275 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    276 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    277 int len, /**< length of arrays */
    278 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    279 );
    280
    281
    282/** partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element,
    283 * see \ref SelectionAlgorithms for more information.
    284 */
    285SCIP_EXPORT
    286void SCIPselectPtrRealInt(
    287 void** ptrarray, /**< pointer array to be sorted */
    288 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    289 int* intarray, /**< int array to be permuted in the same way */
    290 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    291 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    292 int len /**< length of arrays */
    293 );
    294
    295
    296/** 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. \p weights and capacity,
    297 * see \ref SelectionAlgorithms for more information.
    298 */
    299SCIP_EXPORT
    300void SCIPselectWeightedPtrRealInt(
    301 void** ptrarray, /**< pointer array to be sorted */
    302 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    303 int* intarray, /**< int array to be permuted in the same way */
    304 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    305 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    306 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    307 int len, /**< length of arrays */
    308 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    309 );
    310
    311
    312/** partial sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element,
    313 * see \ref SelectionAlgorithms for more information.
    314 */
    315SCIP_EXPORT
    316void SCIPselectPtrRealRealInt(
    317 void** ptrarray, /**< pointer array to be sorted */
    318 SCIP_Real* realarray1, /**< SCIP_Real array to be permuted in the same way */
    319 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    320 int* intarray, /**< int array to be permuted in the same way */
    321 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    322 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    323 int len /**< length of arrays */
    324 );
    325
    326
    327/** partial sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order around the \p k-th element,
    328 * see \ref SelectionAlgorithms for more information.
    329 */
    330SCIP_EXPORT
    331void SCIPselectPtrRealRealBoolBool(
    332 void** ptrarray, /**< pointer array to be sorted */
    333 SCIP_Real* realarray1, /**< SCIP_Real array to be permuted in the same way */
    334 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    335 SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
    336 SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
    337 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    338 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    339 int len /**< length of arrays */
    340 );
    341
    342
    343/** partial sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order around the \p k-th element,
    344 * see \ref SelectionAlgorithms for more information.
    345 */
    346SCIP_EXPORT
    347void SCIPselectPtrRealRealIntBool(
    348 void** ptrarray, /**< pointer array to be sorted */
    349 SCIP_Real* realarray1, /**< SCIP_Real array to be permuted in the same way */
    350 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    351 int* intarray, /**< int array to be permuted in the same way */
    352 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    353 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    354 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    355 int len /**< length of arrays */
    356 );
    357
    358
    359/** 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. \p weights and capacity,
    360 * see \ref SelectionAlgorithms for more information.
    361 */
    362SCIP_EXPORT
    363void SCIPselectWeightedPtrRealRealInt(
    364 void** ptrarray, /**< pointer array to be sorted */
    365 SCIP_Real* realarray1, /**< SCIP_Real array to be permuted in the same way */
    366 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    367 int* intarray, /**< int array to be permuted in the same way */
    368 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    369 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    370 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    371 int len, /**< length of arrays */
    372 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    373 );
    374
    375
    376/** 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. \p weights and capacity,
    377 * see \ref SelectionAlgorithms for more information.
    378 */
    379SCIP_EXPORT
    380void SCIPselectWeightedPtrRealRealBoolBool(
    381 void** ptrarray, /**< pointer array to be sorted */
    382 SCIP_Real* realarray1, /**< SCIP_Real array to be permuted in the same way */
    383 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    384 SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
    385 SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
    386 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    387 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    388 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    389 int len, /**< length of arrays */
    390 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    391 );
    392
    393
    394/** 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. \p weights and capacity,
    395 * see \ref SelectionAlgorithms for more information.
    396 */
    397SCIP_EXPORT
    398void SCIPselectWeightedPtrRealRealIntBool(
    399 void** ptrarray, /**< pointer array to be sorted */
    400 SCIP_Real* realarray1, /**< SCIP_Real array to be permuted in the same way */
    401 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    402 int* intarray, /**< int array to be permuted in the same way */
    403 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    404 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    405 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    406 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    407 int len, /**< length of arrays */
    408 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    409 );
    410
    411
    412/** partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order around the \p k-th element,
    413 * see \ref SelectionAlgorithms for more information.
    414 */
    415SCIP_EXPORT
    416void SCIPselectPtrRealBool(
    417 void** ptrarray, /**< pointer array to be sorted */
    418 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    419 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    420 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    421 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    422 int len /**< length of arrays */
    423 );
    424
    425
    426/** 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. \p weights and capacity,
    427 * see \ref SelectionAlgorithms for more information.
    428 */
    429SCIP_EXPORT
    430void SCIPselectWeightedPtrRealBool(
    431 void** ptrarray, /**< pointer array to be sorted */
    432 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    433 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    434 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    435 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    436 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    437 int len, /**< length of arrays */
    438 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    439 );
    440
    441
    442/** partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order around the \p k-th element,
    443 * see \ref SelectionAlgorithms for more information.
    444 */
    445SCIP_EXPORT
    446void SCIPselectPtrPtrInt(
    447 void** ptrarray1, /**< first pointer array to be sorted */
    448 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    449 int* intarray, /**< int array to be permuted in the same way */
    450 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    451 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    452 int len /**< length of arrays */
    453 );
    454
    455
    456/** 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. \p weights and capacity,
    457 * see \ref SelectionAlgorithms for more information.
    458 */
    459SCIP_EXPORT
    460void SCIPselectWeightedPtrPtrInt(
    461 void** ptrarray1, /**< first pointer array to be sorted */
    462 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    463 int* intarray, /**< int array to be permuted in the same way */
    464 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    465 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    466 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    467 int len, /**< length of arrays */
    468 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    469 );
    470
    471
    472/** partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order around the \p k-th element,
    473 * see \ref SelectionAlgorithms for more information.
    474 */
    475SCIP_EXPORT
    476void SCIPselectPtrPtrReal(
    477 void** ptrarray1, /**< first pointer array to be sorted */
    478 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    479 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    480 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    481 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    482 int len /**< length of arrays */
    483 );
    484
    485
    486/** 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. \p weights and capacity,
    487 * see \ref SelectionAlgorithms for more information.
    488 */
    489SCIP_EXPORT
    490void SCIPselectWeightedPtrPtrReal(
    491 void** ptrarray1, /**< first pointer array to be sorted */
    492 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    493 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    494 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    495 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    496 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    497 int len, /**< length of arrays */
    498 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    499 );
    500
    501
    502/** partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    503 * see \ref SelectionAlgorithms for more information.
    504 */
    505SCIP_EXPORT
    506void SCIPselectPtrPtrIntInt(
    507 void** ptrarray1, /**< first pointer array to be sorted */
    508 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    509 int* intarray1, /**< first int array to be permuted in the same way */
    510 int* intarray2, /**< second int array to be permuted in the same way */
    511 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    512 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    513 int len /**< length of arrays */
    514 );
    515
    516
    517/** 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. \p weights and capacity,
    518 * see \ref SelectionAlgorithms for more information.
    519 */
    520SCIP_EXPORT
    521void SCIPselectWeightedPtrPtrIntInt(
    522 void** ptrarray1, /**< first pointer array to be sorted */
    523 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    524 int* intarray1, /**< first int array to be permuted in the same way */
    525 int* intarray2, /**< second int array to be permuted in the same way */
    526 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    527 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    528 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    529 int len, /**< length of arrays */
    530 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    531 );
    532
    533
    534/** partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    535 * see \ref SelectionAlgorithms for more information.
    536 */
    537SCIP_EXPORT
    538void SCIPselectPtrRealIntInt(
    539 void** ptrarray, /**< pointer array to be sorted */
    540 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    541 int* intarray1, /**< first int array to be permuted in the same way */
    542 int* intarray2, /**< second int array to be permuted in the same way */
    543 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    544 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    545 int len /**< length of arrays */
    546 );
    547
    548
    549/** 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. \p weights and capacity,
    550 * see \ref SelectionAlgorithms for more information.
    551 */
    552SCIP_EXPORT
    553void SCIPselectWeightedPtrRealIntInt(
    554 void** ptrarray, /**< pointer array to be sorted */
    555 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    556 int* intarray1, /**< first int array to be permuted in the same way */
    557 int* intarray2, /**< second int array to be permuted in the same way */
    558 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    559 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    560 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    561 int len, /**< length of arrays */
    562 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    563 );
    564
    565
    566/** partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element,
    567 * see \ref SelectionAlgorithms for more information.
    568 */
    569SCIP_EXPORT
    570void SCIPselectPtrPtrRealInt(
    571 void** ptrarray1, /**< first pointer array to be sorted */
    572 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    573 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    574 int* intarray, /**< int array to be permuted in the same way */
    575 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    576 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    577 int len /**< length of arrays */
    578 );
    579
    580
    581/** 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. \p weights and capacity,
    582 * see \ref SelectionAlgorithms for more information.
    583 */
    584SCIP_EXPORT
    585void SCIPselectWeightedPtrPtrRealInt(
    586 void** ptrarray1, /**< first pointer array to be sorted */
    587 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    588 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    589 int* intarray, /**< int array to be permuted in the same way */
    590 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    591 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    592 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    593 int len, /**< length of arrays */
    594 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    595 );
    596
    597
    598/** partial sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order around the \p k-th element,
    599 * see \ref SelectionAlgorithms for more information.
    600 */
    601SCIP_EXPORT
    602void SCIPselectPtrPtrRealBool(
    603 void** ptrarray1, /**< first pointer array to be sorted */
    604 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    605 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    606 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    607 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    608 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    609 int len /**< length of arrays */
    610 );
    611
    612
    613/** 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. \p weights and capacity,
    614 * see \ref SelectionAlgorithms for more information.
    615 */
    616SCIP_EXPORT
    617void SCIPselectWeightedPtrPtrRealBool(
    618 void** ptrarray1, /**< first pointer array to be sorted */
    619 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    620 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    621 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    622 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    623 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    624 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    625 int len, /**< length of arrays */
    626 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    627 );
    628
    629
    630/** partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order around the \p k-th element,
    631 * see \ref SelectionAlgorithms for more information.
    632 */
    633SCIP_EXPORT
    634void SCIPselectPtrPtrLongInt(
    635 void** ptrarray1, /**< first pointer array to be sorted */
    636 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    637 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    638 int* intarray, /**< int array to be permuted in the same way */
    639 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    640 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    641 int len /**< length of arrays */
    642 );
    643
    644
    645/** 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. \p weights and capacity,
    646 * see \ref SelectionAlgorithms for more information.
    647 */
    648SCIP_EXPORT
    649void SCIPselectWeightedPtrPtrLongInt(
    650 void** ptrarray1, /**< first pointer array to be sorted */
    651 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    652 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    653 int* intarray, /**< int array to be permuted in the same way */
    654 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    655 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    656 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    657 int len, /**< length of arrays */
    658 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    659 );
    660
    661
    662/** partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    663 * see \ref SelectionAlgorithms for more information.
    664 */
    665SCIP_EXPORT
    666void SCIPselectPtrPtrLongIntInt(
    667 void** ptrarray1, /**< first pointer array to be sorted */
    668 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    669 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    670 int* intarray1, /**< first int array to be permuted in the same way */
    671 int* intarray2, /**< second int array to be permuted in the same way */
    672 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    673 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    674 int len /**< length of arrays */
    675 );
    676
    677
    678/** 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. \p weights and capacity,
    679 * see \ref SelectionAlgorithms for more information.
    680 */
    681SCIP_EXPORT
    682void SCIPselectWeightedPtrPtrLongIntInt(
    683 void** ptrarray1, /**< first pointer array to be sorted */
    684 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    685 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    686 int* intarray1, /**< first int array to be permuted in the same way */
    687 int* intarray2, /**< second int array to be permuted in the same way */
    688 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    689 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    690 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    691 int len, /**< length of arrays */
    692 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    693 );
    694
    695
    696/** partial sort an array of Reals in non-decreasing order around the \p k-th element,
    697 * see \ref SelectionAlgorithms for more information.
    698 */
    699SCIP_EXPORT
    700void SCIPselectReal(
    701 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    702 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    703 int len /**< length of arrays */
    704 );
    705
    706
    707/** partial sort an array of Reals in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    708 * see \ref SelectionAlgorithms for more information.
    709 */
    710SCIP_EXPORT
    711void SCIPselectWeightedReal(
    712 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    713 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    714 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    715 int len, /**< length of arrays */
    716 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    717 );
    718
    719
    720/** partial sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    721 * see \ref SelectionAlgorithms for more information.
    722 */
    723SCIP_EXPORT
    724void SCIPselectRealPtr(
    725 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    726 void** ptrarray, /**< pointer array to be permuted in the same way */
    727 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    728 int len /**< length of arrays */
    729 );
    730
    731
    732/** partial sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    733 * see \ref SelectionAlgorithms for more information.
    734 */
    735SCIP_EXPORT
    736void SCIPselectWeightedRealPtr(
    737 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    738 void** ptrarray, /**< pointer array to be permuted in the same way */
    739 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    740 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    741 int len, /**< length of arrays */
    742 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    743 );
    744
    745
    746/** partial sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order around the \p k-th element,
    747 * see \ref SelectionAlgorithms for more information.
    748 */
    749SCIP_EXPORT
    750void SCIPselectRealInt(
    751 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    752 int* intarray, /**< int array to be permuted in the same way */
    753 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    754 int len /**< length of arrays */
    755 );
    756
    757
    758/** partial sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    759 * see \ref SelectionAlgorithms for more information.
    760 */
    761SCIP_EXPORT
    762void SCIPselectWeightedRealInt(
    763 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    764 int* intarray, /**< int array to be permuted in the same way */
    765 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    766 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    767 int len, /**< length of arrays */
    768 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    769 );
    770
    771
    772/** partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    773 * see \ref SelectionAlgorithms for more information.
    774 */
    775SCIP_EXPORT
    776void SCIPselectRealIntInt(
    777 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    778 int* intarray1, /**< int array to be permuted in the same way */
    779 int* intarray2, /**< int array to be permuted in the same way */
    780 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    781 int len /**< length of arrays */
    782 );
    783
    784
    785/** 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. \p weights and capacity,
    786 * see \ref SelectionAlgorithms for more information.
    787 */
    788SCIP_EXPORT
    789void SCIPselectWeightedRealIntInt(
    790 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    791 int* intarray1, /**< int array to be permuted in the same way */
    792 int* intarray2, /**< int array to be permuted in the same way */
    793 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    794 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    795 int len, /**< length of arrays */
    796 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    797 );
    798
    799
    800/** partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order around the \p k-th element,
    801 * see \ref SelectionAlgorithms for more information.
    802 */
    803SCIP_EXPORT
    804void SCIPselectRealBoolPtr(
    805 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    806 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    807 void** ptrarray, /**< pointer array to be permuted in the same way */
    808 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    809 int len /**< length of arrays */
    810 );
    811
    812
    813/** 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. \p weights and capacity,
    814 * see \ref SelectionAlgorithms for more information.
    815 */
    816SCIP_EXPORT
    817void SCIPselectWeightedRealBoolPtr(
    818 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    819 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    820 void** ptrarray, /**< pointer array to be permuted in the same way */
    821 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    822 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    823 int len, /**< length of arrays */
    824 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    825 );
    826
    827
    828/** partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order around the \p k-th element,
    829 * see \ref SelectionAlgorithms for more information.
    830 */
    831SCIP_EXPORT
    832void SCIPselectRealIntLong(
    833 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    834 int* intarray, /**< int array to be permuted in the same way */
    835 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    836 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    837 int len /**< length of arrays */
    838 );
    839
    840
    841/** 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. \p weights and capacity,
    842 * see \ref SelectionAlgorithms for more information.
    843 */
    844SCIP_EXPORT
    845void SCIPselectWeightedRealIntLong(
    846 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    847 int* intarray, /**< int array to be permuted in the same way */
    848 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    849 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    850 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    851 int len, /**< length of arrays */
    852 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    853 );
    854
    855
    856/** partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order around the \p k-th element,
    857 * see \ref SelectionAlgorithms for more information.
    858 */
    859SCIP_EXPORT
    860void SCIPselectRealIntPtr(
    861 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    862 int* intarray, /**< int array to be permuted in the same way */
    863 void** ptrarray, /**< pointer array to be permuted in the same way */
    864 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    865 int len /**< length of arrays */
    866 );
    867
    868
    869/** 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. \p weights and capacity,
    870 * see \ref SelectionAlgorithms for more information.
    871 */
    872SCIP_EXPORT
    873void SCIPselectWeightedRealIntPtr(
    874 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    875 int* intarray, /**< int array to be permuted in the same way */
    876 void** ptrarray, /**< pointer array to be permuted in the same way */
    877 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    878 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    879 int len, /**< length of arrays */
    880 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    881 );
    882
    883
    884/** partial sort of three joint arrays of Reals/Pointer/Pointer, sorted by first array in non-decreasing order around the \p k-th element,
    885 * see \ref SelectionAlgorithms for more information.
    886 */
    887SCIP_EXPORT
    888void SCIPselectRealPtrPtr(
    889 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    890 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    891 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    892 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    893 int len /**< length of arrays */
    894 );
    895
    896
    897/** partial sort of three joint arrays of Reals/Pointer/Pointer, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    898 * see \ref SelectionAlgorithms for more information.
    899 */
    900SCIP_EXPORT
    901void SCIPselectWeightedRealPtrPtr(
    902 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    903 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    904 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    905 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    906 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    907 int len, /**< length of arrays */
    908 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    909 );
    910
    911
    912/** partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order around the \p k-th element,
    913 * see \ref SelectionAlgorithms for more information.
    914 */
    915SCIP_EXPORT
    916void SCIPselectRealRealPtr(
    917 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    918 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    919 void** ptrarray, /**< pointer array to be permuted in the same way */
    920 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    921 int len /**< length of arrays */
    922 );
    923
    924
    925/** 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. \p weights and capacity,
    926 * see \ref SelectionAlgorithms for more information.
    927 */
    928SCIP_EXPORT
    929void SCIPselectWeightedRealRealPtr(
    930 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    931 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    932 void** ptrarray, /**< pointer array to be permuted in the same way */
    933 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    934 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    935 int len, /**< length of arrays */
    936 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    937 );
    938
    939
    940/** partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order around the \p k-th element,
    941 * see \ref SelectionAlgorithms for more information.
    942 */
    943SCIP_EXPORT
    944void SCIPselectRealPtrPtrInt(
    945 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    946 void** ptrarray1, /**< pointer array to be permuted in the same way */
    947 void** ptrarray2, /**< pointer array to be permuted in the same way */
    948 int* intarray, /**< int array to be sorted */
    949 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    950 int len /**< length of arrays */
    951 );
    952
    953
    954/** 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. \p weights and capacity,
    955 * see \ref SelectionAlgorithms for more information.
    956 */
    957SCIP_EXPORT
    958void SCIPselectWeightedRealPtrPtrInt(
    959 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    960 void** ptrarray1, /**< pointer array to be permuted in the same way */
    961 void** ptrarray2, /**< pointer array to be permuted in the same way */
    962 int* intarray, /**< int array to be sorted */
    963 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    964 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    965 int len, /**< length of arrays */
    966 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    967 );
    968
    969
    970/** partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    971 * see \ref SelectionAlgorithms for more information.
    972 */
    973SCIP_EXPORT
    974void SCIPselectRealPtrPtrIntInt(
    975 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    976 void** ptrarray1, /**< pointer array to be permuted in the same way */
    977 void** ptrarray2, /**< pointer array to be permuted in the same way */
    978 int* intarray1, /**< int array to be sorted */
    979 int* intarray2, /**< int array to be sorted */
    980 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    981 int len /**< length of arrays */
    982 );
    983
    984
    985/** 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. \p weights and capacity,
    986 * see \ref SelectionAlgorithms for more information.
    987 */
    988SCIP_EXPORT
    989void SCIPselectWeightedRealPtrPtrIntInt(
    990 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    991 void** ptrarray1, /**< pointer array to be permuted in the same way */
    992 void** ptrarray2, /**< pointer array to be permuted in the same way */
    993 int* intarray1, /**< int array to be sorted */
    994 int* intarray2, /**< int array to be sorted */
    995 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    996 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    997 int len, /**< length of arrays */
    998 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    999 );
    1000
    1001
    1002/** partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1003 * see \ref SelectionAlgorithms for more information.
    1004 */
    1005SCIP_EXPORT
    1006void SCIPselectRealLongRealInt(
    1007 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1008 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    1009 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1010 int* intarray, /**< int array to be permuted in the same way */
    1011 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1012 int len /**< length of arrays */
    1013 );
    1014
    1015
    1016/** 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. \p weights and capacity,
    1017 * see \ref SelectionAlgorithms for more information.
    1018 */
    1019SCIP_EXPORT
    1020void SCIPselectWeightedRealLongRealInt(
    1021 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1022 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    1023 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1024 int* intarray, /**< int array to be permuted in the same way */
    1025 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1026 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1027 int len, /**< length of arrays */
    1028 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1029 );
    1030
    1031
    1032/** partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1033 * see \ref SelectionAlgorithms for more information.
    1034 */
    1035SCIP_EXPORT
    1036void SCIPselectRealRealIntInt(
    1037 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1038 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1039 int* intarray1, /**< int array to be permuted in the same way */
    1040 int* intarray2, /**< int array to be permuted in the same way */
    1041 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1042 int len /**< length of arrays */
    1043 );
    1044
    1045
    1046/** 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. \p weights and capacity,
    1047 * see \ref SelectionAlgorithms for more information.
    1048 */
    1049SCIP_EXPORT
    1050void SCIPselectWeightedRealRealIntInt(
    1051 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1052 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1053 int* intarray1, /**< int array to be permuted in the same way */
    1054 int* intarray2, /**< int array to be permuted in the same way */
    1055 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1056 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1057 int len, /**< length of arrays */
    1058 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1059 );
    1060
    1061
    1062/** partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1063 * see \ref SelectionAlgorithms for more information.
    1064 */
    1065SCIP_EXPORT
    1066void SCIPselectRealRealRealInt(
    1067 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1068 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1069 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1070 int* intarray, /**< int array to be permuted in the same way */
    1071 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1072 int len /**< length of arrays */
    1073 );
    1074
    1075
    1076/** 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. \p weights and capacity,
    1077 * see \ref SelectionAlgorithms for more information.
    1078 */
    1079SCIP_EXPORT
    1080void SCIPselectWeightedRealRealRealInt(
    1081 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1082 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1083 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1084 int* intarray, /**< int array to be permuted in the same way */
    1085 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1086 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1087 int len, /**< length of arrays */
    1088 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1089 );
    1090
    1091
    1092/** partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1093 * see \ref SelectionAlgorithms for more information.
    1094 */
    1095SCIP_EXPORT
    1096void SCIPselectRealRealRealPtr(
    1097 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1098 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1099 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1100 void** ptrarray, /**< pointer array to be permuted in the same way */
    1101 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1102 int len /**< length of arrays */
    1103 );
    1104
    1105
    1106/** 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. \p weights and capacity,
    1107 * see \ref SelectionAlgorithms for more information.
    1108 */
    1109SCIP_EXPORT
    1110void SCIPselectWeightedRealRealRealPtr(
    1111 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1112 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1113 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1114 void** ptrarray, /**< pointer array to be permuted in the same way */
    1115 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1116 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1117 int len, /**< length of arrays */
    1118 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1119 );
    1120
    1121
    1122/** partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1123 * see \ref SelectionAlgorithms for more information.
    1124 */
    1125SCIP_EXPORT
    1126void SCIPselectRealRealRealBoolPtr(
    1127 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1128 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1129 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1130 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1131 void** ptrarray, /**< pointer array to be permuted in the same way */
    1132 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1133 int len /**< length of arrays */
    1134 );
    1135
    1136
    1137/** 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. \p weights and capacity,
    1138 * see \ref SelectionAlgorithms for more information.
    1139 */
    1140SCIP_EXPORT
    1141void SCIPselectWeightedRealRealRealBoolPtr(
    1142 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1143 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1144 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1145 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1146 void** ptrarray, /**< pointer array to be permuted in the same way */
    1147 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1148 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1149 int len, /**< length of arrays */
    1150 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1151 );
    1152
    1153
    1154/** partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1155 * see \ref SelectionAlgorithms for more information.
    1156 */
    1157SCIP_EXPORT
    1158void SCIPselectRealRealRealBoolBoolPtr(
    1159 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1160 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1161 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1162 SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
    1163 SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
    1164 void** ptrarray, /**< pointer array to be permuted in the same way */
    1165 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1166 int len /**< length of arrays */
    1167 );
    1168
    1169
    1170/** 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. \p weights and capacity,
    1171 * see \ref SelectionAlgorithms for more information.
    1172 */
    1173SCIP_EXPORT
    1174void SCIPselectWeightedRealRealRealBoolBoolPtr(
    1175 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    1176 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    1177 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    1178 SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
    1179 SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
    1180 void** ptrarray, /**< pointer array to be permuted in the same way */
    1181 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1182 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1183 int len, /**< length of arrays */
    1184 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1185 );
    1186
    1187
    1188/** partial sort array of ints in non-decreasing order around the \p k-th element,
    1189 * see \ref SelectionAlgorithms for more information.
    1190 */
    1191SCIP_EXPORT
    1192void SCIPselectInt(
    1193 int* intarray, /**< int array to be sorted */
    1194 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1195 int len /**< length of arrays */
    1196 );
    1197
    1198
    1199/** partial sort array of ints in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1200 * see \ref SelectionAlgorithms for more information.
    1201 */
    1202SCIP_EXPORT
    1203void SCIPselectWeightedInt(
    1204 int* intarray, /**< int array to be sorted */
    1205 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1206 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1207 int len, /**< length of arrays */
    1208 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1209 );
    1210
    1211
    1212/** partial sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1213 * see \ref SelectionAlgorithms for more information.
    1214 */
    1215SCIP_EXPORT
    1216void SCIPselectIntInt(
    1217 int* intarray1, /**< int array to be sorted */
    1218 int* intarray2, /**< second int array to be permuted in the same way */
    1219 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1220 int len /**< length of arrays */
    1221 );
    1222
    1223
    1224/** partial sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1225 * see \ref SelectionAlgorithms for more information.
    1226 */
    1227SCIP_EXPORT
    1228void SCIPselectWeightedIntInt(
    1229 int* intarray1, /**< int array to be sorted */
    1230 int* intarray2, /**< second int array to be permuted in the same way */
    1231 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1232 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1233 int len, /**< length of arrays */
    1234 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1235 );
    1236
    1237
    1238/** partial sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1239 * see \ref SelectionAlgorithms for more information.
    1240 */
    1241SCIP_EXPORT
    1242void SCIPselectIntPtr(
    1243 int* intarray, /**< int array to be sorted */
    1244 void** ptrarray, /**< pointer array to be permuted in the same way */
    1245 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1246 int len /**< length of arrays */
    1247 );
    1248
    1249
    1250/** partial sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1251 * see \ref SelectionAlgorithms for more information.
    1252 */
    1253SCIP_EXPORT
    1254void SCIPselectWeightedIntPtr(
    1255 int* intarray, /**< int array to be sorted */
    1256 void** ptrarray, /**< pointer array to be permuted in the same way */
    1257 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1258 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1259 int len, /**< length of arrays */
    1260 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1261 );
    1262
    1263
    1264/** partial sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order around the \p k-th element,
    1265 * see \ref SelectionAlgorithms for more information.
    1266 */
    1267SCIP_EXPORT
    1268void SCIPselectIntReal(
    1269 int* intarray, /**< int array to be sorted */
    1270 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    1271 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1272 int len /**< length of arrays */
    1273 );
    1274
    1275
    1276/** partial sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1277 * see \ref SelectionAlgorithms for more information.
    1278 */
    1279SCIP_EXPORT
    1280void SCIPselectWeightedIntReal(
    1281 int* intarray, /**< int array to be sorted */
    1282 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    1283 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1284 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1285 int len, /**< length of arrays */
    1286 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1287 );
    1288
    1289
    1290/** partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1291 * see \ref SelectionAlgorithms for more information.
    1292 */
    1293SCIP_EXPORT
    1294void SCIPselectIntIntInt(
    1295 int* intarray1, /**< int array to be sorted */
    1296 int* intarray2, /**< second int array to be permuted in the same way */
    1297 int* intarray3, /**< third int array to be permuted in the same way */
    1298 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1299 int len /**< length of arrays */
    1300 );
    1301
    1302
    1303/** 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. \p weights and capacity,
    1304 * see \ref SelectionAlgorithms for more information.
    1305 */
    1306SCIP_EXPORT
    1307void SCIPselectWeightedIntIntInt(
    1308 int* intarray1, /**< int array to be sorted */
    1309 int* intarray2, /**< second int array to be permuted in the same way */
    1310 int* intarray3, /**< third int array to be permuted in the same way */
    1311 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1312 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1313 int len, /**< length of arrays */
    1314 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1315 );
    1316
    1317
    1318/** partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the \p k-th element,
    1319 * see \ref SelectionAlgorithms for more information.
    1320 */
    1321SCIP_EXPORT
    1322void SCIPselectIntIntLong(
    1323 int* intarray1, /**< int array to be sorted */
    1324 int* intarray2, /**< second int array to be permuted in the same way */
    1325 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    1326 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1327 int len /**< length of arrays */
    1328 );
    1329
    1330
    1331/** 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. \p weights and capacity,
    1332 * see \ref SelectionAlgorithms for more information.
    1333 */
    1334SCIP_EXPORT
    1335void SCIPselectWeightedIntIntLong(
    1336 int* intarray1, /**< int array to be sorted */
    1337 int* intarray2, /**< second int array to be permuted in the same way */
    1338 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    1339 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1340 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1341 int len, /**< length of arrays */
    1342 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1343 );
    1344
    1345
    1346/** partial sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order around the \p k-th element,
    1347 * see \ref SelectionAlgorithms for more information.
    1348 */
    1349SCIP_EXPORT
    1350void SCIPselectIntRealLong(
    1351 int* intarray, /**< int array to be sorted */
    1352 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    1353 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    1354 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1355 int len /**< length of arrays */
    1356 );
    1357
    1358
    1359/** 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. \p weights and capacity,
    1360 * see \ref SelectionAlgorithms for more information.
    1361 */
    1362SCIP_EXPORT
    1363void SCIPselectWeightedIntRealLong(
    1364 int* intarray, /**< int array to be sorted */
    1365 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    1366 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    1367 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1368 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1369 int len, /**< length of arrays */
    1370 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1371 );
    1372
    1373
    1374/** partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1375 * see \ref SelectionAlgorithms for more information.
    1376 */
    1377SCIP_EXPORT
    1378void SCIPselectIntIntPtr(
    1379 int* intarray1, /**< int array to be sorted */
    1380 int* intarray2, /**< second int array to be permuted in the same way */
    1381 void** ptrarray, /**< pointer array to be permuted in the same way */
    1382 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1383 int len /**< length of arrays */
    1384 );
    1385
    1386/** partial sort of four joint arrays of ints/ints/pointers/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1387 * see \ref SelectionAlgorithms for more information.
    1388 */
    1389SCIP_EXPORT
    1390void SCIPselectIntIntPtrPtr(
    1391 int* intarray1, /**< int array to be sorted */
    1392 int* intarray2, /**< second int array to be permuted in the same way */
    1393 void** ptrarray1, /**< pointer array to be permuted in the same way */
    1394 void** ptrarray2, /**< pointer array to be permuted in the same way */
    1395 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1396 int len /**< length of arrays */
    1397 );
    1398
    1399/** partial sort of five joint arrays of ints/ints/pointers/pointers/interval, sorted by first array in non-decreasing order around the \p k-th element,
    1400 * see \ref SelectionAlgorithms for more information.
    1401 */
    1402SCIP_EXPORT
    1403void SCIPselectIntIntPtrPtrInterval(
    1404 int* intarray1, /**< int array to be sorted */
    1405 int* intarray2, /**< second int array to be permuted in the same way */
    1406 void** ptrarray1, /**< pointer array to be permuted in the same way */
    1407 void** ptrarray2, /**< pointer array to be permuted in the same way */
    1408 SCIP_INTERVAL* intervalarray, /**< interval array where an element is to be deleted */
    1409 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1410 int len /**< length of arrays */
    1411 );
    1412
    1413/** 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. \p weights and capacity,
    1414 * see \ref SelectionAlgorithms for more information.
    1415 */
    1416SCIP_EXPORT
    1417void SCIPselectWeightedIntIntPtr(
    1418 int* intarray1, /**< int array to be sorted */
    1419 int* intarray2, /**< second int array to be permuted in the same way */
    1420 void** ptrarray, /**< pointer array to be permuted in the same way */
    1421 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1422 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1423 int len, /**< length of arrays */
    1424 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1425 );
    1426
    1427/** partial sort of four joint arrays of ints/ints/pointers/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1428 * see \ref SelectionAlgorithms for more information.
    1429 */
    1430SCIP_EXPORT
    1431void SCIPselectWeightedIntIntPtrPtr(
    1432 int* intarray1, /**< int array to be sorted */
    1433 int* intarray2, /**< second int array to be permuted in the same way */
    1434 void** ptrarray1, /**< pointer array to be permuted in the same way */
    1435 void** ptrarray2, /**< pointer array to be permuted in the same way */
    1436 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1437 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1438 int len, /**< length of arrays */
    1439 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1440 );
    1441
    1442/** partial sort of five joint arrays of ints/ints/pointers/pointers/interval, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1443 * see \ref SelectionAlgorithms for more information.
    1444 */
    1445SCIP_EXPORT
    1446void SCIPselectWeightedIntIntPtrPtrInterval(
    1447 int* intarray1, /**< int array to be sorted */
    1448 int* intarray2, /**< second int array to be permuted in the same way */
    1449 void** ptrarray1, /**< pointer array to be permuted in the same way */
    1450 void** ptrarray2, /**< pointer array to be permuted in the same way */
    1451 SCIP_INTERVAL* intervalarray, /**< interval array where an element is to be deleted */
    1452 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1453 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1454 int len, /**< length of arrays */
    1455 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1456 );
    1457
    1458
    1459/** partial sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order around the \p k-th element,
    1460 * see \ref SelectionAlgorithms for more information.
    1461 */
    1462SCIP_EXPORT
    1463void SCIPselectIntIntReal(
    1464 int* intarray1, /**< int array to be sorted */
    1465 int* intarray2, /**< second int array to be permuted in the same way */
    1466 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1467 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1468 int len /**< length of arrays */
    1469 );
    1470
    1471
    1472/** 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. \p weights and capacity,
    1473 * see \ref SelectionAlgorithms for more information.
    1474 */
    1475SCIP_EXPORT
    1476void SCIPselectWeightedIntIntReal(
    1477 int* intarray1, /**< int array to be sorted */
    1478 int* intarray2, /**< second int array to be permuted in the same way */
    1479 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1480 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1481 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1482 int len, /**< length of arrays */
    1483 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1484 );
    1485
    1486
    1487/** partial sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order around the \p k-th element,
    1488 * see \ref SelectionAlgorithms for more information.
    1489 */
    1490SCIP_EXPORT
    1491void SCIPselectIntPtrReal(
    1492 int* intarray, /**< int array to be sorted */
    1493 void** ptrarray, /**< pointer array to be permuted in the same way */
    1494 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    1495 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1496 int len /**< length of arrays */
    1497 );
    1498
    1499
    1500/** 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. \p weights and capacity,
    1501 * see \ref SelectionAlgorithms for more information.
    1502 */
    1503SCIP_EXPORT
    1504void SCIPselectWeightedIntPtrReal(
    1505 int* intarray, /**< int array to be sorted */
    1506 void** ptrarray, /**< pointer array to be permuted in the same way */
    1507 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    1508 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1509 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1510 int len, /**< length of arrays */
    1511 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1512 );
    1513
    1514
    1515/** partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    1516 * see \ref SelectionAlgorithms for more information.
    1517 */
    1518SCIP_EXPORT
    1519void SCIPselectIntIntIntPtr(
    1520 int* intarray1, /**< int array to be sorted */
    1521 int* intarray2, /**< int array to be permuted in the same way */
    1522 int* intarray3, /**< int array to be permuted in the same way */
    1523 void** ptrarray, /**< pointer array to be permuted in the same way */
    1524 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1525 int len /**< length of arrays */
    1526 );
    1527
    1528
    1529/** 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. \p weights and capacity,
    1530 * see \ref SelectionAlgorithms for more information.
    1531 */
    1532SCIP_EXPORT
    1533void SCIPselectWeightedIntIntIntPtr(
    1534 int* intarray1, /**< int array to be sorted */
    1535 int* intarray2, /**< int array to be permuted in the same way */
    1536 int* intarray3, /**< int array to be permuted in the same way */
    1537 void** ptrarray, /**< pointer array to be permuted in the same way */
    1538 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1539 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1540 int len, /**< length of arrays */
    1541 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1542 );
    1543
    1544
    1545/** partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order around the \p k-th element,
    1546 * see \ref SelectionAlgorithms for more information.
    1547 */
    1548SCIP_EXPORT
    1549void SCIPselectIntIntIntReal(
    1550 int* intarray1, /**< int array to be sorted */
    1551 int* intarray2, /**< int array to be permuted in the same way */
    1552 int* intarray3, /**< int array to be permuted in the same way */
    1553 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1554 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1555 int len /**< length of arrays */
    1556 );
    1557
    1558
    1559/** 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. \p weights and capacity,
    1560 * see \ref SelectionAlgorithms for more information.
    1561 */
    1562SCIP_EXPORT
    1563void SCIPselectWeightedIntIntIntReal(
    1564 int* intarray1, /**< int array to be sorted */
    1565 int* intarray2, /**< int array to be permuted in the same way */
    1566 int* intarray3, /**< int array to be permuted in the same way */
    1567 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1568 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1569 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1570 int len, /**< length of arrays */
    1571 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1572 );
    1573
    1574
    1575/** partial sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order around the \p k-th element,
    1576 * see \ref SelectionAlgorithms for more information.
    1577 */
    1578SCIP_EXPORT
    1579void SCIPselectIntPtrIntReal(
    1580 int* intarray1, /**< int array to be sorted */
    1581 void** ptrarray, /**< pointer array to be permuted in the same way */
    1582 int* intarray2, /**< int array to be permuted in the same way */
    1583 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1584 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1585 int len /**< length of arrays */
    1586 );
    1587
    1588
    1589/** 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. \p weights and capacity,
    1590 * see \ref SelectionAlgorithms for more information.
    1591 */
    1592SCIP_EXPORT
    1593void SCIPselectWeightedIntPtrIntReal(
    1594 int* intarray1, /**< int array to be sorted */
    1595 void** ptrarray, /**< pointer array to be permuted in the same way */
    1596 int* intarray2, /**< int array to be permuted in the same way */
    1597 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1598 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1599 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1600 int len, /**< length of arrays */
    1601 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1602 );
    1603
    1604
    1605/** partial sort an array of Longints in non-decreasing order around the \p k-th element,
    1606 * see \ref SelectionAlgorithms for more information.
    1607 */
    1608SCIP_EXPORT
    1609void SCIPselectLong(
    1610 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1611 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1612 int len /**< length of arrays */
    1613 );
    1614
    1615
    1616/** partial sort an array of Longints in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    1617 * see \ref SelectionAlgorithms for more information.
    1618 */
    1619SCIP_EXPORT
    1620void SCIPselectWeightedLong(
    1621 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1622 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1623 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1624 int len, /**< length of arrays */
    1625 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1626 );
    1627
    1628
    1629/** partial sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order around the \p k-th element,
    1630 * see \ref SelectionAlgorithms for more information.
    1631 */
    1632SCIP_EXPORT
    1633void SCIPselectLongPtr(
    1634 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1635 void** ptrarray, /**< pointer array to be permuted in the same way */
    1636 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1637 int len /**< length of arrays */
    1638 );
    1639
    1640
    1641/** 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. \p weights and capacity,
    1642 * see \ref SelectionAlgorithms for more information.
    1643 */
    1644SCIP_EXPORT
    1645void SCIPselectWeightedLongPtr(
    1646 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1647 void** ptrarray, /**< pointer array to be permuted in the same way */
    1648 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1649 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1650 int len, /**< length of arrays */
    1651 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1652 );
    1653
    1654
    1655/** partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order around the \p k-th element,
    1656 * see \ref SelectionAlgorithms for more information.
    1657 */
    1658SCIP_EXPORT
    1659void SCIPselectLongPtrInt(
    1660 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1661 void** ptrarray, /**< pointer array to be permuted in the same way */
    1662 int* intarray, /**< int array to be permuted in the same way */
    1663 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1664 int len /**< length of arrays */
    1665 );
    1666
    1667
    1668/** 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. \p weights and capacity,
    1669 * see \ref SelectionAlgorithms for more information.
    1670 */
    1671SCIP_EXPORT
    1672void SCIPselectWeightedLongPtrInt(
    1673 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1674 void** ptrarray, /**< pointer array to be permuted in the same way */
    1675 int* intarray, /**< int array to be permuted in the same way */
    1676 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1677 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1678 int len, /**< length of arrays */
    1679 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1680 );
    1681
    1682
    1683/** partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order around the \p k-th element,
    1684 * see \ref SelectionAlgorithms for more information.
    1685 */
    1686SCIP_EXPORT
    1687void SCIPselectLongPtrRealBool(
    1688 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1689 void** ptrarray, /**< pointer array to be permuted in the same way */
    1690 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1691 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1692 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1693 int len /**< length of arrays */
    1694 );
    1695
    1696
    1697/** 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. \p weights and capacity,
    1698 * see \ref SelectionAlgorithms for more information.
    1699 */
    1700SCIP_EXPORT
    1701void SCIPselectWeightedLongPtrRealBool(
    1702 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1703 void** ptrarray, /**< pointer array to be permuted in the same way */
    1704 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    1705 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1706 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1707 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1708 int len, /**< length of arrays */
    1709 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1710 );
    1711
    1712
    1713/** partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order around the \p k-th element,
    1714 * see \ref SelectionAlgorithms for more information.
    1715 */
    1716SCIP_EXPORT
    1717void SCIPselectLongPtrRealRealBool(
    1718 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1719 void** ptrarray, /**< pointer array to be permuted in the same way */
    1720 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    1721 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    1722 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1723 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1724 int len /**< length of arrays */
    1725 );
    1726
    1727
    1728/** 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. \p weights and capacity,
    1729 * see \ref SelectionAlgorithms for more information.
    1730 */
    1731SCIP_EXPORT
    1732void SCIPselectWeightedLongPtrRealRealBool(
    1733 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1734 void** ptrarray, /**< pointer array to be permuted in the same way */
    1735 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    1736 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    1737 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1738 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1739 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1740 int len, /**< length of arrays */
    1741 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1742 );
    1743
    1744
    1745/** partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order around the \p k-th element,
    1746 * see \ref SelectionAlgorithms for more information.
    1747 */
    1748SCIP_EXPORT
    1749void SCIPselectLongPtrRealRealIntBool(
    1750 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1751 void** ptrarray, /**< pointer array to be permuted in the same way */
    1752 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    1753 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    1754 int* intarray, /**< int array to be permuted in the same way */
    1755 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1756 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1757 int len /**< length of arrays */
    1758 );
    1759
    1760
    1761/** 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. \p weights and capacity,
    1762 * see \ref SelectionAlgorithms for more information.
    1763 */
    1764SCIP_EXPORT
    1765void SCIPselectWeightedLongPtrRealRealIntBool(
    1766 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1767 void** ptrarray, /**< pointer array to be permuted in the same way */
    1768 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    1769 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    1770 int* intarray, /**< int array to be permuted in the same way */
    1771 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1772 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1773 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1774 int len, /**< length of arrays */
    1775 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1776 );
    1777
    1778
    1779/** partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1780 * see \ref SelectionAlgorithms for more information.
    1781 */
    1782SCIP_EXPORT
    1783void SCIPselectLongPtrPtrInt(
    1784 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1785 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    1786 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    1787 int* intarray, /**< int array to be permuted in the same way */
    1788 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1789 int len /**< length of arrays */
    1790 );
    1791
    1792
    1793/** 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. \p weights and capacity,
    1794 * see \ref SelectionAlgorithms for more information.
    1795 */
    1796SCIP_EXPORT
    1797void SCIPselectWeightedLongPtrPtrInt(
    1798 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1799 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    1800 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    1801 int* intarray, /**< int array to be permuted in the same way */
    1802 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1803 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1804 int len, /**< length of arrays */
    1805 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1806 );
    1807
    1808
    1809/** partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1810 * see \ref SelectionAlgorithms for more information.
    1811 */
    1812SCIP_EXPORT
    1813void SCIPselectLongPtrPtrIntInt(
    1814 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1815 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    1816 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    1817 int* intarray1, /**< first int array to be permuted in the same way */
    1818 int* intarray2, /**< second int array to be permuted in the same way */
    1819 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1820 int len /**< length of arrays */
    1821 );
    1822
    1823
    1824/** 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. \p weights and capacity,
    1825 * see \ref SelectionAlgorithms for more information.
    1826 */
    1827SCIP_EXPORT
    1828void SCIPselectWeightedLongPtrPtrIntInt(
    1829 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1830 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    1831 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    1832 int* intarray1, /**< first int array to be permuted in the same way */
    1833 int* intarray2, /**< second int array to be permuted in the same way */
    1834 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1835 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1836 int len, /**< length of arrays */
    1837 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1838 );
    1839
    1840
    1841/** partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order around the \p k-th element,
    1842 * see \ref SelectionAlgorithms for more information.
    1843 */
    1844SCIP_EXPORT
    1845void SCIPselectLongPtrPtrBoolInt(
    1846 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1847 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    1848 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    1849 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1850 int* intarray, /**< int array to be sorted */
    1851 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1852 int len /**< length of arrays */
    1853 );
    1854
    1855
    1856/** 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. \p weights and capacity,
    1857 * see \ref SelectionAlgorithms for more information.
    1858 */
    1859SCIP_EXPORT
    1860void SCIPselectWeightedLongPtrPtrBoolInt(
    1861 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    1862 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    1863 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    1864 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    1865 int* intarray, /**< int array to be sorted */
    1866 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1867 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1868 int len, /**< length of arrays */
    1869 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1870 );
    1871
    1872
    1873/** partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the \p k-th element,
    1874 * see \ref SelectionAlgorithms for more information.
    1875 */
    1876SCIP_EXPORT
    1877void SCIPselectPtrIntIntBoolBool(
    1878 void** ptrarray, /**< pointer array to be sorted */
    1879 int* intarray1, /**< first int array to be permuted in the same way */
    1880 int* intarray2, /**< second int array to be permuted in the same way */
    1881 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    1882 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    1883 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    1884 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1885 int len /**< length of arrays */
    1886 );
    1887
    1888
    1889/** 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. \p weights and capacity,
    1890 * see \ref SelectionAlgorithms for more information.
    1891 */
    1892SCIP_EXPORT
    1893void SCIPselectWeightedPtrIntIntBoolBool(
    1894 void** ptrarray, /**< pointer array to be sorted */
    1895 int* intarray1, /**< first int array to be permuted in the same way */
    1896 int* intarray2, /**< second int array to be permuted in the same way */
    1897 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    1898 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    1899 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    1900 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1901 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1902 int len, /**< length of arrays */
    1903 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1904 );
    1905
    1906
    1907/** partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order around the \p k-th element,
    1908 * see \ref SelectionAlgorithms for more information.
    1909 */
    1910SCIP_EXPORT
    1911void SCIPselectIntPtrIntIntBoolBool(
    1912 int* intarray1, /**< int array to be sorted */
    1913 void** ptrarray, /**< pointer array to be permuted in the same way */
    1914 int* intarray2, /**< second int array to be permuted in the same way */
    1915 int* intarray3, /**< thrid int array to be permuted in the same way */
    1916 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    1917 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    1918 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1919 int len /**< length of arrays */
    1920 );
    1921
    1922
    1923/** 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. \p weights and capacity,
    1924 * see \ref SelectionAlgorithms for more information.
    1925 */
    1926SCIP_EXPORT
    1927void SCIPselectWeightedIntPtrIntIntBoolBool(
    1928 int* intarray1, /**< int array to be sorted */
    1929 void** ptrarray, /**< pointer array to be permuted in the same way */
    1930 int* intarray2, /**< second int array to be permuted in the same way */
    1931 int* intarray3, /**< thrid int array to be permuted in the same way */
    1932 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    1933 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    1934 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1935 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1936 int len, /**< length of arrays */
    1937 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1938 );
    1939
    1940
    1941/** partial sort an index array in non-increasing order around the \p k-th element,
    1942 * see \ref SelectionAlgorithms for more information.
    1943 */
    1944SCIP_EXPORT
    1945void SCIPselectDownInd(
    1946 int* indarray, /**< pointer to the index array to be sorted */
    1947 SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
    1948 void* dataptr, /**< pointer to data field that is given to the external compare method */
    1949 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1950 int len /**< length of arrays */
    1951 );
    1952
    1953
    1954/** partial sort an index array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    1955 * see \ref SelectionAlgorithms for more information.
    1956 */
    1957SCIP_EXPORT
    1958void SCIPselectWeightedDownInd(
    1959 int* indarray, /**< pointer to the index array to be sorted */
    1960 SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
    1961 void* dataptr, /**< pointer to data field that is given to the external compare method */
    1962 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1963 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1964 int len, /**< length of arrays */
    1965 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1966 );
    1967
    1968
    1969/** partial sort of an array of pointers in non-increasing order around the \p k-th element,
    1970 * see \ref SelectionAlgorithms for more information.
    1971 */
    1972SCIP_EXPORT
    1973void SCIPselectDownPtr(
    1974 void** ptrarray, /**< pointer array to be sorted */
    1975 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    1976 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    1977 int len /**< length of arrays */
    1978 );
    1979
    1980
    1981/** partial sort of an array of pointers in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    1982 * see \ref SelectionAlgorithms for more information.
    1983 */
    1984SCIP_EXPORT
    1985void SCIPselectWeightedDownPtr(
    1986 void** ptrarray, /**< pointer array to be sorted */
    1987 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    1988 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    1989 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    1990 int len, /**< length of arrays */
    1991 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    1992 );
    1993
    1994
    1995/** partial sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order around the \p k-th element,
    1996 * see \ref SelectionAlgorithms for more information.
    1997 */
    1998SCIP_EXPORT
    1999void SCIPselectDownPtrPtr(
    2000 void** ptrarray1, /**< first pointer array to be sorted */
    2001 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2002 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2003 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2004 int len /**< length of arrays */
    2005 );
    2006
    2007
    2008/** partial sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2009 * see \ref SelectionAlgorithms for more information.
    2010 */
    2011SCIP_EXPORT
    2012void SCIPselectWeightedDownPtrPtr(
    2013 void** ptrarray1, /**< first pointer array to be sorted */
    2014 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2015 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2016 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2017 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2018 int len, /**< length of arrays */
    2019 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2020 );
    2021
    2022
    2023/** partial sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order around the \p k-th element,
    2024 * see \ref SelectionAlgorithms for more information.
    2025 */
    2026SCIP_EXPORT
    2027void SCIPselectDownPtrReal(
    2028 void** ptrarray, /**< pointer array to be sorted */
    2029 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2030 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2031 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2032 int len /**< length of arrays */
    2033 );
    2034
    2035
    2036/** partial sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2037 * see \ref SelectionAlgorithms for more information.
    2038 */
    2039SCIP_EXPORT
    2040void SCIPselectWeightedDownPtrReal(
    2041 void** ptrarray, /**< pointer array to be sorted */
    2042 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2043 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2044 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2045 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2046 int len, /**< length of arrays */
    2047 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2048 );
    2049
    2050
    2051/** partial sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order around the \p k-th element,
    2052 * see \ref SelectionAlgorithms for more information.
    2053 */
    2054SCIP_EXPORT
    2055void SCIPselectDownPtrInt(
    2056 void** ptrarray, /**< pointer array to be sorted */
    2057 int* intarray, /**< int array to be permuted in the same way */
    2058 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2059 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2060 int len /**< length of arrays */
    2061 );
    2062
    2063
    2064/** partial sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2065 * see \ref SelectionAlgorithms for more information.
    2066 */
    2067SCIP_EXPORT
    2068void SCIPselectWeightedDownPtrInt(
    2069 void** ptrarray, /**< pointer array to be sorted */
    2070 int* intarray, /**< int array to be permuted in the same way */
    2071 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2072 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2073 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2074 int len, /**< length of arrays */
    2075 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2076 );
    2077
    2078
    2079/** partial sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order around the \p k-th element,
    2080 * see \ref SelectionAlgorithms for more information.
    2081 */
    2082SCIP_EXPORT
    2083void SCIPselectDownPtrBool(
    2084 void** ptrarray, /**< pointer array to be sorted */
    2085 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2086 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2087 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2088 int len /**< length of arrays */
    2089 );
    2090
    2091
    2092/** partial sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2093 * see \ref SelectionAlgorithms for more information.
    2094 */
    2095SCIP_EXPORT
    2096void SCIPselectWeightedDownPtrBool(
    2097 void** ptrarray, /**< pointer array to be sorted */
    2098 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2099 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2100 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2101 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2102 int len, /**< length of arrays */
    2103 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2104 );
    2105
    2106
    2107/** partial sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2108 * see \ref SelectionAlgorithms for more information.
    2109 */
    2110SCIP_EXPORT
    2111void SCIPselectDownPtrIntInt(
    2112 void** ptrarray, /**< pointer array to be sorted */
    2113 int* intarray1, /**< first int array to be permuted in the same way */
    2114 int* intarray2, /**< second int array to be permuted in the same way */
    2115 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2116 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2117 int len /**< length of arrays */
    2118 );
    2119
    2120
    2121/** 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. \p weights and capacity,
    2122 * see \ref SelectionAlgorithms for more information.
    2123 */
    2124SCIP_EXPORT
    2125void SCIPselectWeightedDownPtrIntInt(
    2126 void** ptrarray, /**< pointer array to be sorted */
    2127 int* intarray1, /**< first int array to be permuted in the same way */
    2128 int* intarray2, /**< second int array to be permuted in the same way */
    2129 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2130 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2131 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2132 int len, /**< length of arrays */
    2133 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2134 );
    2135
    2136
    2137/** partial sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order around the \p k-th element,
    2138 * see \ref SelectionAlgorithms for more information.
    2139 */
    2140SCIP_EXPORT
    2141void SCIPselectDownPtrRealInt(
    2142 void** ptrarray, /**< pointer array to be sorted */
    2143 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2144 int* intarray, /**< int array to be permuted in the same way */
    2145 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2146 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2147 int len /**< length of arrays */
    2148 );
    2149
    2150
    2151/** 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. \p weights and capacity,
    2152 * see \ref SelectionAlgorithms for more information.
    2153 */
    2154SCIP_EXPORT
    2155void SCIPselectWeightedDownPtrRealInt(
    2156 void** ptrarray, /**< pointer array to be sorted */
    2157 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2158 int* intarray, /**< int array to be permuted in the same way */
    2159 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2160 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2161 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2162 int len, /**< length of arrays */
    2163 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2164 );
    2165
    2166
    2167/** partial sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order around the \p k-th element,
    2168 * see \ref SelectionAlgorithms for more information.
    2169 */
    2170SCIP_EXPORT
    2171void SCIPselectDownPtrRealBool(
    2172 void** ptrarray, /**< pointer array to be sorted */
    2173 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2174 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2175 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2176 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2177 int len /**< length of arrays */
    2178 );
    2179
    2180
    2181/** 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. \p weights and capacity,
    2182 * see \ref SelectionAlgorithms for more information.
    2183 */
    2184SCIP_EXPORT
    2185void SCIPselectWeightedDownPtrRealBool(
    2186 void** ptrarray, /**< pointer array to be sorted */
    2187 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2188 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2189 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2190 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2191 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2192 int len, /**< length of arrays */
    2193 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2194 );
    2195
    2196
    2197/** partial sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order around the \p k-th element,
    2198 * see \ref SelectionAlgorithms for more information.
    2199 */
    2200SCIP_EXPORT
    2201void SCIPselectDownPtrPtrInt(
    2202 void** ptrarray1, /**< first pointer array to be sorted */
    2203 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2204 int* intarray, /**< int array to be permuted in the same way */
    2205 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2206 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2207 int len /**< length of arrays */
    2208 );
    2209
    2210
    2211/** 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. \p weights and capacity,
    2212 * see \ref SelectionAlgorithms for more information.
    2213 */
    2214SCIP_EXPORT
    2215void SCIPselectWeightedDownPtrPtrInt(
    2216 void** ptrarray1, /**< first pointer array to be sorted */
    2217 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2218 int* intarray, /**< int array to be permuted in the same way */
    2219 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2220 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2221 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2222 int len, /**< length of arrays */
    2223 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2224 );
    2225
    2226
    2227/** partial sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order around the \p k-th element,
    2228 * see \ref SelectionAlgorithms for more information.
    2229 */
    2230SCIP_EXPORT
    2231void SCIPselectDownPtrPtrReal(
    2232 void** ptrarray1, /**< first pointer array to be sorted */
    2233 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2234 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2235 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2236 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2237 int len /**< length of arrays */
    2238 );
    2239
    2240
    2241/** 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. \p weights and capacity,
    2242 * see \ref SelectionAlgorithms for more information.
    2243 */
    2244SCIP_EXPORT
    2245void SCIPselectWeightedDownPtrPtrReal(
    2246 void** ptrarray1, /**< first pointer array to be sorted */
    2247 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2248 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2249 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2250 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2251 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2252 int len, /**< length of arrays */
    2253 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2254 );
    2255
    2256
    2257/** partial sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2258 * see \ref SelectionAlgorithms for more information.
    2259 */
    2260SCIP_EXPORT
    2261void SCIPselectDownPtrPtrIntInt(
    2262 void** ptrarray1, /**< first pointer array to be sorted */
    2263 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2264 int* intarray1, /**< first int array to be permuted in the same way */
    2265 int* intarray2, /**< second int array to be permuted in the same way */
    2266 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2267 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2268 int len /**< length of arrays */
    2269 );
    2270
    2271
    2272/** 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. \p weights and capacity,
    2273 * see \ref SelectionAlgorithms for more information.
    2274 */
    2275SCIP_EXPORT
    2276void SCIPselectWeightedDownPtrPtrIntInt(
    2277 void** ptrarray1, /**< first pointer array to be sorted */
    2278 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2279 int* intarray1, /**< first int array to be permuted in the same way */
    2280 int* intarray2, /**< second int array to be permuted in the same way */
    2281 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2282 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2283 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2284 int len, /**< length of arrays */
    2285 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2286 );
    2287
    2288
    2289/** partial sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2290 * see \ref SelectionAlgorithms for more information.
    2291 */
    2292SCIP_EXPORT
    2293void SCIPselectDownPtrRealIntInt(
    2294 void** ptrarray, /**< pointer array to be sorted */
    2295 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2296 int* intarray1, /**< first int array to be permuted in the same way */
    2297 int* intarray2, /**< second int array to be permuted in the same way */
    2298 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2299 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2300 int len /**< length of arrays */
    2301 );
    2302
    2303
    2304/** 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. \p weights and capacity,
    2305 * see \ref SelectionAlgorithms for more information.
    2306 */
    2307SCIP_EXPORT
    2308void SCIPselectWeightedDownPtrRealIntInt(
    2309 void** ptrarray, /**< pointer array to be sorted */
    2310 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2311 int* intarray1, /**< first int array to be permuted in the same way */
    2312 int* intarray2, /**< second int array to be permuted in the same way */
    2313 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2314 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2315 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2316 int len, /**< length of arrays */
    2317 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2318 );
    2319
    2320
    2321/** partial sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order around the \p k-th element,
    2322 * see \ref SelectionAlgorithms for more information.
    2323 */
    2324SCIP_EXPORT
    2325void SCIPselectDownPtrPtrRealInt(
    2326 void** ptrarray1, /**< first pointer array to be sorted */
    2327 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2328 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2329 int* intarray, /**< int array to be permuted in the same way */
    2330 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2331 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2332 int len /**< length of arrays */
    2333 );
    2334
    2335
    2336/** 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. \p weights and capacity,
    2337 * see \ref SelectionAlgorithms for more information.
    2338 */
    2339SCIP_EXPORT
    2340void SCIPselectWeightedDownPtrPtrRealInt(
    2341 void** ptrarray1, /**< first pointer array to be sorted */
    2342 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2343 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2344 int* intarray, /**< int array to be permuted in the same way */
    2345 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2346 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2347 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2348 int len, /**< length of arrays */
    2349 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2350 );
    2351
    2352
    2353/** partial sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order around the \p k-th element,
    2354 * see \ref SelectionAlgorithms for more information.
    2355 */
    2356SCIP_EXPORT
    2357void SCIPselectDownPtrPtrRealBool(
    2358 void** ptrarray1, /**< first pointer array to be sorted */
    2359 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2360 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2361 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2362 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2363 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2364 int len /**< length of arrays */
    2365 );
    2366
    2367
    2368/** 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. \p weights and capacity,
    2369 * see \ref SelectionAlgorithms for more information.
    2370 */
    2371SCIP_EXPORT
    2372void SCIPselectWeightedDownPtrPtrRealBool(
    2373 void** ptrarray1, /**< first pointer array to be sorted */
    2374 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2375 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    2376 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2377 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2378 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2379 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2380 int len, /**< length of arrays */
    2381 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2382 );
    2383
    2384
    2385/** partial sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order around the \p k-th element,
    2386 * see \ref SelectionAlgorithms for more information.
    2387 */
    2388SCIP_EXPORT
    2389void SCIPselectDownPtrPtrLongInt(
    2390 void** ptrarray1, /**< first pointer array to be sorted */
    2391 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2392 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2393 int* intarray, /**< int array to be permuted in the same way */
    2394 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2395 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2396 int len /**< length of arrays */
    2397 );
    2398
    2399
    2400/** 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. \p weights and capacity,
    2401 * see \ref SelectionAlgorithms for more information.
    2402 */
    2403SCIP_EXPORT
    2404void SCIPselectWeightedDownPtrPtrLongInt(
    2405 void** ptrarray1, /**< first pointer array to be sorted */
    2406 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2407 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2408 int* intarray, /**< int array to be permuted in the same way */
    2409 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2410 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2411 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2412 int len, /**< length of arrays */
    2413 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2414 );
    2415
    2416
    2417/** partial sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2418 * see \ref SelectionAlgorithms for more information.
    2419 */
    2420SCIP_EXPORT
    2421void SCIPselectDownPtrPtrLongIntInt(
    2422 void** ptrarray1, /**< first pointer array to be sorted */
    2423 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2424 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2425 int* intarray1, /**< first int array to be permuted in the same way */
    2426 int* intarray2, /**< second int array to be permuted in the same way */
    2427 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2428 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2429 int len /**< length of arrays */
    2430 );
    2431
    2432
    2433/** 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. \p weights and capacity,
    2434 * see \ref SelectionAlgorithms for more information.
    2435 */
    2436SCIP_EXPORT
    2437void SCIPselectWeightedDownPtrPtrLongIntInt(
    2438 void** ptrarray1, /**< first pointer array to be sorted */
    2439 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    2440 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2441 int* intarray1, /**< first int array to be permuted in the same way */
    2442 int* intarray2, /**< second int array to be permuted in the same way */
    2443 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    2444 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2445 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2446 int len, /**< length of arrays */
    2447 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2448 );
    2449
    2450
    2451/** partial sort an array of Reals in non-increasing order around the \p k-th element,
    2452 * see \ref SelectionAlgorithms for more information.
    2453 */
    2454SCIP_EXPORT
    2455void SCIPselectDownReal(
    2456 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2457 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2458 int len /**< length of arrays */
    2459 );
    2460
    2461
    2462/** partial sort an array of Reals in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2463 * see \ref SelectionAlgorithms for more information.
    2464 */
    2465SCIP_EXPORT
    2466void SCIPselectWeightedDownReal(
    2467 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2468 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2469 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2470 int len, /**< length of arrays */
    2471 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2472 );
    2473
    2474
    2475/** partial sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order around the \p k-th element,
    2476 * see \ref SelectionAlgorithms for more information.
    2477 */
    2478SCIP_EXPORT
    2479void SCIPselectDownRealPtr(
    2480 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2481 void** ptrarray, /**< pointer array to be permuted in the same way */
    2482 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2483 int len /**< length of arrays */
    2484 );
    2485
    2486
    2487/** partial sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2488 * see \ref SelectionAlgorithms for more information.
    2489 */
    2490SCIP_EXPORT
    2491void SCIPselectWeightedDownRealPtr(
    2492 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2493 void** ptrarray, /**< pointer array to be permuted in the same way */
    2494 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2495 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2496 int len, /**< length of arrays */
    2497 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2498 );
    2499
    2500
    2501/** partial sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order around the \p k-th element,
    2502 * see \ref SelectionAlgorithms for more information.
    2503 */
    2504SCIP_EXPORT
    2505void SCIPselectDownRealInt(
    2506 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2507 int* intarray, /**< pointer array to be permuted in the same way */
    2508 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2509 int len /**< length of arrays */
    2510 );
    2511
    2512
    2513/** partial sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2514 * see \ref SelectionAlgorithms for more information.
    2515 */
    2516SCIP_EXPORT
    2517void SCIPselectDownRealIntInt(
    2518 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2519 int* intarray1, /**< first int array to be permuted in the same way */
    2520 int* intarray2, /**< second int array to be permuted in the same way */
    2521 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2522 int len /**< length of arrays */
    2523 );
    2524
    2525
    2526/** partial sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    2527 * see \ref SelectionAlgorithms for more information.
    2528 */
    2529SCIP_EXPORT
    2530void SCIPselectWeightedDownRealInt(
    2531 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2532 int* intarray, /**< pointer array to be permuted in the same way */
    2533 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2534 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2535 int len, /**< length of arrays */
    2536 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2537 );
    2538
    2539
    2540/** 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. \p weights and capacity,
    2541 * see \ref SelectionAlgorithms for more information.
    2542 */
    2543SCIP_EXPORT
    2544void SCIPselectWeightedDownRealIntInt(
    2545 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2546 int* intarray1, /**< first int array to be permuted in the same way */
    2547 int* intarray2, /**< second int array to be permuted in the same way */
    2548 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2549 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2550 int len, /**< length of arrays */
    2551 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2552 );
    2553
    2554
    2555/** partial sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order around the \p k-th element,
    2556 * see \ref SelectionAlgorithms for more information.
    2557 */
    2558SCIP_EXPORT
    2559void SCIPselectDownRealBoolPtr(
    2560 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2561 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2562 void** ptrarray, /**< pointer array to be permuted in the same way */
    2563 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2564 int len /**< length of arrays */
    2565 );
    2566
    2567
    2568/** 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. \p weights and capacity,
    2569 * see \ref SelectionAlgorithms for more information.
    2570 */
    2571SCIP_EXPORT
    2572void SCIPselectWeightedDownRealBoolPtr(
    2573 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2574 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2575 void** ptrarray, /**< pointer array to be permuted in the same way */
    2576 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2577 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2578 int len, /**< length of arrays */
    2579 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2580 );
    2581
    2582
    2583/** partial sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order around the \p k-th element,
    2584 * see \ref SelectionAlgorithms for more information.
    2585 */
    2586SCIP_EXPORT
    2587void SCIPselectDownRealIntLong(
    2588 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2589 int* intarray, /**< int array to be permuted in the same way */
    2590 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2591 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2592 int len /**< length of arrays */
    2593 );
    2594
    2595
    2596/** 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. \p weights and capacity,
    2597 * see \ref SelectionAlgorithms for more information.
    2598 */
    2599SCIP_EXPORT
    2600void SCIPselectWeightedDownRealIntLong(
    2601 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2602 int* intarray, /**< int array to be permuted in the same way */
    2603 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2604 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2605 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2606 int len, /**< length of arrays */
    2607 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2608 );
    2609
    2610
    2611/** partial sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order around the \p k-th element,
    2612 * see \ref SelectionAlgorithms for more information.
    2613 */
    2614SCIP_EXPORT
    2615void SCIPselectDownRealIntPtr(
    2616 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2617 int* intarray, /**< int array to be permuted in the same way */
    2618 void** ptrarray, /**< pointer array to be permuted in the same way */
    2619 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2620 int len /**< length of arrays */
    2621 );
    2622
    2623
    2624/** 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. \p weights and capacity,
    2625 * see \ref SelectionAlgorithms for more information.
    2626 */
    2627SCIP_EXPORT
    2628void SCIPselectWeightedDownRealIntPtr(
    2629 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2630 int* intarray, /**< int array to be permuted in the same way */
    2631 void** ptrarray, /**< pointer array to be permuted in the same way */
    2632 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2633 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2634 int len, /**< length of arrays */
    2635 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2636 );
    2637
    2638
    2639/** partial sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order around the \p k-th element,
    2640 * see \ref SelectionAlgorithms for more information.
    2641 */
    2642SCIP_EXPORT
    2643void SCIPselectDownRealRealInt(
    2644 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    2645 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    2646 int* intarray, /**< integer array to be permuted in the same way */
    2647 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2648 int len /**< length of arrays */
    2649 );
    2650
    2651
    2652/** 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. \p weights and capacity,
    2653 * see \ref SelectionAlgorithms for more information.
    2654 */
    2655SCIP_EXPORT
    2656void SCIPselectWeightedDownRealRealInt(
    2657 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    2658 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    2659 int* intarray, /**< integer array to be permuted in the same way */
    2660 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2661 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2662 int len, /**< length of arrays */
    2663 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2664 );
    2665
    2666
    2667/** partial sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order around the \p k-th element,
    2668 * see \ref SelectionAlgorithms for more information.
    2669 */
    2670SCIP_EXPORT
    2671void SCIPselectDownRealRealPtr(
    2672 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    2673 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    2674 void** ptrarray, /**< pointer array to be permuted in the same way */
    2675 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2676 int len /**< length of arrays */
    2677 );
    2678
    2679
    2680/** 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. \p weights and capacity,
    2681 * see \ref SelectionAlgorithms for more information.
    2682 */
    2683SCIP_EXPORT
    2684void SCIPselectWeightedDownRealRealPtr(
    2685 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    2686 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    2687 void** ptrarray, /**< pointer array to be permuted in the same way */
    2688 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2689 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2690 int len, /**< length of arrays */
    2691 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2692 );
    2693
    2694/** partial sort of three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order around the \p k-th element */
    2695SCIP_EXPORT
    2696void SCIPselectDownRealRealPtrPtr(
    2697 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    2698 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    2699 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2700 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2701 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2702 int len /**< length of arrays */
    2703 );
    2704
    2705/** 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. \p weights and capacity */
    2706SCIP_EXPORT
    2707void SCIPselectWeightedDownRealRealPtrPtr(
    2708 SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
    2709 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    2710 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2711 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2712 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2713 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2714 int len, /**< length of arrays */
    2715 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2716 );
    2717
    2718/** partial sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order around the \p k-th element,
    2719 * see \ref SelectionAlgorithms for more information.
    2720 */
    2721SCIP_EXPORT
    2722void SCIPselectDownRealPtrPtrInt(
    2723 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2724 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2725 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2726 int* intarray, /**< int array to be sorted */
    2727 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2728 int len /**< length of arrays */
    2729 );
    2730
    2731
    2732/** 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. \p weights and capacity,
    2733 * see \ref SelectionAlgorithms for more information.
    2734 */
    2735SCIP_EXPORT
    2736void SCIPselectWeightedDownRealPtrPtrInt(
    2737 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2738 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2739 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2740 int* intarray, /**< int array to be sorted */
    2741 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2742 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2743 int len, /**< length of arrays */
    2744 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2745 );
    2746
    2747
    2748/** partial sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2749 * see \ref SelectionAlgorithms for more information.
    2750 */
    2751SCIP_EXPORT
    2752void SCIPselectDownRealPtrPtrIntInt(
    2753 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2754 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2755 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2756 int* intarray1, /**< int array to be sorted */
    2757 int* intarray2, /**< int array to be sorted */
    2758 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2759 int len /**< length of arrays */
    2760 );
    2761
    2762
    2763/** 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. \p weights and capacity,
    2764 * see \ref SelectionAlgorithms for more information.
    2765 */
    2766SCIP_EXPORT
    2767void SCIPselectWeightedDownRealPtrPtrIntInt(
    2768 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2769 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2770 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2771 int* intarray1, /**< int array to be sorted */
    2772 int* intarray2, /**< int array to be sorted */
    2773 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2774 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2775 int len, /**< length of arrays */
    2776 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2777 );
    2778
    2779
    2780/** partial sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order around the \p k-th element,
    2781 * see \ref SelectionAlgorithms for more information.
    2782 */
    2783SCIP_EXPORT
    2784void SCIPselectDownRealLongRealInt(
    2785 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2786 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2787 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2788 int* intarray, /**< int array to be permuted in the same way */
    2789 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2790 int len /**< length of arrays */
    2791 );
    2792
    2793
    2794/** 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. \p weights and capacity,
    2795 * see \ref SelectionAlgorithms for more information.
    2796 */
    2797SCIP_EXPORT
    2798void SCIPselectWeightedDownRealLongRealInt(
    2799 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2800 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    2801 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2802 int* intarray, /**< int array to be permuted in the same way */
    2803 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2804 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2805 int len, /**< length of arrays */
    2806 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2807 );
    2808
    2809
    2810/** partial sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    2811 * see \ref SelectionAlgorithms for more information.
    2812 */
    2813SCIP_EXPORT
    2814void SCIPselectDownRealRealIntInt(
    2815 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2816 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2817 int* intarray1, /**< int array to be permuted in the same way */
    2818 int* intarray2, /**< int array to be permuted in the same way */
    2819 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2820 int len /**< length of arrays */
    2821 );
    2822
    2823
    2824/** 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. \p weights and capacity,
    2825 * see \ref SelectionAlgorithms for more information.
    2826 */
    2827SCIP_EXPORT
    2828void SCIPselectWeightedDownRealRealIntInt(
    2829 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2830 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2831 int* intarray1, /**< int array to be permuted in the same way */
    2832 int* intarray2, /**< int array to be permuted in the same way */
    2833 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2834 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2835 int len, /**< length of arrays */
    2836 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2837 );
    2838
    2839
    2840/** partial sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order around the \p k-th element,
    2841 * see \ref SelectionAlgorithms for more information.
    2842 */
    2843SCIP_EXPORT
    2844void SCIPselectDownRealRealRealInt(
    2845 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2846 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2847 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2848 int* intarray, /**< int array to be permuted in the same way */
    2849 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2850 int len /**< length of arrays */
    2851 );
    2852
    2853
    2854/** 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. \p weights and capacity,
    2855 * see \ref SelectionAlgorithms for more information.
    2856 */
    2857SCIP_EXPORT
    2858void SCIPselectWeightedDownRealRealRealInt(
    2859 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2860 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2861 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2862 int* intarray, /**< int array to be permuted in the same way */
    2863 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2864 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2865 int len, /**< length of arrays */
    2866 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2867 );
    2868
    2869
    2870/** partial sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order around the \p k-th element,
    2871 * see \ref SelectionAlgorithms for more information.
    2872 */
    2873SCIP_EXPORT
    2874void SCIPselectDownRealRealRealPtr(
    2875 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2876 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2877 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2878 void** ptrarray, /**< pointer array to be permuted in the same way */
    2879 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2880 int len /**< length of arrays */
    2881 );
    2882
    2883
    2884/** 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. \p weights and capacity,
    2885 * see \ref SelectionAlgorithms for more information.
    2886 */
    2887SCIP_EXPORT
    2888void SCIPselectWeightedDownRealRealRealPtr(
    2889 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2890 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2891 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2892 void** ptrarray, /**< pointer array to be permuted in the same way */
    2893 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2894 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2895 int len, /**< length of arrays */
    2896 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2897 );
    2898
    2899
    2900/** partial sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the \p k-th element,
    2901 * see \ref SelectionAlgorithms for more information.
    2902 */
    2903SCIP_EXPORT
    2904void SCIPselectDownRealPtrPtr(
    2905 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2906 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2907 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2908 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2909 int len /**< length of arrays */
    2910 );
    2911
    2912
    2913/** partial sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order around the weighted median w.r.t. \p weights and capacity,
    2914 * see \ref SelectionAlgorithms for more information.
    2915 */
    2916SCIP_EXPORT
    2917void SCIPselectWeightedDownRealPtrPtr(
    2918 SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
    2919 void** ptrarray1, /**< pointer array to be permuted in the same way */
    2920 void** ptrarray2, /**< pointer array to be permuted in the same way */
    2921 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2922 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2923 int len, /**< length of arrays */
    2924 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2925 );
    2926
    2927
    2928/** partial sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order around the \p k-th element,
    2929 * see \ref SelectionAlgorithms for more information.
    2930 */
    2931SCIP_EXPORT
    2932void SCIPselectDownRealRealRealBoolPtr(
    2933 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2934 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2935 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2936 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2937 void** ptrarray, /**< pointer array to be permuted in the same way */
    2938 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2939 int len /**< length of arrays */
    2940 );
    2941
    2942
    2943/** 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. \p weights and capacity,
    2944 * see \ref SelectionAlgorithms for more information.
    2945 */
    2946SCIP_EXPORT
    2947void SCIPselectWeightedDownRealRealRealBoolPtr(
    2948 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2949 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2950 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2951 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    2952 void** ptrarray, /**< pointer array to be permuted in the same way */
    2953 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2954 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2955 int len, /**< length of arrays */
    2956 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2957 );
    2958
    2959
    2960/** partial sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order around the \p k-th element,
    2961 * see \ref SelectionAlgorithms for more information.
    2962 */
    2963SCIP_EXPORT
    2964void SCIPselectDownRealRealRealBoolBoolPtr(
    2965 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2966 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2967 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2968 SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
    2969 SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
    2970 void** ptrarray, /**< pointer array to be permuted in the same way */
    2971 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    2972 int len /**< length of arrays */
    2973 );
    2974
    2975
    2976/** 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. \p weights and capacity,
    2977 * see \ref SelectionAlgorithms for more information.
    2978 */
    2979SCIP_EXPORT
    2980void SCIPselectWeightedDownRealRealRealBoolBoolPtr(
    2981 SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
    2982 SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
    2983 SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
    2984 SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
    2985 SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
    2986 void** ptrarray, /**< pointer array to be permuted in the same way */
    2987 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    2988 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    2989 int len, /**< length of arrays */
    2990 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    2991 );
    2992
    2993
    2994/** partial sort array of ints in non-increasing order around the \p k-th element,
    2995 * see \ref SelectionAlgorithms for more information.
    2996 */
    2997SCIP_EXPORT
    2998void SCIPselectDownInt(
    2999 int* intarray, /**< int array to be sorted */
    3000 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3001 int len /**< length of arrays */
    3002 );
    3003
    3004
    3005/** partial sort array of ints in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    3006 * see \ref SelectionAlgorithms for more information.
    3007 */
    3008SCIP_EXPORT
    3009void SCIPselectWeightedDownInt(
    3010 int* intarray, /**< int array to be sorted */
    3011 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3012 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3013 int len, /**< length of arrays */
    3014 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3015 );
    3016
    3017
    3018/** partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    3019 * see \ref SelectionAlgorithms for more information.
    3020 */
    3021SCIP_EXPORT
    3022void SCIPselectDownIntInt(
    3023 int* intarray1, /**< int array to be sorted */
    3024 int* intarray2, /**< second int array to be permuted in the same way */
    3025 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3026 int len /**< length of arrays */
    3027 );
    3028
    3029
    3030/** partial sort of two joint arrays of ints/ints, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    3031 * see \ref SelectionAlgorithms for more information.
    3032 */
    3033SCIP_EXPORT
    3034void SCIPselectWeightedDownIntInt(
    3035 int* intarray1, /**< int array to be sorted */
    3036 int* intarray2, /**< second int array to be permuted in the same way */
    3037 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3038 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3039 int len, /**< length of arrays */
    3040 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3041 );
    3042
    3043
    3044/** partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the \p k-th element,
    3045 * see \ref SelectionAlgorithms for more information.
    3046 */
    3047SCIP_EXPORT
    3048void SCIPselectDownIntPtr(
    3049 int* intarray, /**< int array to be sorted */
    3050 void** ptrarray, /**< pointer array to be permuted in the same way */
    3051 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3052 int len /**< length of arrays */
    3053 );
    3054
    3055
    3056/** partial sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    3057 * see \ref SelectionAlgorithms for more information.
    3058 */
    3059SCIP_EXPORT
    3060void SCIPselectWeightedDownIntPtr(
    3061 int* intarray, /**< int array to be sorted */
    3062 void** ptrarray, /**< pointer array to be permuted in the same way */
    3063 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3064 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3065 int len, /**< length of arrays */
    3066 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3067 );
    3068
    3069
    3070/** partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the \p k-th element,
    3071 * see \ref SelectionAlgorithms for more information.
    3072 */
    3073SCIP_EXPORT
    3074void SCIPselectDownIntReal(
    3075 int* intarray, /**< int array to be sorted */
    3076 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    3077 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3078 int len /**< length of arrays */
    3079 );
    3080
    3081
    3082/** partial sort of two joint arrays of ints/reals, sorted by first array in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    3083 * see \ref SelectionAlgorithms for more information.
    3084 */
    3085SCIP_EXPORT
    3086void SCIPselectWeightedDownIntReal(
    3087 int* intarray, /**< int array to be sorted */
    3088 SCIP_Real* realarray, /**< real array to be permuted in the same way */
    3089 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3090 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3091 int len, /**< length of arrays */
    3092 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3093 );
    3094
    3095
    3096/** partial sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    3097 * see \ref SelectionAlgorithms for more information.
    3098 */
    3099SCIP_EXPORT
    3100void SCIPselectDownIntIntInt(
    3101 int* intarray1, /**< int array to be sorted */
    3102 int* intarray2, /**< second int array to be permuted in the same way */
    3103 int* intarray3, /**< third int array to be permuted in the same way */
    3104 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3105 int len /**< length of arrays */
    3106 );
    3107
    3108
    3109/** 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. \p weights and capacity,
    3110 * see \ref SelectionAlgorithms for more information.
    3111 */
    3112SCIP_EXPORT
    3113void SCIPselectWeightedDownIntIntInt(
    3114 int* intarray1, /**< int array to be sorted */
    3115 int* intarray2, /**< second int array to be permuted in the same way */
    3116 int* intarray3, /**< third int array to be permuted in the same way */
    3117 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3118 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3119 int len, /**< length of arrays */
    3120 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3121 );
    3122
    3123
    3124/** partial sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order around the \p k-th element,
    3125 * see \ref SelectionAlgorithms for more information.
    3126 */
    3127SCIP_EXPORT
    3128void SCIPselectDownIntIntLong(
    3129 int* intarray1, /**< int array to be sorted */
    3130 int* intarray2, /**< second int array to be permuted in the same way */
    3131 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    3132 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3133 int len /**< length of arrays */
    3134 );
    3135
    3136
    3137/** 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. \p weights and capacity,
    3138 * see \ref SelectionAlgorithms for more information.
    3139 */
    3140SCIP_EXPORT
    3141void SCIPselectWeightedDownIntIntLong(
    3142 int* intarray1, /**< int array to be sorted */
    3143 int* intarray2, /**< second int array to be permuted in the same way */
    3144 SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
    3145 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3146 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3147 int len, /**< length of arrays */
    3148 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3149 );
    3150
    3151
    3152/** partial sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order around the \p k-th element,
    3153 * see \ref SelectionAlgorithms for more information.
    3154 */
    3155SCIP_EXPORT
    3156void SCIPselectDownIntIntPtr(
    3157 int* intarray1, /**< int array to be sorted */
    3158 int* intarray2, /**< second int array to be permuted in the same way */
    3159 void** ptrarray, /**< pointer array to be permuted in the same way */
    3160 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3161 int len /**< length of arrays */
    3162 );
    3163
    3164
    3165/** 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. \p weights and capacity,
    3166 * see \ref SelectionAlgorithms for more information.
    3167 */
    3168SCIP_EXPORT
    3169void SCIPselectWeightedDownIntIntPtr(
    3170 int* intarray1, /**< int array to be sorted */
    3171 int* intarray2, /**< second int array to be permuted in the same way */
    3172 void** ptrarray, /**< pointer array to be permuted in the same way */
    3173 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3174 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3175 int len, /**< length of arrays */
    3176 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3177 );
    3178
    3179
    3180/** partial sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order around the \p k-th element,
    3181 * see \ref SelectionAlgorithms for more information.
    3182 */
    3183SCIP_EXPORT
    3184void SCIPselectDownIntIntReal(
    3185 int* intarray1, /**< int array to be sorted */
    3186 int* intarray2, /**< second int array to be permuted in the same way */
    3187 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3188 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3189 int len /**< length of arrays */
    3190 );
    3191
    3192
    3193/** 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. \p weights and capacity,
    3194 * see \ref SelectionAlgorithms for more information.
    3195 */
    3196SCIP_EXPORT
    3197void SCIPselectWeightedDownIntIntReal(
    3198 int* intarray1, /**< int array to be sorted */
    3199 int* intarray2, /**< second int array to be permuted in the same way */
    3200 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3201 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3202 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3203 int len, /**< length of arrays */
    3204 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3205 );
    3206
    3207
    3208/** partial sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order around the \p k-th element,
    3209 * see \ref SelectionAlgorithms for more information.
    3210 */
    3211SCIP_EXPORT
    3212void SCIPselectDownIntIntIntPtr(
    3213 int* intarray1, /**< int array to be sorted */
    3214 int* intarray2, /**< int array to be permuted in the same way */
    3215 int* intarray3, /**< int array to be permuted in the same way */
    3216 void** ptrarray, /**< pointer array to be permuted in the same way */
    3217 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3218 int len /**< length of arrays */
    3219 );
    3220
    3221
    3222/** 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. \p weights and capacity,
    3223 * see \ref SelectionAlgorithms for more information.
    3224 */
    3225SCIP_EXPORT
    3226void SCIPselectWeightedDownIntIntIntPtr(
    3227 int* intarray1, /**< int array to be sorted */
    3228 int* intarray2, /**< int array to be permuted in the same way */
    3229 int* intarray3, /**< int array to be permuted in the same way */
    3230 void** ptrarray, /**< pointer array to be permuted in the same way */
    3231 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3232 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3233 int len, /**< length of arrays */
    3234 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3235 );
    3236
    3237
    3238/** partial sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order around the \p k-th element,
    3239 * see \ref SelectionAlgorithms for more information.
    3240 */
    3241SCIP_EXPORT
    3242void SCIPselectDownIntIntIntReal(
    3243 int* intarray1, /**< int array to be sorted */
    3244 int* intarray2, /**< int array to be permuted in the same way */
    3245 int* intarray3, /**< int array to be permuted in the same way */
    3246 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3247 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3248 int len /**< length of arrays */
    3249 );
    3250
    3251
    3252/** 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. \p weights and capacity,
    3253 * see \ref SelectionAlgorithms for more information.
    3254 */
    3255SCIP_EXPORT
    3256void SCIPselectWeightedDownIntIntIntReal(
    3257 int* intarray1, /**< int array to be sorted */
    3258 int* intarray2, /**< int array to be permuted in the same way */
    3259 int* intarray3, /**< int array to be permuted in the same way */
    3260 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3261 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3262 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3263 int len, /**< length of arrays */
    3264 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3265 );
    3266
    3267
    3268/** partial sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order around the \p k-th element,
    3269 * see \ref SelectionAlgorithms for more information.
    3270 */
    3271SCIP_EXPORT
    3272void SCIPselectDownIntPtrIntReal(
    3273 int* intarray1, /**< int array to be sorted */
    3274 void** ptrarray, /**< pointer array to be permuted in the same way */
    3275 int* intarray2, /**< int array to be permuted in the same way */
    3276 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3277 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3278 int len /**< length of arrays */
    3279 );
    3280
    3281
    3282/** 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. \p weights and capacity,
    3283 * see \ref SelectionAlgorithms for more information.
    3284 */
    3285SCIP_EXPORT
    3286void SCIPselectWeightedDownIntPtrIntReal(
    3287 int* intarray1, /**< int array to be sorted */
    3288 void** ptrarray, /**< pointer array to be permuted in the same way */
    3289 int* intarray2, /**< int array to be permuted in the same way */
    3290 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3291 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3292 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3293 int len, /**< length of arrays */
    3294 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3295 );
    3296
    3297
    3298/** partial sort an array of Longints in non-increasing order around the \p k-th element,
    3299 * see \ref SelectionAlgorithms for more information.
    3300 */
    3301SCIP_EXPORT
    3302void SCIPselectDownLong(
    3303 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3304 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3305 int len /**< length of arrays */
    3306 );
    3307
    3308
    3309/** partial sort an array of Longints in non-increasing order around the weighted median w.r.t. \p weights and capacity,
    3310 * see \ref SelectionAlgorithms for more information.
    3311 */
    3312SCIP_EXPORT
    3313void SCIPselectWeightedDownLong(
    3314 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3315 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3316 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3317 int len, /**< length of arrays */
    3318 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3319 );
    3320
    3321
    3322/** partial sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order around the \p k-th element,
    3323 * see \ref SelectionAlgorithms for more information.
    3324 */
    3325SCIP_EXPORT
    3326void SCIPselectDownLongPtr(
    3327 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3328 void** ptrarray, /**< pointer array to be permuted in the same way */
    3329 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3330 int len /**< length of arrays */
    3331 );
    3332
    3333
    3334/** 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. \p weights and capacity,
    3335 * see \ref SelectionAlgorithms for more information.
    3336 */
    3337SCIP_EXPORT
    3338void SCIPselectWeightedDownLongPtr(
    3339 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3340 void** ptrarray, /**< pointer array to be permuted in the same way */
    3341 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3342 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3343 int len, /**< length of arrays */
    3344 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3345 );
    3346
    3347
    3348/** partial sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order around the \p k-th element,
    3349 * see \ref SelectionAlgorithms for more information.
    3350 */
    3351SCIP_EXPORT
    3352void SCIPselectDownLongPtrInt(
    3353 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3354 void** ptrarray, /**< pointer array to be permuted in the same way */
    3355 int* intarray, /**< int array to be permuted in the same way */
    3356 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3357 int len /**< length of arrays */
    3358 );
    3359
    3360
    3361/** 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. \p weights and capacity,
    3362 * see \ref SelectionAlgorithms for more information.
    3363 */
    3364SCIP_EXPORT
    3365void SCIPselectWeightedDownLongPtrInt(
    3366 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3367 void** ptrarray, /**< pointer array to be permuted in the same way */
    3368 int* intarray, /**< int array to be permuted in the same way */
    3369 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3370 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3371 int len, /**< length of arrays */
    3372 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3373 );
    3374
    3375
    3376/** partial sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order around the \p k-th element,
    3377 * see \ref SelectionAlgorithms for more information.
    3378 */
    3379SCIP_EXPORT
    3380void SCIPselectDownLongPtrRealBool(
    3381 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3382 void** ptrarray, /**< pointer array to be permuted in the same way */
    3383 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3384 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3385 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3386 int len /**< length of arrays */
    3387 );
    3388
    3389
    3390/** 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. \p weights and capacity,
    3391 * see \ref SelectionAlgorithms for more information.
    3392 */
    3393SCIP_EXPORT
    3394void SCIPselectWeightedDownLongPtrRealBool(
    3395 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3396 void** ptrarray, /**< pointer array to be permuted in the same way */
    3397 SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
    3398 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3399 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3400 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3401 int len, /**< length of arrays */
    3402 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3403 );
    3404
    3405
    3406/** partial sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order around the \p k-th element,
    3407 * see \ref SelectionAlgorithms for more information.
    3408 */
    3409SCIP_EXPORT
    3410void SCIPselectDownLongPtrRealRealBool(
    3411 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3412 void** ptrarray, /**< pointer array to be permuted in the same way */
    3413 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    3414 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    3415 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3416 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3417 int len /**< length of arrays */
    3418 );
    3419
    3420
    3421/** 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. \p weights and capacity,
    3422 * see \ref SelectionAlgorithms for more information.
    3423 */
    3424SCIP_EXPORT
    3425void SCIPselectWeightedDownLongPtrRealRealBool(
    3426 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3427 void** ptrarray, /**< pointer array to be permuted in the same way */
    3428 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    3429 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    3430 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3431 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3432 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3433 int len, /**< length of arrays */
    3434 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3435 );
    3436
    3437
    3438/** partial sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order around the \p k-th element,
    3439 * see \ref SelectionAlgorithms for more information.
    3440 */
    3441SCIP_EXPORT
    3442void SCIPselectDownLongPtrRealRealIntBool(
    3443 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3444 void** ptrarray, /**< pointer array to be permuted in the same way */
    3445 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    3446 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    3447 int* intarray, /**< int array to be permuted in the same way */
    3448 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3449 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3450 int len /**< length of arrays */
    3451 );
    3452
    3453
    3454/** 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. \p weights and capacity,
    3455 * see \ref SelectionAlgorithms for more information.
    3456 */
    3457SCIP_EXPORT
    3458void SCIPselectWeightedDownLongPtrRealRealIntBool(
    3459 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3460 void** ptrarray, /**< pointer array to be permuted in the same way */
    3461 SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
    3462 SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
    3463 int* intarray, /**< int array to be permuted in the same way */
    3464 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3465 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3466 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3467 int len, /**< length of arrays */
    3468 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3469 );
    3470
    3471
    3472/** partial sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order around the \p k-th element,
    3473 * see \ref SelectionAlgorithms for more information.
    3474 */
    3475SCIP_EXPORT
    3476void SCIPselectDownLongPtrPtrInt(
    3477 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3478 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    3479 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    3480 int* intarray, /**< int array to be permuted in the same way */
    3481 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3482 int len /**< length of arrays */
    3483 );
    3484
    3485
    3486/** 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. \p weights and capacity,
    3487 * see \ref SelectionAlgorithms for more information.
    3488 */
    3489SCIP_EXPORT
    3490void SCIPselectWeightedDownLongPtrPtrInt(
    3491 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3492 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    3493 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    3494 int* intarray, /**< int array to be permuted in the same way */
    3495 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3496 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3497 int len, /**< length of arrays */
    3498 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3499 );
    3500
    3501
    3502/** partial sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order around the \p k-th element,
    3503 * see \ref SelectionAlgorithms for more information.
    3504 */
    3505SCIP_EXPORT
    3506void SCIPselectDownLongPtrPtrIntInt(
    3507 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3508 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    3509 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    3510 int* intarray1, /**< first int array to be permuted in the same way */
    3511 int* intarray2, /**< second int array to be permuted in the same way */
    3512 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3513 int len /**< length of arrays */
    3514 );
    3515
    3516
    3517/** 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. \p weights and capacity,
    3518 * see \ref SelectionAlgorithms for more information.
    3519 */
    3520SCIP_EXPORT
    3521void SCIPselectWeightedDownLongPtrPtrIntInt(
    3522 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3523 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    3524 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    3525 int* intarray1, /**< first int array to be permuted in the same way */
    3526 int* intarray2, /**< second int array to be permuted in the same way */
    3527 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3528 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3529 int len, /**< length of arrays */
    3530 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3531 );
    3532
    3533
    3534/** partial sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order around the \p k-th element,
    3535 * see \ref SelectionAlgorithms for more information.
    3536 */
    3537SCIP_EXPORT
    3538void SCIPselectDownLongPtrPtrBoolInt(
    3539 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3540 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    3541 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    3542 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3543 int* intarray, /**< int array to be sorted */
    3544 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3545 int len /**< length of arrays */
    3546 );
    3547
    3548
    3549/** 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. \p weights and capacity,
    3550 * see \ref SelectionAlgorithms for more information.
    3551 */
    3552SCIP_EXPORT
    3553void SCIPselectWeightedDownLongPtrPtrBoolInt(
    3554 SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
    3555 void** ptrarray1, /**< first pointer array to be permuted in the same way */
    3556 void** ptrarray2, /**< second pointer array to be permuted in the same way */
    3557 SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
    3558 int* intarray, /**< int array to be sorted */
    3559 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3560 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3561 int len, /**< length of arrays */
    3562 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3563 );
    3564
    3565
    3566/** partial sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the \p k-th element,
    3567 * see \ref SelectionAlgorithms for more information.
    3568 */
    3569SCIP_EXPORT
    3570void SCIPselectDownPtrIntIntBoolBool(
    3571 void** ptrarray, /**< pointer array to be sorted */
    3572 int* intarray1, /**< first int array to be permuted in the same way */
    3573 int* intarray2, /**< second int array to be permuted in the same way */
    3574 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    3575 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    3576 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    3577 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3578 int len /**< length of arrays */
    3579 );
    3580
    3581
    3582/** 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. \p weights and capacity,
    3583 * see \ref SelectionAlgorithms for more information.
    3584 */
    3585SCIP_EXPORT
    3586void SCIPselectWeightedDownPtrIntIntBoolBool(
    3587 void** ptrarray, /**< pointer array to be sorted */
    3588 int* intarray1, /**< first int array to be permuted in the same way */
    3589 int* intarray2, /**< second int array to be permuted in the same way */
    3590 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    3591 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    3592 SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
    3593 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3594 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3595 int len, /**< length of arrays */
    3596 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3597 );
    3598
    3599
    3600/** partial sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order around the \p k-th element,
    3601 * see \ref SelectionAlgorithms for more information.
    3602 */
    3603SCIP_EXPORT
    3604void SCIPselectDownIntPtrIntIntBoolBool(
    3605 int* intarray1, /**< int array to be sorted */
    3606 void** ptrarray, /**< pointer array to be permuted in the same way */
    3607 int* intarray2, /**< second int array to be permuted in the same way */
    3608 int* intarray3, /**< thrid int array to be permuted in the same way */
    3609 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    3610 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    3611 int k, /**< the index of the desired element, must be between 0 (search for maximum/minimum) and len - 1 */
    3612 int len /**< length of arrays */
    3613 );
    3614
    3615
    3616/** 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. \p weights and capacity,
    3617 * see \ref SelectionAlgorithms for more information.
    3618 */
    3619SCIP_EXPORT
    3620void SCIPselectWeightedDownIntPtrIntIntBoolBool(
    3621 int* intarray1, /**< int array to be sorted */
    3622 void** ptrarray, /**< pointer array to be permuted in the same way */
    3623 int* intarray2, /**< second int array to be permuted in the same way */
    3624 int* intarray3, /**< thrid int array to be permuted in the same way */
    3625 SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
    3626 SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
    3627 SCIP_Real* weights, /**< (optional), nonnegative weights array for weighted median, or NULL (all weights are equal to 1) */
    3628 SCIP_Real capacity, /**< the maximum capacity that is exceeded by the median */
    3629 int len, /**< length of arrays */
    3630 int* medianpos /**< pointer to store the index of the weighted median, or NULL, if not needed */
    3631 );
    3632
    3633/**@} */
    3634
    3635#ifdef __cplusplus
    3636}
    3637#endif
    3638
    3639#endif
    def.h
    common defines and data types used in all packages of SCIP
    SCIP_Longint
    #define SCIP_Longint
    Definition: def.h:141
    SCIP_Bool
    #define SCIP_Bool
    Definition: def.h:91
    SCIP_Real
    #define SCIP_Real
    Definition: def.h:156
    SCIPselectWeightedDownRealRealRealBoolBoolPtr
    void SCIPselectWeightedDownRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealIntPtr
    void SCIPselectRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int k, int len)
    SCIPselectWeightedLong
    void SCIPselectWeightedLong(SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntIntIntReal
    void SCIPselectWeightedIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntIntIntReal
    void SCIPselectDownIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedIntIntReal
    void SCIPselectWeightedIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntPtrReal
    void SCIPselectWeightedIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntInt
    void SCIPselectDownIntInt(int *intarray1, int *intarray2, int k, int len)
    SCIPselectDownPtrIntIntBoolBool
    void SCIPselectDownPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectRealInt
    void SCIPselectRealInt(SCIP_Real *realarray, int *intarray, int k, int len)
    SCIPselectWeightedDownRealRealRealBoolPtr
    void SCIPselectWeightedDownRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealIntPtr
    void SCIPselectDownRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int k, int len)
    SCIPselectWeightedDownRealLongRealInt
    void SCIPselectWeightedDownRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealRealIntInt
    void SCIPselectWeightedRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownLongPtrRealBool
    void SCIPselectWeightedDownLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtr
    void SCIPselectPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedInt
    void SCIPselectWeightedInt(int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealPtrPtrIntInt
    void SCIPselectWeightedRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealRealRealInt
    void SCIPselectRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int k, int len)
    SCIPselectWeightedDownIntPtr
    void SCIPselectWeightedDownIntPtr(int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownLongPtrPtrBoolInt
    void SCIPselectWeightedDownLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntPtr
    void SCIPselectIntPtr(int *intarray, void **ptrarray, int k, int len)
    SCIPselectPtrBool
    void SCIPselectPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownPtrReal
    void SCIPselectDownPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownInt
    void SCIPselectDownInt(int *intarray, int k, int len)
    SCIPselectWeightedDownPtrInt
    void SCIPselectWeightedDownPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntIntReal
    void SCIPselectDownIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedRealLongRealInt
    void SCIPselectWeightedRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrPtrRealBool
    void SCIPselectDownPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectIntIntPtrPtr
    void SCIPselectIntIntPtrPtr(int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, int k, int len)
    SCIPselectWeightedDownRealInt
    void SCIPselectWeightedDownRealInt(SCIP_Real *realarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealPtr
    void SCIPselectWeightedRealPtr(SCIP_Real *realarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownIntPtrIntIntBoolBool
    void SCIPselectWeightedDownIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtrPtrInt
    void SCIPselectWeightedPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownPtrRealInt
    void SCIPselectWeightedDownPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealRealPtr
    void SCIPselectWeightedDownRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealBoolPtr
    void SCIPselectDownRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
    SCIPselectDownIntPtr
    void SCIPselectDownIntPtr(int *intarray, void **ptrarray, int k, int len)
    SCIPselectDownRealRealInt
    void SCIPselectDownRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, int k, int len)
    SCIPselectWeightedPtrRealBool
    void SCIPselectWeightedPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownIntIntLong
    void SCIPselectWeightedDownIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntPtrReal
    void SCIPselectIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int k, int len)
    SCIPselectRealRealRealBoolPtr
    void SCIPselectRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
    SCIPselectWeightedPtrInt
    void SCIPselectWeightedPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownIntReal
    void SCIPselectWeightedDownIntReal(int *intarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealBoolPtr
    void SCIPselectRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
    SCIPselectDownLongPtrRealRealBool
    void SCIPselectDownLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int k, int len)
    SCIPselectWeightedDownPtrRealBool
    void SCIPselectWeightedDownPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtrRealRealIntBool
    void SCIPselectLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int k, int len)
    SCIPselectPtrInt
    void SCIPselectPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownLongPtr
    void SCIPselectDownLongPtr(SCIP_Longint *longarray, void **ptrarray, int k, int len)
    SCIPselectWeightedDownRealRealRealInt
    void SCIPselectWeightedDownRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntRealLong
    void SCIPselectWeightedIntRealLong(int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtrPtrBoolInt
    void SCIPselectLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int k, int len)
    SCIPselectDownPtrInt
    void SCIPselectDownPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedPtrPtrIntInt
    void SCIPselectWeightedPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedLongPtrRealBool
    void SCIPselectWeightedLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntIntPtrPtrInterval
    void SCIPselectWeightedIntIntPtrPtrInterval(int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, SCIP_INTERVAL *intervalarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrPtrInt
    void SCIPselectPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectIntIntLong
    void SCIPselectIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int k, int len)
    SCIPselectDownReal
    void SCIPselectDownReal(SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedDownPtrPtrLongIntInt
    void SCIPselectWeightedDownPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealRealPtr
    void SCIPselectDownRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int k, int len)
    SCIPselectDownPtr
    void SCIPselectDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectRealRealRealPtr
    void SCIPselectRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int k, int len)
    SCIPselectDownRealRealRealInt
    void SCIPselectDownRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int k, int len)
    SCIPselectPtrPtrRealBool
    void SCIPselectPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectIntIntInt
    void SCIPselectIntIntInt(int *intarray1, int *intarray2, int *intarray3, int k, int len)
    SCIPselectInd
    void SCIPselectInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len)
    SCIPselectWeightedDownLongPtrInt
    void SCIPselectWeightedDownLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealIntInt
    void SCIPselectWeightedRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtrReal
    void SCIPselectWeightedPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownLong
    void SCIPselectDownLong(SCIP_Longint *longarray, int k, int len)
    SCIPselectDownLongPtrPtrIntInt
    void SCIPselectDownLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
    SCIPselectWeightedPtrRealIntInt
    void SCIPselectWeightedPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownLongPtrPtrInt
    void SCIPselectWeightedDownLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrPtrRealInt
    void SCIPselectDownPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownIntIntInt
    void SCIPselectWeightedDownIntIntInt(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrRealRealInt
    void SCIPselectPtrRealRealInt(void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectRealIntLong
    void SCIPselectRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int k, int len)
    SCIPselectWeightedDownIntIntIntReal
    void SCIPselectWeightedDownIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownPtrIntInt
    void SCIPselectWeightedDownPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealRealPtrPtr
    void SCIPselectDownRealRealPtrPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, int k, int len)
    SCIPselectWeightedPtrPtrLongInt
    void SCIPselectWeightedPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntIntLong
    void SCIPselectWeightedIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownPtrBool
    void SCIPselectWeightedDownPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownLongPtrPtrBoolInt
    void SCIPselectDownLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int k, int len)
    SCIPselectWeightedRealBoolPtr
    void SCIPselectWeightedRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownLongPtrRealBool
    void SCIPselectDownLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int k, int len)
    SCIPselectWeightedInd
    void SCIPselectWeightedInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownReal
    void SCIPselectWeightedDownReal(SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealIntInt
    void SCIPselectDownRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, int k, int len)
    SCIPselectPtrRealRealBoolBool
    void SCIPselectPtrRealRealBoolBool(void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedLongPtr
    void SCIPselectWeightedLongPtr(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownLongPtrPtrIntInt
    void SCIPselectWeightedDownLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealPtrPtrIntInt
    void SCIPselectWeightedDownRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrPtr
    void SCIPselectDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownRealRealInt
    void SCIPselectWeightedDownRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealLongRealInt
    void SCIPselectDownRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int k, int len)
    SCIPselectPtrPtr
    void SCIPselectPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownIntInt
    void SCIPselectWeightedDownIntInt(int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedLongPtrPtrBoolInt
    void SCIPselectWeightedLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealRealRealPtr
    void SCIPselectDownRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int k, int len)
    SCIPselectWeightedPtrRealRealBoolBool
    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)
    SCIPselectWeightedDownRealPtrPtr
    void SCIPselectWeightedDownRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntIntPtr
    void SCIPselectDownIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int k, int len)
    SCIPselectWeightedDownIntIntPtr
    void SCIPselectWeightedDownIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealPtrPtr
    void SCIPselectWeightedRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrRealIntInt
    void SCIPselectDownPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownPtrReal
    void SCIPselectWeightedDownPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntRealLong
    void SCIPselectIntRealLong(int *intarray, SCIP_Real *realarray, SCIP_Longint *longarray, int k, int len)
    SCIPselectWeightedDownRealPtrPtrInt
    void SCIPselectWeightedDownRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealIntPtr
    void SCIPselectWeightedDownRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtrRealInt
    void SCIPselectWeightedPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownPtrIntIntBoolBool
    void SCIPselectWeightedDownPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntPtr
    void SCIPselectWeightedIntPtr(int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownPtrPtrRealInt
    void SCIPselectWeightedDownPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrIntIntBoolBool
    void SCIPselectPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectIntIntIntReal
    void SCIPselectIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int k, int len)
    SCIPselectDownRealInt
    void SCIPselectDownRealInt(SCIP_Real *realarray, int *intarray, int k, int len)
    SCIPselectWeightedPtrIntInt
    void SCIPselectWeightedPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrPtrIntInt
    void SCIPselectDownPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedRealRealRealPtr
    void SCIPselectWeightedRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealIntLong
    void SCIPselectWeightedDownRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealPtrPtrInt
    void SCIPselectWeightedRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealPtr
    void SCIPselectRealPtr(SCIP_Real *realarray, void **ptrarray, int k, int len)
    SCIPselectWeightedDownRealBoolPtr
    void SCIPselectWeightedDownRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntReal
    void SCIPselectIntReal(int *intarray, SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedDownPtr
    void SCIPselectWeightedDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntInt
    void SCIPselectIntInt(int *intarray1, int *intarray2, int k, int len)
    SCIPselectWeightedLongPtrRealRealIntBool
    void SCIPselectWeightedLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealRealPtrPtr
    void SCIPselectWeightedDownRealRealPtrPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownLongPtrInt
    void SCIPselectDownLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, int k, int len)
    SCIPselectPtrRealBool
    void SCIPselectPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectRealPtrPtr
    void SCIPselectRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int k, int len)
    SCIPselectWeightedDownPtrPtrReal
    void SCIPselectWeightedDownPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownLongPtrRealRealIntBool
    void SCIPselectDownLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int k, int len)
    SCIPselectWeightedDownInd
    void SCIPselectWeightedDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtrPtrRealBool
    void SCIPselectWeightedPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrPtrIntInt
    void SCIPselectPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedIntReal
    void SCIPselectWeightedIntReal(int *intarray, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealRealPtr
    void SCIPselectWeightedRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealInt
    void SCIPselectWeightedRealInt(SCIP_Real *realarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtrPtrReal
    void SCIPselectWeightedPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntPtrIntReal
    void SCIPselectDownIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int k, int len)
    SCIPselectReal
    void SCIPselectReal(SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedDownLongPtr
    void SCIPselectWeightedDownLongPtr(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownIntIntReal
    void SCIPselectWeightedDownIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrBool
    void SCIPselectDownPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedLongPtrInt
    void SCIPselectWeightedLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownLongPtrRealRealBool
    void SCIPselectWeightedDownLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownIntIntIntPtr
    void SCIPselectWeightedDownIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrPtrInt
    void SCIPselectDownPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownIntReal
    void SCIPselectDownIntReal(int *intarray, SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedPtrBool
    void SCIPselectWeightedPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealRealIntInt
    void SCIPselectDownRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int k, int len)
    SCIPselectWeightedIntInt
    void SCIPselectWeightedIntInt(int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLong
    void SCIPselectLong(SCIP_Longint *longarray, int k, int len)
    SCIPselectRealRealPtr
    void SCIPselectRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int k, int len)
    SCIPselectDownPtrPtrLongIntInt
    void SCIPselectDownPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownRealPtrPtrIntInt
    void SCIPselectDownRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
    SCIPselectPtrReal
    void SCIPselectPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownLong
    void SCIPselectWeightedDownLong(SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealRealRealPtr
    void SCIPselectWeightedDownRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtrRealRealInt
    void SCIPselectWeightedPtrRealRealInt(void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtrRealBool
    void SCIPselectLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int k, int len)
    SCIPselectWeightedIntPtrIntIntBoolBool
    void SCIPselectWeightedIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntPtrIntIntBoolBool
    void SCIPselectDownIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int k, int len)
    SCIPselectWeightedDownPtrPtrRealBool
    void SCIPselectWeightedDownPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownPtrPtrIntInt
    void SCIPselectWeightedDownPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrIntInt
    void SCIPselectDownPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedPtrPtrLongIntInt
    void SCIPselectWeightedPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownIntPtrIntReal
    void SCIPselectWeightedDownIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealIntPtr
    void SCIPselectWeightedRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealRealRealBoolPtr
    void SCIPselectDownRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int k, int len)
    SCIPselectPtrRealIntInt
    void SCIPselectPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownPtrRealBool
    void SCIPselectDownPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedIntIntInt
    void SCIPselectWeightedIntIntInt(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownRealIntInt
    void SCIPselectWeightedDownRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntIntLong
    void SCIPselectDownIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int k, int len)
    SCIPselectIntPtrIntReal
    void SCIPselectIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedDownRealPtr
    void SCIPselectWeightedDownRealPtr(SCIP_Real *realarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownPtrPtrReal
    void SCIPselectDownPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownPtrPtrLongInt
    void SCIPselectWeightedDownPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectInt
    void SCIPselectInt(int *intarray, int k, int len)
    SCIPselectDownPtrPtrLongInt
    void SCIPselectDownPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectIntIntReal
    void SCIPselectIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int k, int len)
    SCIPselectWeightedLongPtrRealRealBool
    void SCIPselectWeightedLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealPtrPtrIntInt
    void SCIPselectRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
    SCIPselectDownRealPtrPtrInt
    void SCIPselectDownRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
    SCIPselectRealRealIntInt
    void SCIPselectRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int k, int len)
    SCIPselectDownRealIntLong
    void SCIPselectDownRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int k, int len)
    SCIPselectDownPtrRealInt
    void SCIPselectDownPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownPtrPtr
    void SCIPselectWeightedDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntIntPtr
    void SCIPselectIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int k, int len)
    SCIPselectWeightedPtrPtr
    void SCIPselectWeightedPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealIntInt
    void SCIPselectRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, int k, int len)
    SCIPselectWeightedDownRealRealIntInt
    void SCIPselectWeightedDownRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedDownInt
    void SCIPselectWeightedDownInt(int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedIntPtrIntReal
    void SCIPselectWeightedIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtrInt
    void SCIPselectLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, int k, int len)
    SCIPselectPtrIntInt
    void SCIPselectPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedLongPtrPtrInt
    void SCIPselectWeightedLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealRealRealBoolBoolPtr
    void SCIPselectWeightedRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedPtr
    void SCIPselectWeightedPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrRealRealIntBool
    void SCIPselectPtrRealRealIntBool(void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownLongPtrPtrInt
    void SCIPselectDownLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
    SCIPselectRealRealRealBoolBoolPtr
    void SCIPselectRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int k, int len)
    SCIPselectPtrPtrRealInt
    void SCIPselectPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectRealLongRealInt
    void SCIPselectRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int k, int len)
    SCIPselectIntIntIntPtr
    void SCIPselectIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int k, int len)
    SCIPselectDownInd
    void SCIPselectDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int k, int len)
    SCIPselectWeightedDownPtrRealIntInt
    void SCIPselectWeightedDownPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtrPtrIntInt
    void SCIPselectLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int k, int len)
    SCIPselectWeightedIntIntPtr
    void SCIPselectWeightedIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedReal
    void SCIPselectWeightedReal(SCIP_Real *realarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtrPtrInt
    void SCIPselectLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
    SCIPselectWeightedPtrRealRealIntBool
    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)
    SCIPselectPtrPtrReal
    void SCIPselectPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectDownRealPtr
    void SCIPselectDownRealPtr(SCIP_Real *realarray, void **ptrarray, int k, int len)
    SCIPselectWeightedIntIntPtrPtr
    void SCIPselectWeightedIntIntPtrPtr(int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownRealRealRealBoolBoolPtr
    void SCIPselectDownRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int k, int len)
    SCIPselectIntIntPtrPtrInterval
    void SCIPselectIntIntPtrPtrInterval(int *intarray1, int *intarray2, void **ptrarray1, void **ptrarray2, SCIP_INTERVAL *intervalarray, int k, int len)
    SCIPselectDownIntIntIntPtr
    void SCIPselectDownIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int k, int len)
    SCIPselectWeightedRealIntLong
    void SCIPselectWeightedRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectLongPtr
    void SCIPselectLongPtr(SCIP_Longint *longarray, void **ptrarray, int k, int len)
    SCIPselectLongPtrRealRealBool
    void SCIPselectLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int k, int len)
    SCIPselectWeightedLongPtrPtrIntInt
    void SCIPselectWeightedLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealRealRealBoolPtr
    void SCIPselectWeightedRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectWeightedRealRealRealInt
    void SCIPselectWeightedRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrPtrLongIntInt
    void SCIPselectPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedDownPtrPtrInt
    void SCIPselectWeightedDownPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrPtrLongInt
    void SCIPselectPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedIntIntIntPtr
    void SCIPselectWeightedIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectIntPtrIntIntBoolBool
    void SCIPselectIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int k, int len)
    SCIPselectWeightedPtrPtrRealInt
    void SCIPselectWeightedPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectPtrRealInt
    void SCIPselectPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int k, int len)
    SCIPselectWeightedPtrIntIntBoolBool
    void SCIPselectWeightedPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectDownIntIntInt
    void SCIPselectDownIntIntInt(int *intarray1, int *intarray2, int *intarray3, int k, int len)
    SCIPselectWeightedDownLongPtrRealRealIntBool
    void SCIPselectWeightedDownLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)
    SCIPselectRealPtrPtrInt
    void SCIPselectRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int k, int len)
    SCIPselectDownRealPtrPtr
    void SCIPselectDownRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int k, int len)
    intervalarith.h
    interval arithmetics for provable bounds
    SCIP_Interval
    Definition: intervalarith.h:55
    type_misc.h
    type definitions for miscellaneous datastructures
    SCIP_DECL_SORTPTRCOMP
    #define SCIP_DECL_SORTPTRCOMP(x)
    Definition: type_misc.h:189
    SCIP_DECL_SORTINDCOMP
    #define SCIP_DECL_SORTINDCOMP(x)
    Definition: type_misc.h:181