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