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