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