Scippy

SCIP

Solving Constraint Integer Programs

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