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