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