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
3584