Scippy

SCIP

Solving Constraint Integer Programs

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