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