Scippy

SCIP

Solving Constraint Integer Programs

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