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