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