1    	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2    	/*                                                                           */
3    	/*                  This file is part of the program and library             */
4    	/*         SCIP --- Solving Constraint Integer Programs                      */
5    	/*                                                                           */
6    	/*  Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB)                      */
7    	/*                                                                           */
8    	/*  Licensed under the Apache License, Version 2.0 (the "License");          */
9    	/*  you may not use this file except in compliance with the License.         */
10   	/*  You may obtain a copy of the License at                                  */
11   	/*                                                                           */
12   	/*      http://www.apache.org/licenses/LICENSE-2.0                           */
13   	/*                                                                           */
14   	/*  Unless required by applicable law or agreed to in writing, software      */
15   	/*  distributed under the License is distributed on an "AS IS" BASIS,        */
16   	/*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17   	/*  See the License for the specific language governing permissions and      */
18   	/*  limitations under the License.                                           */
19   	/*                                                                           */
20   	/*  You should have received a copy of the Apache-2.0 license                */
21   	/*  along with SCIP; see the file LICENSE. If not visit scipopt.org.         */
22   	/*                                                                           */
23   	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24   	
25   	/**@file   pub_misc_sort.h
26   	 * @ingroup PUBLICCOREAPI
27   	 * @brief  methods for sorting joint arrays of various types
28   	 * @author Gregor Hendel
29   	 *
30   	 * This file contains methods for sorting joint arrays of various types.
31   	 */
32   	
33   	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34   	
35   	#ifndef __SCIP_PUB_MISC_SORT_H__
36   	#define __SCIP_PUB_MISC_SORT_H__
37   	
38   	#include "scip/def.h"
39   	#include "type_misc.h"
40   	
41   	#ifdef __cplusplus
42   	extern "C" {
43   	#endif
44   	
45   	/*
46   	 * Sorting algorithms
47   	 */
48   	
49   	/**@defgroup SortingAlgorithms Sorting Algorithms
50   	 * @ingroup MiscellaneousMethods
51   	 * @brief public methods for in place sorting of arrays
52   	 *
53   	 * Below are the public methods for in place sorting of up to six arrays of joint data.
54   	 *
55   	 * @{
56   	 */
57   	
58   	/** default comparer for integers */
59   	SCIP_EXPORT
60   	SCIP_DECL_SORTPTRCOMP(SCIPsortCompInt);
61   	
62   	
63   	/** implements argsort
64   	 *
65   	 * The data pointer is a lookup array of integers.
66   	 */
67   	SCIP_EXPORT
68   	SCIP_DECL_SORTINDCOMP(SCIPsortArgsortInt);
69   	
70   	/** implements argsort
71   	 *
72   	 * The data pointer is a lookup array, which are pointer arrays.
73   	 */
74   	SCIP_EXPORT
75   	SCIP_DECL_SORTINDCOMP(SCIPsortArgsortPtr);
76   	
77   	/* first all upwards-sorting methods */
78   	
79   	/** sort an indexed element set in non-decreasing order, resulting in a permutation index array */
80   	SCIP_EXPORT
81   	void SCIPsort(
82   	   int*                  perm,               /**< pointer to store the resulting permutation */
83   	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
84   	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
85   	   int                   len                 /**< number of elements to be sorted (valid index range) */
86   	   );
87   	
88   	/** sort an index array in non-decreasing order */
89   	SCIP_EXPORT
90   	void SCIPsortInd(
91   	   int*                  indarray,           /**< pointer to the index array to be sorted */
92   	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
93   	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
94   	   int                   len                 /**< length of array */
95   	   );
96   	
97   	/** sort of an array of pointers in non-decreasing order */
98   	SCIP_EXPORT
99   	void SCIPsortPtr(
100  	   void**                ptrarray,           /**< pointer array to be sorted */
101  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
102  	   int                   len                 /**< length of array */
103  	   );
104  	
105  	/** sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
106  	SCIP_EXPORT
107  	void SCIPsortPtrPtr(
108  	   void**                ptrarray1,          /**< first pointer array to be sorted */
109  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
110  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
111  	   int                   len                 /**< length of arrays */
112  	   );
113  	
114  	/** sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
115  	SCIP_EXPORT
116  	void SCIPsortPtrReal(
117  	   void**                ptrarray,           /**< pointer array to be sorted */
118  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
119  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
120  	   int                   len                 /**< length of arrays */
121  	   );
122  	
123  	/** sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
124  	SCIP_EXPORT
125  	void SCIPsortPtrInt(
126  	   void**                ptrarray,           /**< pointer array to be sorted */
127  	   int*                  intarray,           /**< int array to be permuted in the same way */
128  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
129  	   int                   len                 /**< length of arrays */
130  	   );
131  	
132  	/** sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
133  	SCIP_EXPORT
134  	void SCIPsortPtrBool(
135  	   void**                ptrarray,           /**< pointer array to be sorted */
136  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
137  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
138  	   int                   len                 /**< length of arrays */
139  	   );
140  	
141  	
142  	/** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
143  	SCIP_EXPORT
144  	void SCIPsortPtrIntInt(
145  	   void**                ptrarray,           /**< pointer array to be sorted */
146  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
147  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
148  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
149  	   int                   len                 /**< length of arrays */
150  	   );
151  	
152  	/** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
153  	SCIP_EXPORT
154  	void SCIPsortPtrRealInt(
155  	   void**                ptrarray,           /**< pointer array to be sorted */
156  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
157  	   int*                  intarray,           /**< int array to be permuted in the same way */
158  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
159  	   int                   len                 /**< length of arrays */
160  	   );
161  	
162  	/** sort of four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order */
163  	SCIP_EXPORT
164  	void SCIPsortPtrRealRealInt(
165  	   void**                ptrarray,           /**< pointer array to be sorted */
166  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be permuted in the same way */
167  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
168  	   int*                  intarray,           /**< int array to be permuted in the same way */
169  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
170  	   int                   len                 /**< length of arrays */
171  	   );
172  	
173  	/** sort of four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order */
174  	SCIP_EXPORT
175  	void SCIPsortPtrRealRealBoolBool(
176  	   void**                ptrarray,           /**< pointer array to be sorted */
177  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be permuted in the same way */
178  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
179  	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array to be permuted in the same way */
180  	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array to be permuted in the same way */
181  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
182  	   int                   len                 /**< length of arrays */
183  	   );
184  	
185  	/** sort of four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order */
186  	SCIP_EXPORT
187  	void SCIPsortPtrRealRealIntBool(
188  	   void**                ptrarray,           /**< pointer array to be sorted */
189  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be permuted in the same way */
190  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
191  	   int*                  intarray,           /**< int array to be permuted in the same way */
192  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
193  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
194  	   int                   len                 /**< length of arrays */
195  	   );
196  	
197  	/** sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order */
198  	SCIP_EXPORT
199  	void SCIPsortPtrRealBool(
200  	   void**                ptrarray,           /**< pointer array to be sorted */
201  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
202  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
203  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
204  	   int                   len                 /**< length of arrays */
205  	   );
206  	
207  	/** sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order */
208  	SCIP_EXPORT
209  	void SCIPsortPtrRealReal(
210  	   void**                ptrarray,           /**< pointer array to be sorted */
211  	   SCIP_Real*            realarray1,         /**< first SCIP_Real array to be permuted in the same way */
212  	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
213  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
214  	   int                   len                 /**< length of arrays */
215  	   );
216  	
217  	/** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order */
218  	SCIP_EXPORT
219  	void SCIPsortPtrPtrInt(
220  	   void**                ptrarray1,          /**< first pointer array to be sorted */
221  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
222  	   int*                  intarray,           /**< int array to be permuted in the same way */
223  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
224  	   int                   len                 /**< length of arrays */
225  	   );
226  	
227  	/** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
228  	SCIP_EXPORT
229  	void SCIPsortPtrPtrReal(
230  	   void**                ptrarray1,          /**< first pointer array to be sorted */
231  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
232  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
233  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
234  	   int                   len                 /**< length of arrays */
235  	   );
236  	
237  	/** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
238  	SCIP_EXPORT
239  	void SCIPsortPtrPtrIntInt(
240  	   void**                ptrarray1,          /**< first pointer array to be sorted */
241  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
242  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
243  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
244  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
245  	   int                   len                 /**< length of arrays */
246  	   );
247  	
248  	/** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
249  	SCIP_EXPORT
250  	void SCIPsortPtrRealIntInt(
251  	   void**                ptrarray,           /**< pointer array to be sorted */
252  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
253  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
254  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
255  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
256  	   int                   len                 /**< length of arrays */
257  	   );
258  	
259  	/** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
260  	SCIP_EXPORT
261  	void SCIPsortPtrPtrRealInt(
262  	   void**                ptrarray1,          /**< first pointer array to be sorted */
263  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
264  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
265  	   int*                  intarray,           /**< int array to be permuted in the same way */
266  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
267  	   int                   len                 /**< length of arrays */
268  	   );
269  	
270  	/** sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order */
271  	SCIP_EXPORT
272  	void SCIPsortPtrPtrRealBool(
273  	   void**                ptrarray1,          /**< first pointer array to be sorted */
274  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
275  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
276  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
277  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
278  	   int                   len                 /**< length of arrays */
279  	   );
280  	
281  	/** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
282  	SCIP_EXPORT
283  	void SCIPsortPtrPtrLongInt(
284  	   void**                ptrarray1,          /**< first pointer array to be sorted */
285  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
286  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
287  	   int*                  intarray,           /**< int array to be permuted in the same way */
288  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
289  	   int                   len                 /**< length of arrays */
290  	   );
291  	
292  	/** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
293  	SCIP_EXPORT
294  	void SCIPsortPtrPtrLongIntInt(
295  	   void**                ptrarray1,          /**< first pointer array to be sorted */
296  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
297  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
298  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
299  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
300  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
301  	   int                   len                 /**< length of arrays */
302  	   );
303  	
304  	/** sort an array of Reals in non-decreasing order */
305  	SCIP_EXPORT
306  	void SCIPsortReal(
307  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
308  	   int                   len                 /**< length of arrays */
309  	   );
310  	
311  	/** sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
312  	SCIP_EXPORT
313  	void SCIPsortRealPtr(
314  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
315  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
316  	   int                   len                 /**< length of arrays */
317  	   );
318  	
319  	/** sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
320  	SCIP_EXPORT
321  	void SCIPsortRealInt(
322  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
323  	   int*                  intarray,           /**< int array to be permuted in the same way */
324  	   int                   len                 /**< length of arrays */
325  	   );
326  	
327  	/** sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order */
328  	SCIP_EXPORT
329  	void SCIPsortRealIntInt(
330  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
331  	   int*                  intarray1,          /**< int array to be permuted in the same way */
332  	   int*                  intarray2,          /**< int array to be permuted in the same way */
333  	   int                   len                 /**< length of arrays */
334  	   );
335  	
336  	/** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order */
337  	SCIP_EXPORT
338  	void SCIPsortRealBoolPtr(
339  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
340  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
341  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
342  	   int                   len                 /**< length of arrays */
343  	   );
344  	
345  	/** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
346  	SCIP_EXPORT
347  	void SCIPsortRealIntLong(
348  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
349  	   int*                  intarray,           /**< int array to be permuted in the same way */
350  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
351  	   int                   len                 /**< length of arrays */
352  	   );
353  	
354  	/** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
355  	SCIP_EXPORT
356  	void SCIPsortRealIntPtr(
357  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
358  	   int*                  intarray,           /**< int array to be permuted in the same way */
359  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
360  	   int                   len                 /**< length of arrays */
361  	   );
362  	
363  	/** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
364  	SCIP_EXPORT
365  	void SCIPsortRealRealPtr(
366  	   SCIP_Real*            realarray1,         /**< first SCIP_Real array to be sorted */
367  	   SCIP_Real*            realarray2,         /**< second  SCIP_Real array to be permuted in the same way */
368  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
369  	   int                   len                 /**< length of arrays */
370  	   );
371  	
372  	/** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
373  	SCIP_EXPORT
374  	void SCIPsortRealPtrPtrInt(
375  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
376  	   void**                ptrarray1,          /**< pointer array to be permuted in the same way */
377  	   void**                ptrarray2,          /**< pointer array to be permuted in the same way */
378  	   int*                  intarray,           /**< int array to be sorted */
379  	   int                   len                 /**< length of arrays */
380  	   );
381  	
382  	/** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
383  	SCIP_EXPORT
384  	void SCIPsortRealPtrPtrIntInt(
385  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
386  	   void**                ptrarray1,          /**< pointer array to be permuted in the same way */
387  	   void**                ptrarray2,          /**< pointer array to be permuted in the same way */
388  	   int*                  intarray1,          /**< int array to be sorted */
389  	   int*                  intarray2,          /**< int array to be sorted */
390  	   int                   len                 /**< length of arrays */
391  	   );
392  	
393  	/** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order */
394  	SCIP_EXPORT
395  	void SCIPsortRealLongRealInt(
396  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
397  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
398  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
399  	   int*                  intarray,           /**< int array  to be permuted in the same way */
400  	   int                   len                 /**< length of arrays */
401  	   );
402  	
403  	/** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
404  	SCIP_EXPORT
405  	void SCIPsortRealRealIntInt(
406  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
407  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
408  	   int*                  intarray1,          /**< int array to be permuted in the same way */
409  	   int*                  intarray2,          /**< int array to be permuted in the same way */
410  	   int                   len                 /**< length of arrays */
411  	   );
412  	
413  	/** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
414  	SCIP_EXPORT
415  	void SCIPsortRealRealRealInt(
416  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
417  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
418  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
419  	   int*                  intarray,           /**< int array to be permuted in the same way */
420  	   int                   len                 /**< length of arrays */
421  	   );
422  	
423  	/** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
424  	SCIP_EXPORT
425  	void SCIPsortRealRealRealPtr(
426  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
427  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
428  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
429  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
430  	   int                   len                 /**< length of arrays */
431  	   );
432  	
433  	/** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
434  	SCIP_EXPORT
435  	void SCIPsortRealRealRealBoolPtr(
436  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
437  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
438  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
439  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
440  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
441  	   int                   len                 /**< length of arrays */
442  	   );
443  	
444  	/** sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order */
445  	SCIP_EXPORT
446  	void SCIPsortRealRealRealBoolBoolPtr(
447  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
448  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
449  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
450  	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array to be permuted in the same way */
451  	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array to be permuted in the same way */
452  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
453  	   int                   len                 /**< length of arrays */
454  	   );
455  	
456  	/** sort array of ints in non-decreasing order */
457  	SCIP_EXPORT
458  	void SCIPsortInt(
459  	   int*                  intarray,           /**< int array to be sorted */
460  	   int                   len                 /**< length of arrays */
461  	   );
462  	
463  	/** sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order */
464  	SCIP_EXPORT
465  	void SCIPsortIntInt(
466  	   int*                  intarray1,          /**< int array to be sorted */
467  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
468  	   int                   len                 /**< length of arrays */
469  	   );
470  	
471  	/** sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
472  	SCIP_EXPORT
473  	void SCIPsortIntPtr(
474  	   int*                  intarray,           /**< int array to be sorted */
475  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
476  	   int                   len                 /**< length of arrays */
477  	   );
478  	
479  	/** sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order */
480  	SCIP_EXPORT
481  	void SCIPsortIntReal(
482  	   int*                  intarray,           /**< int array to be sorted */
483  	   SCIP_Real*            realarray,          /**< real array to be permuted in the same way */
484  	   int                   len                 /**< length of arrays */
485  	   );
486  	
487  	/** sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
488  	SCIP_EXPORT
489  	void SCIPsortIntIntInt(
490  	   int*                  intarray1,          /**< int array to be sorted */
491  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
492  	   int*                  intarray3,          /**< third int array to be permuted in the same way */
493  	   int                   len                 /**< length of arrays */
494  	   );
495  	
496  	/** sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order */
497  	SCIP_EXPORT
498  	void SCIPsortIntIntLong(
499  	   int*                  intarray1,          /**< int array to be sorted */
500  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
501  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
502  	   int                   len                 /**< length of arrays */
503  	   );
504  	
505  	/** sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order */
506  	SCIP_EXPORT
507  	void SCIPsortIntRealLong(
508  	   int*                  intarray,           /**< int array to be sorted */
509  	   SCIP_Real*            realarray,          /**< real array to be permuted in the same way */
510  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
511  	   int                   len                 /**< length of arrays */
512  	   );
513  	
514  	/** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
515  	SCIP_EXPORT
516  	void SCIPsortIntIntPtr(
517  	   int*                  intarray1,          /**< int array to be sorted */
518  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
519  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
520  	   int                   len                 /**< length of arrays */
521  	   );
522  	
523  	/** sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order */
524  	SCIP_EXPORT
525  	void SCIPsortIntIntReal(
526  	   int*                  intarray1,          /**< int array to be sorted */
527  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
528  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
529  	   int                   len                 /**< length of arrays */
530  	   );
531  	
532  	/** sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order */
533  	SCIP_EXPORT
534  	void SCIPsortIntPtrReal(
535  	   int*                  intarray,           /**< int array to be sorted */
536  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
537  	   SCIP_Real*            realarray,          /**< real array to be permuted in the same way */
538  	   int                   len                 /**< length of arrays */
539  	   );
540  	
541  	/** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
542  	SCIP_EXPORT
543  	void SCIPsortIntIntIntPtr(
544  	   int*                  intarray1,          /**< int array to be sorted */
545  	   int*                  intarray2,          /**< int array to be permuted in the same way */
546  	   int*                  intarray3,          /**< int array to be permuted in the same way */
547  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
548  	   int                   len                 /**< length of arrays */
549  	   );
550  	
551  	/** sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
552  	SCIP_EXPORT
553  	void SCIPsortIntIntIntReal(
554  	   int*                  intarray1,          /**< int array to be sorted */
555  	   int*                  intarray2,          /**< int array to be permuted in the same way */
556  	   int*                  intarray3,          /**< int array to be permuted in the same way */
557  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
558  	   int                   len                 /**< length of arrays */
559  	   );
560  	
561  	/** sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order */
562  	SCIP_EXPORT
563  	void SCIPsortIntPtrIntReal(
564  	   int*                  intarray1,          /**< int array to be sorted */
565  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
566  	   int*                  intarray2,          /**< int array to be permuted in the same way */
567  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
568  	   int                   len                 /**< length of arrays */
569  	   );
570  	
571  	/** sort an array of Longints in non-decreasing order */
572  	SCIP_EXPORT
573  	void SCIPsortLong(
574  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
575  	   int                   len                 /**< length of arrays */
576  	   );
577  	
578  	/** sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
579  	SCIP_EXPORT
580  	void SCIPsortLongPtr(
581  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
582  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
583  	   int                   len                 /**< length of arrays */
584  	   );
585  	
586  	/** sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
587  	SCIP_EXPORT
588  	void SCIPsortLongPtrInt(
589  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
590  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
591  	   int*                  intarray,           /**< int array to be permuted in the same way */
592  	   int                   len                 /**< length of arrays */
593  	   );
594  	
595  	/** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
596  	SCIP_EXPORT
597  	void SCIPsortLongPtrRealBool(
598  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
599  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
600  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
601  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
602  	   int                   len                 /**< length of arrays */
603  	   );
604  	
605  	/** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
606  	SCIP_EXPORT
607  	void SCIPsortLongPtrRealRealBool(
608  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
609  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
610  	   SCIP_Real*            realarray,          /**< first SCIP_Real array to be permuted in the same way */
611  	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
612  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
613  	   int                   len                 /**< length of arrays */
614  	   );
615  	
616  	/** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
617  	SCIP_EXPORT
618  	void SCIPsortLongPtrRealRealIntBool(
619  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
620  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
621  	   SCIP_Real*            realarray,          /**< first SCIP_Real array to be permuted in the same way */
622  	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
623  	   int*                  intarray,           /**< int array to be permuted in the same way */
624  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
625  	   int                   len                 /**< length of arrays */
626  	   );
627  	
628  	/** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
629  	SCIP_EXPORT
630  	void SCIPsortLongPtrPtrInt(
631  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
632  	   void**                ptrarray1,          /**< first pointer array to be permuted in the same way */
633  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
634  	   int*                  intarray,           /**< int array to be permuted in the same way */
635  	   int                   len                 /**< length of arrays */
636  	   );
637  	
638  	/** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
639  	SCIP_EXPORT
640  	void SCIPsortLongPtrPtrIntInt(
641  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
642  	   void**                ptrarray1,          /**< first pointer array to be permuted in the same way */
643  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
644  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
645  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
646  	   int                   len                 /**< length of arrays */
647  	   );
648  	
649  	/** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
650  	SCIP_EXPORT
651  	void SCIPsortLongPtrPtrBoolInt(
652  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
653  	   void**                ptrarray1,          /**< first pointer array to be permuted in the same way */
654  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
655  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
656  	   int*                  intarray,           /**< int array to be sorted */
657  	   int                   len                 /**< length of arrays */
658  	   );
659  	
660  	/** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
661  	SCIP_EXPORT
662  	void SCIPsortPtrIntIntBoolBool(
663  	   void**                ptrarray,           /**< pointer array to be sorted */
664  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
665  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
666  	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
667  	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
668  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
669  	   int                   len                 /**< length of arrays */
670  	   );
671  	
672  	/** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
673  	SCIP_EXPORT
674  	void SCIPsortIntPtrIntIntBoolBool(
675  	   int*                  intarray1,          /**< int array to be sorted */
676  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
677  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
678  	   int*                  intarray3,          /**< thrid int array to be permuted in the same way */
679  	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
680  	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
681  	   int                   len                 /**< length of arrays */
682  	   );
683  	
684  	/* now all downwards-sorting methods */
685  	
686  	/** sort an indexed element set in non-increasing order, resulting in a permutation index array */
687  	SCIP_EXPORT
688  	void SCIPsortDown(
689  	   int*                  perm,               /**< pointer to store the resulting permutation */
690  	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
691  	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
692  	   int                   len                 /**< number of elements to be sorted (valid index range) */
693  	   );
694  	
695  	/** sort an index array in non-increasing order */
696  	SCIP_EXPORT
697  	void SCIPsortDownInd(
698  	   int*                  indarray,           /**< pointer to the index array to be sorted */
699  	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
700  	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
701  	   int                   len                 /**< length of array */
702  	   );
703  	
704  	/** sort of an array of pointers in non-increasing order */
705  	SCIP_EXPORT
706  	void SCIPsortDownPtr(
707  	   void**                ptrarray,           /**< pointer array to be sorted */
708  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
709  	   int                   len                 /**< length of array */
710  	   );
711  	
712  	/** sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
713  	SCIP_EXPORT
714  	void SCIPsortDownPtrPtr(
715  	   void**                ptrarray1,          /**< first pointer array to be sorted */
716  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
717  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
718  	   int                   len                 /**< length of arrays */
719  	   );
720  	
721  	/** sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
722  	SCIP_EXPORT
723  	void SCIPsortDownPtrReal(
724  	   void**                ptrarray,           /**< pointer array to be sorted */
725  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
726  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
727  	   int                   len                 /**< length of arrays */
728  	   );
729  	
730  	/** sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order */
731  	SCIP_EXPORT
732  	void SCIPsortDownPtrInt(
733  	   void**                ptrarray,           /**< pointer array to be sorted */
734  	   int*                  intarray,           /**< int array to be permuted in the same way */
735  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
736  	   int                   len                 /**< length of arrays */
737  	   );
738  	
739  	/** sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
740  	SCIP_EXPORT
741  	void SCIPsortDownPtrBool(
742  	   void**                ptrarray,           /**< pointer array to be sorted */
743  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
744  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
745  	   int                   len                 /**< length of arrays */
746  	   );
747  	
748  	/** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
749  	SCIP_EXPORT
750  	void SCIPsortDownPtrIntInt(
751  	   void**                ptrarray,           /**< pointer array to be sorted */
752  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
753  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
754  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
755  	   int                   len                 /**< length of arrays */
756  	   );
757  	
758  	/** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
759  	SCIP_EXPORT
760  	void SCIPsortDownPtrRealInt(
761  	   void**                ptrarray,           /**< pointer array to be sorted */
762  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
763  	   int*                  intarray,           /**< int array to be permuted in the same way */
764  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
765  	   int                   len                 /**< length of arrays */
766  	   );
767  	
768  	/** sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order */
769  	SCIP_EXPORT
770  	void SCIPsortDownPtrRealBool(
771  	   void**                ptrarray,           /**< pointer array to be sorted */
772  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
773  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
774  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
775  	   int                   len                 /**< length of arrays */
776  	   );
777  	
778  	/** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order */
779  	SCIP_EXPORT
780  	void SCIPsortDownPtrPtrInt(
781  	   void**                ptrarray1,          /**< first pointer array to be sorted */
782  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
783  	   int*                  intarray,           /**< int array to be permuted in the same way */
784  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
785  	   int                   len                 /**< length of arrays */
786  	   );
787  	
788  	/** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
789  	SCIP_EXPORT
790  	void SCIPsortDownPtrPtrReal(
791  	   void**                ptrarray1,          /**< first pointer array to be sorted */
792  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
793  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
794  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
795  	   int                   len                 /**< length of arrays */
796  	   );
797  	
798  	/** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
799  	SCIP_EXPORT
800  	void SCIPsortDownPtrPtrIntInt(
801  	   void**                ptrarray1,          /**< first pointer array to be sorted */
802  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
803  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
804  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
805  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
806  	   int                   len                 /**< length of arrays */
807  	   );
808  	
809  	/** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
810  	SCIP_EXPORT
811  	void SCIPsortDownPtrRealIntInt(
812  	   void**                ptrarray,           /**< pointer array to be sorted */
813  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
814  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
815  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
816  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
817  	   int                   len                 /**< length of arrays */
818  	   );
819  	
820  	/** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
821  	SCIP_EXPORT
822  	void SCIPsortDownPtrPtrRealInt(
823  	   void**                ptrarray1,          /**< first pointer array to be sorted */
824  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
825  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
826  	   int*                  intarray,           /**< int array to be permuted in the same way */
827  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
828  	   int                   len                 /**< length of arrays */
829  	   );
830  	
831  	/** sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order */
832  	SCIP_EXPORT
833  	void SCIPsortDownPtrPtrRealBool(
834  	   void**                ptrarray1,          /**< first pointer array to be sorted */
835  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
836  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
837  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
838  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
839  	   int                   len                 /**< length of arrays */
840  	   );
841  	
842  	/** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
843  	SCIP_EXPORT
844  	void SCIPsortDownPtrPtrLongInt(
845  	   void**                ptrarray1,          /**< first pointer array to be sorted */
846  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
847  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
848  	   int*                  intarray,           /**< int array to be permuted in the same way */
849  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
850  	   int                   len                 /**< length of arrays */
851  	   );
852  	
853  	/** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
854  	SCIP_EXPORT
855  	void SCIPsortDownPtrPtrLongIntInt(
856  	   void**                ptrarray1,          /**< first pointer array to be sorted */
857  	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
858  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
859  	   int*                  intarray1,          /**< first int array to be permuted in the same way */
860  	   int*                  intarray2,          /**< second int array to be permuted in the same way */
861  	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
862  	   int                   len                 /**< length of arrays */
863  	   );
864  	
865  	/** sort an array of Reals in non-increasing order */
866  	SCIP_EXPORT
867  	void SCIPsortDownReal(
868  	   SCIP_Real*            realarray,          /**< SCIP_Real  array to be sorted */
869  	   int                   len                 /**< length of arrays */
870  	   );
871  	
872  	/** sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
873  	SCIP_EXPORT
874  	void SCIPsortDownRealPtr(
875  	   SCIP_Real*            realarray,          /**< SCIP_Real  array to be sorted */
876  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
877  	   int                   len                 /**< length of arrays */
878  	   );
879  	
880  	/** sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order */
881  	SCIP_EXPORT
882  	void SCIPsortDownRealInt(
883  	   SCIP_Real*            realarray,          /**< SCIP_Real  array to be sorted */
884  	   int*                  intarray,           /**< pointer array to be permuted in the same way */
885  	   int                   len                 /**< length of arrays */
886  	   );
887  	
888  	/** sort of three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order */
889  	SCIP_EXPORT
890  	void SCIPsortDownRealIntInt(
891  	   SCIP_Real*            realarray,          /**< SCIP_Real  array to be sorted */
892  	   int*                  intarray1,          /**< int array to be sorted */
893  	   int*                  intarray2,          /**< int array to be sorted */
894  	   int                   len                 /**< length of arrays */
895  	   );
896  	
897  	/** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order */
898  	SCIP_EXPORT
899  	void SCIPsortDownRealBoolPtr(
900  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
901  	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
902  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
903  	   int                   len                 /**< length of arrays */
904  	   );
905  	
906  	/** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
907  	SCIP_EXPORT
908  	void SCIPsortDownRealIntLong(
909  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
910  	   int*                  intarray,           /**< int array to be permuted in the same way */
911  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
912  	   int                   len                 /**< length of arrays */
913  	   );
914  	
915  	/** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
916  	SCIP_EXPORT
917  	void SCIPsortDownRealIntPtr(
918  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
919  	   int*                  intarray,           /**< int array to be permuted in the same way */
920  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
921  	   int                   len                 /**< length of arrays */
922  	   );
923  	
924  	/** sort of three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order */
925  	SCIP_EXPORT
926  	void SCIPsortDownRealRealInt(
927  	   SCIP_Real*            realarray1,         /**< first SCIP_Real array to be sorted */
928  	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
929  	   int*                  intarray,           /**< integer array to be permuted in the same way */
930  	   int                   len                 /**< length of arrays */
931  	   );
932  	
933  	/** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
934  	SCIP_EXPORT
935  	void SCIPsortDownRealRealPtr(
936  	   SCIP_Real*            realarray1,         /**< first SCIP_Real array to be sorted */
937  	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
938  	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
939  	   int                   len                 /**< length of arrays */
940  	   );
941  	
942  	/** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
943  	SCIP_EXPORT
944  	void SCIPsortDownRealRealPtrPtr(
945  	   SCIP_Real*            realarray1,         /**< first SCIP_Real array to be sorted */
946  	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
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                   len                 /**< length of arrays */
950  	   );
951  	
952  	/** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
953  	SCIP_EXPORT
954  	void SCIPsortDownRealPtrPtrInt(
955  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
956  	   void**                ptrarray1,          /**< pointer array to be permuted in the same way */
957  	   void**                ptrarray2,          /**< pointer array to be permuted in the same way */
958  	   int*                  intarray,           /**< int array to be sorted */
959  	   int                   len                 /**< length of arrays */
960  	   );
961  	
962  	/** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
963  	SCIP_EXPORT
964  	void SCIPsortDownRealPtrPtrIntInt(
965  	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
966  	   void**                ptrarray1,          /**< pointer array to be permuted in the same way */
967  	   void**                ptrarray2,          /**< pointer array to be permuted in the same way */
968  	   int*                  intarray1,          /**< int array to be sorted */
969  	   int*                  intarray2,          /**< int array to be sorted */
970  	   int                   len                 /**< length of arrays */
971  	   );
972  	
973  	/** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
974  	SCIP_EXPORT
975  	void SCIPsortDownRealLongRealInt(
976  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
977  	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
978  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
979  	   int*                  intarray,           /**< int array  to be permuted in the same way */
980  	   int                   len                 /**< length of arrays */
981  	   );
982  	
983  	/** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
984  	SCIP_EXPORT
985  	void SCIPsortDownRealRealIntInt(
986  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
987  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
988  	   int*                  intarray1,          /**< int array to be permuted in the same way */
989  	   int*                  intarray2,          /**< int array to be permuted in the same way */
990  	   int                   len                 /**< length of arrays */
991  	   );
992  	
993  	
994  	/** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
995  	SCIP_EXPORT
996  	void SCIPsortDownRealRealRealInt(
997  	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
998  	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
999  	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
1000 	   int*                  intarray,           /**< int array to be permuted in the same way */
1001 	   int                   len                 /**< length of arrays */
1002 	   );
1003 	
1004 	/** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
1005 	SCIP_EXPORT
1006 	void SCIPsortDownRealRealRealPtr(
1007 	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
1008 	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
1009 	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
1010 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1011 	   int                   len                 /**< length of arrays */
1012 	   );
1013 	
1014 	/** sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
1015 	SCIP_EXPORT
1016 	void SCIPsortDownRealPtrPtr(
1017 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
1018 	   void**                ptrarray1,          /**< pointer array to be permuted in the same way */
1019 	   void**                ptrarray2,          /**< pointer array to be permuted in the same way */
1020 	   int                   len                 /**< length of arrays */
1021 	   );
1022 	
1023 	/** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
1024 	SCIP_EXPORT
1025 	void SCIPsortDownRealRealRealBoolPtr(
1026 	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
1027 	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
1028 	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
1029 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
1030 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1031 	   int                   len                 /**< length of arrays */
1032 	   );
1033 	
1034 	/** sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order */
1035 	SCIP_EXPORT
1036 	void SCIPsortDownRealRealRealBoolBoolPtr(
1037 	   SCIP_Real*            realarray1,         /**< SCIP_Real array to be sorted */
1038 	   SCIP_Real*            realarray2,         /**< SCIP_Real array to be permuted in the same way */
1039 	   SCIP_Real*            realarray3,         /**< SCIP_Real array to be permuted in the same way */
1040 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array to be permuted in the same way */
1041 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array to be permuted in the same way */
1042 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1043 	   int                   len                 /**< length of arrays */
1044 	   );
1045 	
1046 	/** sort array of ints in non-increasing order */
1047 	SCIP_EXPORT
1048 	void SCIPsortDownInt(
1049 	   int*                  intarray,           /**< int array to be sorted */
1050 	   int                   len                 /**< length of arrays */
1051 	   );
1052 	
1053 	/** sort of two joint arrays of ints/ints, sorted by first array in non-increasing order */
1054 	SCIP_EXPORT
1055 	void SCIPsortDownIntInt(
1056 	   int*                  intarray1,          /**< int array to be sorted */
1057 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1058 	   int                   len                 /**< length of arrays */
1059 	   );
1060 	
1061 	/** sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order */
1062 	SCIP_EXPORT
1063 	void SCIPsortDownIntPtr(
1064 	   int*                  intarray,           /**< int array to be sorted */
1065 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1066 	   int                   len                 /**< length of arrays */
1067 	   );
1068 	
1069 	/** sort of two joint arrays of ints/reals, sorted by first array in non-increasing order */
1070 	SCIP_EXPORT
1071 	void SCIPsortDownIntReal(
1072 	   int*                  intarray,           /**< int array to be sorted */
1073 	   SCIP_Real*            realarray,          /**< real array to be permuted in the same way */
1074 	   int                   len                 /**< length of arrays */
1075 	   );
1076 	
1077 	/** sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
1078 	SCIP_EXPORT
1079 	void SCIPsortDownIntIntInt(
1080 	   int*                  intarray1,          /**< int array to be sorted */
1081 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1082 	   int*                  intarray3,          /**< third int  array to be permuted in the same way */
1083 	   int                   len                 /**< length of arrays */
1084 	   );
1085 	
1086 	/** sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
1087 	SCIP_EXPORT
1088 	void SCIPsortDownIntIntLong(
1089 	   int*                  intarray1,          /**< int array to be sorted */
1090 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1091 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
1092 	   int                   len                 /**< length of arrays */
1093 	   );
1094 	
1095 	/** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
1096 	SCIP_EXPORT
1097 	void SCIPsortDownIntIntPtr(
1098 	   int*                  intarray1,          /**< int array to be sorted */
1099 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1100 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1101 	   int                   len                 /**< length of arrays */
1102 	   );
1103 	
1104 	/** sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
1105 	SCIP_EXPORT
1106 	void SCIPsortDownIntIntReal(
1107 	   int*                  intarray1,          /**< int array to be sorted */
1108 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1109 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
1110 	   int                   len                 /**< length of arrays */
1111 	   );
1112 	
1113 	/** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order */
1114 	SCIP_EXPORT
1115 	void SCIPsortDownIntIntIntPtr(
1116 	   int*                  intarray1,          /**< int array to be sorted */
1117 	   int*                  intarray2,          /**< int array to be permuted in the same way */
1118 	   int*                  intarray3,          /**< int array to be permuted in the same way */
1119 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1120 	   int                   len                 /**< length of arrays */
1121 	   );
1122 	
1123 	/** sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order */
1124 	SCIP_EXPORT
1125 	void SCIPsortDownIntIntIntReal(
1126 	   int*                  intarray1,          /**< int array to be sorted */
1127 	   int*                  intarray2,          /**< int array to be permuted in the same way */
1128 	   int*                  intarray3,          /**< int array to be permuted in the same way */
1129 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
1130 	   int                   len                 /**< length of arrays */
1131 	   );
1132 	
1133 	/** sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
1134 	SCIP_EXPORT
1135 	void SCIPsortDownIntPtrIntReal(
1136 	   int*                  intarray1,          /**< int array to be sorted */
1137 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1138 	   int*                  intarray2,          /**< int array to be permuted in the same way */
1139 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
1140 	   int                   len                 /**< length of arrays */
1141 	   );
1142 	
1143 	/** sort an array of Longints in non-increasing order */
1144 	SCIP_EXPORT
1145 	void SCIPsortDownLong(
1146 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1147 	   int                   len                 /**< length of arrays */
1148 	   );
1149 	
1150 	/** sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
1151 	SCIP_EXPORT
1152 	void SCIPsortDownLongPtr(
1153 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1154 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1155 	   int                   len                 /**< length of arrays */
1156 	   );
1157 	
1158 	/** sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
1159 	SCIP_EXPORT
1160 	void SCIPsortDownLongPtrInt(
1161 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1162 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1163 	   int*                  intarray,           /**< int array to be permuted in the same way */
1164 	   int                   len                 /**< length of arrays */
1165 	   );
1166 	
1167 	/** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
1168 	SCIP_EXPORT
1169 	void SCIPsortDownLongPtrRealBool(
1170 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1171 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1172 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be permuted in the same way */
1173 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
1174 	   int                   len                 /**< length of arrays */
1175 	   );
1176 	
1177 	/** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
1178 	SCIP_EXPORT
1179 	void SCIPsortDownLongPtrRealRealBool(
1180 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1181 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1182 	   SCIP_Real*            realarray,          /**< first SCIP_Real array to be permuted in the same way */
1183 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
1184 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
1185 	   int                   len                 /**< length of arrays */
1186 	   );
1187 	
1188 	/** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
1189 	SCIP_EXPORT
1190 	void SCIPsortDownLongPtrRealRealIntBool(
1191 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1192 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1193 	   SCIP_Real*            realarray,          /**< first SCIP_Real array to be permuted in the same way */
1194 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array to be permuted in the same way */
1195 	   int*                  intarray,           /**< int array to be permuted in the same way */
1196 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
1197 	   int                   len                 /**< length of arrays */
1198 	   );
1199 	
1200 	/** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
1201 	SCIP_EXPORT
1202 	void SCIPsortDownLongPtrPtrInt(
1203 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1204 	   void**                ptrarray1,          /**< first pointer array to be permuted in the same way */
1205 	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
1206 	   int*                  intarray,           /**< int array to be permuted in the same way */
1207 	   int                   len                 /**< length of arrays */
1208 	   );
1209 	
1210 	/** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
1211 	SCIP_EXPORT
1212 	void SCIPsortDownLongPtrPtrIntInt(
1213 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1214 	   void**                ptrarray1,          /**< first pointer array to be permuted in the same way */
1215 	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
1216 	   int*                  intarray1,          /**< first int array to be permuted in the same way */
1217 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1218 	   int                   len                 /**< length of arrays */
1219 	   );
1220 	
1221 	/** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
1222 	SCIP_EXPORT
1223 	void SCIPsortDownLongPtrPtrBoolInt(
1224 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be sorted */
1225 	   void**                ptrarray1,          /**< first pointer array to be permuted in the same way */
1226 	   void**                ptrarray2,          /**< second pointer array to be permuted in the same way */
1227 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
1228 	   int*                  intarray,           /**< int array to be sorted */
1229 	   int                   len                 /**< length of arrays */
1230 	   );
1231 	
1232 	/** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
1233 	SCIP_EXPORT
1234 	void SCIPsortDownPtrIntIntBoolBool(
1235 	   void**                ptrarray,           /**< pointer array to be sorted */
1236 	   int*                  intarray1,          /**< first int array to be permuted in the same way */
1237 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1238 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
1239 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
1240 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1241 	   int                   len                 /**< length of arrays */
1242 	   );
1243 	
1244 	/** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
1245 	SCIP_EXPORT
1246 	void SCIPsortDownIntPtrIntIntBoolBool(
1247 	   int*                  intarray1,          /**< int array to be sorted */
1248 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1249 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
1250 	   int*                  intarray3,          /**< thrid int array to be permuted in the same way */
1251 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
1252 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
1253 	   int                   len                 /**< length of arrays */
1254 	   );
1255 	
1256 	/*
1257 	 * Sorted vectors
1258 	 */
1259 	
1260 	/* upwards insertion */
1261 	
1262 	/** insert a new element into an index array in non-decreasing order */
1263 	SCIP_EXPORT
1264 	void SCIPsortedvecInsertInd(
1265 	   int*                  indarray,           /**< pointer to the index array where an element is to be inserted */
1266 	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
1267 	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
1268 	   int                   keyval,             /**< key value of new element */
1269 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1270 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1271 	   );
1272 	
1273 	/** insert a new element into an array of pointers in non-decreasing order */
1274 	SCIP_EXPORT
1275 	void SCIPsortedvecInsertPtr(
1276 	   void**                ptrarray,           /**< pointer to the pointer array where an element is to be inserted */
1277 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1278 	   void*                 keyval,             /**< key value of new element */
1279 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1280 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1281 	   );
1282 	
1283 	/** insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order */
1284 	SCIP_EXPORT
1285 	void SCIPsortedvecInsertPtrPtr(
1286 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1287 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1288 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1289 	   void*                 keyval,             /**< key value of new element */
1290 	   void*                 field1val,          /**< additional value of new element */
1291 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1292 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1293 	   );
1294 	
1295 	/** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
1296 	SCIP_EXPORT
1297 	void SCIPsortedvecInsertPtrReal(
1298 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1299 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1300 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1301 	   void*                 keyval,             /**< key value of new element */
1302 	   SCIP_Real             field1val,          /**< additional value of new element */
1303 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1304 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1305 	   );
1306 	
1307 	/** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
1308 	SCIP_EXPORT
1309 	void SCIPsortedvecInsertPtrInt(
1310 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1311 	   int*                  intarray,           /**< int array where an element is to be inserted */
1312 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1313 	   void*                 keyval,             /**< key value of new element */
1314 	   int                   field1val,          /**< additional value of new element */
1315 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1316 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1317 	   );
1318 	
1319 	/** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
1320 	SCIP_EXPORT
1321 	void SCIPsortedvecInsertPtrBool(
1322 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1323 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1324 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1325 	   void*                 keyval,             /**< key value of new element */
1326 	   SCIP_Bool             field1val,          /**< additional value of new element */
1327 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1328 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1329 	   );
1330 	
1331 	/** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
1332 	SCIP_EXPORT
1333 	void SCIPsortedvecInsertPtrIntInt(
1334 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1335 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1336 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1337 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1338 	   void*                 keyval,             /**< key value of new element */
1339 	   int                   field1val,          /**< additional value of new element */
1340 	   int                   field2val,          /**< additional value of new element */
1341 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1342 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1343 	   );
1344 	
1345 	/** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
1346 	SCIP_EXPORT
1347 	void SCIPsortedvecInsertPtrRealInt(
1348 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1349 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1350 	   int*                  intarray,           /**< int array where an element is to be inserted */
1351 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1352 	   void*                 keyval,             /**< key value of new element */
1353 	   SCIP_Real             field1val,          /**< additional value of new element */
1354 	   int                   field2val,          /**< additional value of new element */
1355 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1356 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1357 	   );
1358 	
1359 	/** insert a new element into four joint arrays of pointers/Reals/Reals/ints, sorted by first array in non-decreasing order */
1360 	SCIP_EXPORT
1361 	void SCIPsortedvecInsertPtrRealRealInt(
1362 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1363 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
1364 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
1365 	   int*                  intarray,           /**< int array where an element is to be inserted */
1366 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1367 	   void*                 keyval,             /**< key value of new element */
1368 	   SCIP_Real             field1val,          /**< additional value of new element */
1369 	   SCIP_Real             field2val,          /**< additional value of new element */
1370 	   int                   field3val,          /**< additional value of new element */
1371 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1372 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1373 	   );
1374 	
1375 	/** insert a new element into four joint arrays of pointers/Reals/Reals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order */
1376 	SCIP_EXPORT
1377 	void SCIPsortedvecInsertPtrRealRealBoolBool(
1378 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1379 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
1380 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
1381 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array where an element is to be inserted */
1382 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array where an element is to be inserted */
1383 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1384 	   void*                 keyval,             /**< key value of new element */
1385 	   SCIP_Real             field1val,          /**< additional value of new element */
1386 	   SCIP_Real             field2val,          /**< additional value of new element */
1387 	   SCIP_Bool             field3val,          /**< additional value of new element */
1388 	   SCIP_Bool             field4val,          /**< additional value of new element */
1389 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1390 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1391 	   );
1392 	
1393 	/** insert a new element into four joint arrays of pointers/Reals/Reals/ints/SCIP_Bools, sorted by first array in non-decreasing order */
1394 	SCIP_EXPORT
1395 	void SCIPsortedvecInsertPtrRealRealIntBool(
1396 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1397 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
1398 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
1399 	   int*                  intarray,           /**< int array where an element is to be inserted */
1400 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1401 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1402 	   void*                 keyval,             /**< key value of new element */
1403 	   SCIP_Real             field1val,          /**< additional value of new element */
1404 	   SCIP_Real             field2val,          /**< additional value of new element */
1405 	   int                   field3val,          /**< additional value of new element */
1406 	   SCIP_Bool             field4val,          /**< additional value of new element */
1407 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1408 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1409 	   );
1410 	
1411 	/** insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order */
1412 	SCIP_EXPORT
1413 	void SCIPsortedvecInsertPtrRealBool(
1414 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1415 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1416 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1417 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1418 	   void*                 keyval,             /**< key value of new element */
1419 	   SCIP_Real             field1val,          /**< additional value of new element */
1420 	   SCIP_Bool             field2val,          /**< additional value of new element */
1421 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1422 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1423 	   );
1424 	
1425 	/** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
1426 	SCIP_EXPORT
1427 	void SCIPsortedvecInsertPtrPtrInt(
1428 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1429 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1430 	   int*                  intarray,           /**< int array where an element is to be inserted */
1431 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1432 	   void*                 keyval,             /**< key value of new element */
1433 	   void*                 field1val,          /**< additional value of new element */
1434 	   int                   field2val,          /**< additional value of new element */
1435 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1436 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1437 	   );
1438 	
1439 	/** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
1440 	SCIP_EXPORT
1441 	void SCIPsortedvecInsertPtrPtrReal(
1442 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1443 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1444 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1445 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1446 	   void*                 keyval,             /**< key value of new element */
1447 	   void*                 field1val,          /**< additional value of new element */
1448 	   SCIP_Real             field2val,          /**< additional value of new element */
1449 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1450 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1451 	   );
1452 	
1453 	/** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1454 	SCIP_EXPORT
1455 	void SCIPsortedvecInsertPtrPtrIntInt(
1456 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1457 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1458 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1459 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1460 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1461 	   void*                 keyval,             /**< key value of new element */
1462 	   void*                 field1val,          /**< additional value of new element */
1463 	   int                   field2val,          /**< additional value of new element */
1464 	   int                   field3val,          /**< additional value of new element */
1465 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1466 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1467 	   );
1468 	
1469 	/** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
1470 	SCIP_EXPORT
1471 	void SCIPsortedvecInsertPtrRealIntInt(
1472 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1473 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1474 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1475 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1476 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1477 	   void*                 keyval,             /**< key value of new element */
1478 	   SCIP_Real             field1val,          /**< additional value of new element */
1479 	   int                   field2val,          /**< additional value of new element */
1480 	   int                   field3val,          /**< additional value of new element */
1481 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1482 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1483 	   );
1484 	
1485 	/** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
1486 	SCIP_EXPORT
1487 	void SCIPsortedvecInsertPtrPtrRealInt(
1488 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1489 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1490 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1491 	   int*                  intarray,           /**< int array where an element is to be inserted */
1492 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1493 	   void*                 keyval,             /**< key value of new element */
1494 	   void*                 field1val,          /**< additional value of new element */
1495 	   SCIP_Real             field2val,          /**< additional value of new element */
1496 	   int                   field3val,          /**< additional value of new element */
1497 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1498 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1499 	   );
1500 	
1501 	/** insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order */
1502 	SCIP_EXPORT
1503 	void SCIPsortedvecInsertPtrPtrRealBool(
1504 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1505 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1506 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1507 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1508 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1509 	   void*                 keyval,             /**< key value of new element */
1510 	   void*                 field1val,          /**< additional value of new element */
1511 	   SCIP_Real             field2val,          /**< additional value of new element */
1512 	   SCIP_Bool             field3val,          /**< additional value of new element */
1513 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1514 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1515 	   );
1516 	
1517 	/** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
1518 	SCIP_EXPORT
1519 	void SCIPsortedvecInsertPtrPtrLongInt(
1520 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1521 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1522 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1523 	   int*                  intarray,           /**< int array to be sorted */
1524 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1525 	   void*                 keyval,             /**< key value of new element */
1526 	   void*                 field1val,          /**< additional value of new element */
1527 	   SCIP_Longint          field2val,          /**< additional value of new element */
1528 	   int                   field3val,          /**< additional value of new element */
1529 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1530 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1531 	   );
1532 	
1533 	/** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
1534 	SCIP_EXPORT
1535 	void SCIPsortedvecInsertPtrPtrLongIntInt(
1536 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
1537 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
1538 	   SCIP_Longint*         longarray,          /**< SCIP_Longint where an element is to be inserted */
1539 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1540 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1541 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
1542 	   void*                 keyval,             /**< key value of new element */
1543 	   void*                 field1val,          /**< additional value of new element */
1544 	   SCIP_Longint          field2val,          /**< additional value of new element */
1545 	   int                   field3val,          /**< additional value of new element */
1546 	   int                   field4val,          /**< additional value of new element */
1547 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1548 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1549 	   );
1550 	
1551 	/** insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order */
1552 	SCIP_EXPORT
1553 	void SCIPsortedvecInsertRealIntInt(
1554 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1555 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1556 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1557 	   SCIP_Real             keyval,             /**< key value of new element */
1558 	   int                   field2val,          /**< additional value of new element */
1559 	   int                   field3val,          /**< additional value of new element */
1560 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1561 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1562 	   );
1563 	
1564 	/** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
1565 	SCIP_EXPORT
1566 	void SCIPsortedvecInsertRealBoolPtr(
1567 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
1568 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
1569 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
1570 	   SCIP_Real             keyval,             /**< key value of new element */
1571 	   SCIP_Bool             field1val,          /**< additional value of new element */
1572 	   void*                 field2val,          /**< additional value of new element */
1573 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1574 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1575 	   );
1576 	
1577 	/** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
1578 	SCIP_EXPORT
1579 	void SCIPsortedvecInsertRealPtr(
1580 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1581 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1582 	   SCIP_Real             keyval,             /**< key value of new element */
1583 	   void*                 field1val,          /**< additional value of new element */
1584 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1585 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1586 	   );
1587 	
1588 	/** insert a new element into an arrays of Reals, sorted in non-decreasing order */
1589 	SCIP_EXPORT
1590 	void SCIPsortedvecInsertReal(
1591 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1592 	   SCIP_Real             keyval,             /**< key value of new element */
1593 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1594 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1595 	   );
1596 	
1597 	/** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
1598 	SCIP_EXPORT
1599 	void SCIPsortedvecInsertRealInt(
1600 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1601 	   int*                  intarray,           /**< int array where an element is to be inserted */
1602 	   SCIP_Real             keyval,             /**< key value of new element */
1603 	   int                   field1val,          /**< additional value of new element */
1604 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1605 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1606 	   );
1607 	
1608 	/** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
1609 	SCIP_EXPORT
1610 	void SCIPsortedvecInsertRealIntLong(
1611 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
1612 	   int*                  intarray,           /**< int array to be permuted in the same way */
1613 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
1614 	   SCIP_Real             keyval,             /**< key value of new element */
1615 	   int                   field1val,          /**< additional value of new element */
1616 	   SCIP_Longint          field2val,          /**< additional value of new element */
1617 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1618 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1619 	   );
1620 	
1621 	/** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
1622 	SCIP_EXPORT
1623 	void SCIPsortedvecInsertRealIntPtr(
1624 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1625 	   int*                  intarray,           /**< int array where an element is to be inserted */
1626 	   void**                ptrarray,           /**< pointer array where an element is to be inserted  */
1627 	   SCIP_Real             keyval,             /**< key value of new element */
1628 	   int                   field1val,          /**< additional value of new element */
1629 	   void*                 field2val,          /**< additional value of new element */
1630 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1631 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1632 	   );
1633 	
1634 	/** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
1635 	SCIP_EXPORT
1636 	void SCIPsortedvecInsertRealRealPtr(
1637 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
1638 	   SCIP_Real*            realarray2,         /**< second  SCIP_Real array where an element is to be inserted */
1639 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1640 	   SCIP_Real             keyval,             /**< key value of new element */
1641 	   SCIP_Real             field1val,          /**< additional value of new element */
1642 	   void*                 field2val,          /**< additional value of new element */
1643 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1644 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1645 	   );
1646 	
1647 	/** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
1648 	SCIP_EXPORT
1649 	void SCIPsortedvecInsertRealPtrPtrInt(
1650 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1651 	   void**                ptrarray1,          /**< pointer array where an element is to be inserted */
1652 	   void**                ptrarray2,          /**< pointer array where an element is to be inserted */
1653 	   int*                  intarray,           /**< int array where an element is to be inserted */
1654 	   SCIP_Real             keyval,             /**< key value of new element */
1655 	   void*                 field1val,          /**< additional value of new element */
1656 	   void*                 field2val,          /**< additional value of new element */
1657 	   int                   intval,             /**< additional value of new element */
1658 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1659 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1660 	   );
1661 	
1662 	/** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1663 	SCIP_EXPORT
1664 	void SCIPsortedvecInsertRealPtrPtrIntInt(
1665 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1666 	   void**                ptrarray1,          /**< pointer array where an element is to be inserted */
1667 	   void**                ptrarray2,          /**< pointer array where an element is to be inserted */
1668 	   int*                  intarray1,          /**< int array where an element is to be inserted */
1669 	   int*                  intarray2,          /**< int array where an element is to be inserted */
1670 	   SCIP_Real             keyval,             /**< key value of new element */
1671 	   void*                 field1val,          /**< additional value of new element */
1672 	   void*                 field2val,          /**< additional value of new element */
1673 	   int                   intval1,            /**< additional value of new element */
1674 	   int                   intval2,            /**< additional value of new element */
1675 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1676 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1677 	   );
1678 	
1679 	/** insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
1680 	SCIP_EXPORT
1681 	void SCIPsortedvecInsertRealLongRealInt(
1682 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
1683 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1684 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be inserted */
1685 	   int*                  intarray,           /**< int array where an element is to be inserted */
1686 	   SCIP_Real             keyval,             /**< key value of new element */
1687 	   SCIP_Longint          field1val,          /**< additional value of new element */
1688 	   SCIP_Real             field2val,          /**< additional value of new element */
1689 	   int                   field3val,          /**< additional value of new element */
1690 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1691 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1692 	   );
1693 	
1694 	/** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
1695 	SCIP_EXPORT
1696 	void SCIPsortedvecInsertRealRealIntInt(
1697 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
1698 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
1699 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1700 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1701 	   SCIP_Real             keyval,             /**< key value of new element */
1702 	   SCIP_Real             field1val,          /**< additional value of new element */
1703 	   int                   field2val,          /**< additional value of new element */
1704 	   int                   field3val,          /**< additional value of new element */
1705 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1706 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1707 	   );
1708 	
1709 	/** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
1710 	SCIP_EXPORT
1711 	void SCIPsortedvecInsertRealRealRealInt(
1712 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
1713 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
1714 	   SCIP_Real*            realarray3,         /**< third SCIP_Real array where an element is to be inserted */
1715 	   int*                  intarray,           /**< int array where an element is to be inserted */
1716 	   SCIP_Real             keyval,             /**< key value of new element */
1717 	   SCIP_Real             field1val,          /**< additional value of new element */
1718 	   SCIP_Real             field2val,          /**< additional value of new element */
1719 	   int                   field3val,          /**< additional value of new element */
1720 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1721 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1722 	   );
1723 	
1724 	/** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
1725 	SCIP_EXPORT
1726 	void SCIPsortedvecInsertRealRealRealPtr(
1727 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
1728 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
1729 	   SCIP_Real*            realarray3,         /**< third SCIP_Real array where an element is to be inserted */
1730 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1731 	   SCIP_Real             keyval,             /**< key value of new element */
1732 	   SCIP_Real             field1val,          /**< additional value of new element */
1733 	   SCIP_Real             field2val,          /**< additional value of new element */
1734 	   void*                 field3val,          /**< additional value of new element */
1735 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1736 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1737 	   );
1738 	
1739 	/** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
1740 	SCIP_EXPORT
1741 	void SCIPsortedvecInsertRealRealRealBoolPtr(
1742 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
1743 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
1744 	   SCIP_Real*            realarray3,         /**< third SCIP_Real array where an element is to be inserted */
1745 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1746 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1747 	   SCIP_Real             keyval,             /**< key value of new element */
1748 	   SCIP_Real             field1val,          /**< additional value of new element */
1749 	   SCIP_Real             field2val,          /**< additional value of new element */
1750 	   SCIP_Bool             field3val,          /**< additional value of new element */
1751 	   void*                 field4val,          /**< additional value of new element */
1752 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1753 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1754 	   );
1755 	
1756 	/** insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order */
1757 	SCIP_EXPORT
1758 	void SCIPsortedvecInsertRealRealRealBoolBoolPtr(
1759 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
1760 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
1761 	   SCIP_Real*            realarray3,         /**< third SCIP_Real array where an element is to be inserted */
1762 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array where an element is to be inserted */
1763 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array where an element is to be inserted */
1764 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1765 	   SCIP_Real             keyval,             /**< key value of new element */
1766 	   SCIP_Real             field1val,          /**< additional value of new element */
1767 	   SCIP_Real             field2val,          /**< additional value of new element */
1768 	   SCIP_Bool             field3val,          /**< additional value of new element */
1769 	   SCIP_Bool             field4val,          /**< additional value of new element */
1770 	   void*                 field5val,          /**< additional value of new element */
1771 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1772 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1773 	   );
1774 	
1775 	/** insert a new element into an array of ints in non-decreasing order */
1776 	SCIP_EXPORT
1777 	void SCIPsortedvecInsertInt(
1778 	   int*                  intarray,           /**< int array where an element is to be inserted */
1779 	   int                   keyval,             /**< key value of new element */
1780 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1781 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1782 	   );
1783 	
1784 	/** insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order */
1785 	SCIP_EXPORT
1786 	void SCIPsortedvecInsertIntInt(
1787 	   int*                  intarray1,          /**< int array where an element is to be inserted */
1788 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1789 	   int                   keyval,             /**< key value of new element */
1790 	   int                   field1val,          /**< additional value of new element */
1791 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1792 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1793 	   );
1794 	
1795 	/** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
1796 	SCIP_EXPORT
1797 	void SCIPsortedvecInsertIntPtr(
1798 	   int*                  intarray,           /**< int array where an element is to be inserted */
1799 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1800 	   int                   keyval,             /**< key value of new element */
1801 	   void*                 field1val,          /**< additional value of new element */
1802 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1803 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1804 	   );
1805 	
1806 	/** insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order */
1807 	SCIP_EXPORT
1808 	void SCIPsortedvecInsertIntReal(
1809 	   int*                  intarray,           /**< int array where an element is to be inserted */
1810 	   SCIP_Real*            realarray,          /**< real array where an element is to be inserted */
1811 	   int                   keyval,             /**< key value of new element */
1812 	   SCIP_Real             field1val,          /**< additional value of new element */
1813 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1814 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1815 	   );
1816 	
1817 	/** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
1818 	SCIP_EXPORT
1819 	void SCIPsortedvecInsertIntIntInt(
1820 	   int*                  intarray1,          /**< int array where an element is to be inserted */
1821 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1822 	   int*                  intarray3,          /**< third int array where an element is to be inserted */
1823 	   int                   keyval,             /**< key value of new element */
1824 	   int                   field1val,          /**< additional value of new element */
1825 	   int                   field2val,          /**< additional value of new element */
1826 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1827 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1828 	   );
1829 	
1830 	/** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
1831 	SCIP_EXPORT
1832 	void SCIPsortedvecInsertIntIntLong(
1833 	   int*                  intarray1,          /**< int array where an element is to be inserted */
1834 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1835 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1836 	   int                   keyval,             /**< key value of new element */
1837 	   int                   field1val,          /**< additional value of new element */
1838 	   SCIP_Longint          field2val,          /**< additional value of new element */
1839 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1840 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1841 	   );
1842 	
1843 	/** insert a new element into three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order */
1844 	SCIP_EXPORT
1845 	void SCIPsortedvecInsertIntRealLong(
1846 	   int*                  intarray,           /**< int array where an element is to be inserted */
1847 	   SCIP_Real*            realarray,          /**< SCIP_Real where an element is to be inserted */
1848 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1849 	   int                   keyval,             /**< key value of new element */
1850 	   SCIP_Real             field1val,          /**< additional value of new element */
1851 	   SCIP_Longint          field2val,          /**< additional value of new element */
1852 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1853 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1854 	   );
1855 	
1856 	/** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
1857 	SCIP_EXPORT
1858 	void SCIPsortedvecInsertIntIntPtr(
1859 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1860 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1861 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1862 	   int                   keyval,             /**< key value of new element */
1863 	   int                   field1val,          /**< additional value of new element */
1864 	   void*                 field2val,          /**< additional value of new element */
1865 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1866 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1867 	   );
1868 	
1869 	/** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
1870 	SCIP_EXPORT
1871 	void SCIPsortedvecInsertIntIntReal(
1872 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1873 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1874 	   SCIP_Real*            realarray,          /**< real array where an element is to be inserted */
1875 	   int                   keyval,             /**< key value of new element */
1876 	   int                   field1val,          /**< additional value of new element */
1877 	   SCIP_Real             field2val,          /**< additional value of new element */
1878 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1879 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1880 	   );
1881 	
1882 	/** insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
1883 	SCIP_EXPORT
1884 	void SCIPsortedvecInsertIntPtrReal(
1885 	   int*                  intarray,           /**< int array where an element is to be inserted */
1886 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1887 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1888 	   int                   keyval,             /**< key value of new element */
1889 	   void*                 field1val,          /**< additional value of new element */
1890 	   SCIP_Real             field2val,          /**< additional value of new element */
1891 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1892 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1893 	   );
1894 	
1895 	/** insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
1896 	SCIP_EXPORT
1897 	void SCIPsortedvecInsertIntIntIntPtr(
1898 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1899 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1900 	   int*                  intarray3,          /**< second int array where an element is to be inserted */
1901 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1902 	   int                   keyval,             /**< key value of new element */
1903 	   int                   field1val,          /**< additional value of new element */
1904 	   int                   field2val,          /**< additional value of new element */
1905 	   void*                 field3val,          /**< additional value of new element */
1906 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1907 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1908 	   );
1909 	
1910 	/** insert a new element into four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
1911 	SCIP_EXPORT
1912 	void SCIPsortedvecInsertIntIntIntReal(
1913 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1914 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1915 	   int*                  intarray3,          /**< second int array where an element is to be inserted */
1916 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1917 	   int                   keyval,             /**< key value of new element */
1918 	   int                   field1val,          /**< additional value of new element */
1919 	   int                   field2val,          /**< additional value of new element */
1920 	   SCIP_Real             field3val,          /**< additional value of new element */
1921 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1922 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1923 	   );
1924 	
1925 	/** insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order */
1926 	SCIP_EXPORT
1927 	void SCIPsortedvecInsertIntPtrIntReal(
1928 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
1929 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1930 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
1931 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1932 	   int                   keyval,             /**< key value of new element */
1933 	   void*                 field1val,          /**< additional value of new element */
1934 	   int                   field2val,          /**< additional value of new element */
1935 	   SCIP_Real             field3val,          /**< additional value of new element */
1936 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1937 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1938 	   );
1939 	
1940 	/** insert a new element into an array of Longints, sorted in non-decreasing order */
1941 	SCIP_EXPORT
1942 	void SCIPsortedvecInsertLong(
1943 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1944 	   SCIP_Longint          keyval,             /**< key value of new element */
1945 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1946 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1947 	   );
1948 	
1949 	/** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
1950 	SCIP_EXPORT
1951 	void SCIPsortedvecInsertLongPtr(
1952 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1953 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1954 	   SCIP_Longint          keyval,             /**< key value of new element */
1955 	   void*                 field1val,          /**< additional value of new element */
1956 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1957 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1958 	   );
1959 	
1960 	/** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
1961 	SCIP_EXPORT
1962 	void SCIPsortedvecInsertLongPtrInt(
1963 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1964 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1965 	   int*                  intarray,           /**< int array where an element is to be inserted */
1966 	   SCIP_Longint          keyval,             /**< key value of new element */
1967 	   void*                 field1val,          /**< additional value of new element */
1968 	   int                   field2val,          /**< additional value of new element */
1969 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1970 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1971 	   );
1972 	
1973 	/** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
1974 	SCIP_EXPORT
1975 	void SCIPsortedvecInsertLongPtrRealBool(
1976 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1977 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1978 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
1979 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1980 	   SCIP_Longint          keyval,             /**< key value of new element */
1981 	   void*                 field1val,          /**< additional value of new element */
1982 	   SCIP_Real             field2val,          /**< additional value of new element */
1983 	   SCIP_Bool             field3val,          /**< additional value of new element */
1984 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
1985 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
1986 	   );
1987 	
1988 	/** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
1989 	SCIP_EXPORT
1990 	void SCIPsortedvecInsertLongPtrRealRealBool(
1991 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
1992 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
1993 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be inserted  */
1994 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
1995 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
1996 	   SCIP_Longint          keyval,             /**< key value of new element */
1997 	   void*                 field1val,          /**< additional value of new element */
1998 	   SCIP_Real             field2val,          /**< additional value of new element */
1999 	   SCIP_Real             field3val,          /**< additional value of new element */
2000 	   SCIP_Bool             field4val,          /**< additional value of new element */
2001 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2002 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2003 	   );
2004 	
2005 	/** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
2006 	SCIP_EXPORT
2007 	void SCIPsortedvecInsertLongPtrRealRealIntBool(
2008 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2009 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2010 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be inserted  */
2011 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
2012 	   int*                  intarray,           /**< int array where an element is to be inserted */
2013 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2014 	   SCIP_Longint          keyval,             /**< key value of new element */
2015 	   void*                 field1val,          /**< additional value of new element */
2016 	   SCIP_Real             field2val,          /**< additional value of new element */
2017 	   SCIP_Real             field3val,          /**< additional value of new element */
2018 	   int                   field4val,          /**< additional value of new element */
2019 	   SCIP_Bool             field5val,          /**< additional value of new element */
2020 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2021 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2022 	   );
2023 	
2024 	/** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
2025 	SCIP_EXPORT
2026 	void SCIPsortedvecInsertLongPtrPtrInt(
2027 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2028 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2029 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2030 	   int*                  intarray,           /**< int array where an element is to be inserted */
2031 	   SCIP_Longint          keyval,             /**< key value of new element */
2032 	   void*                 field1val,          /**< additional value of new element */
2033 	   void*                 field2val,          /**< additional value of new element */
2034 	   int                   field3val,          /**< additional value of new element */
2035 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2036 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2037 	   );
2038 	
2039 	/** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
2040 	SCIP_EXPORT
2041 	void SCIPsortedvecInsertLongPtrPtrIntInt(
2042 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2043 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2044 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2045 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2046 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2047 	   SCIP_Longint          keyval,             /**< key value of new element */
2048 	   void*                 field1val,          /**< additional value of new element */
2049 	   void*                 field2val,          /**< additional value of new element */
2050 	   int                   field3val,          /**< additional value of new element */
2051 	   int                   field4val,          /**< additional value of new element */
2052 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2053 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2054 	   );
2055 	
2056 	/** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
2057 	SCIP_EXPORT
2058 	void SCIPsortedvecInsertLongPtrPtrBoolInt(
2059 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2060 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2061 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2062 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2063 	   int*                  intarray,           /**< int array to be sorted */
2064 	   SCIP_Longint          keyval,             /**< key value of new element */
2065 	   void*                 field1val,          /**< additional value of new element */
2066 	   void*                 field2val,          /**< additional value of new element */
2067 	   SCIP_Bool             field3val,          /**< additional value of new element */
2068 	   int                   field4val,          /**< additional value of new element */
2069 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2070 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2071 	   );
2072 	
2073 	/** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
2074 	SCIP_EXPORT
2075 	void SCIPsortedvecInsertPtrIntIntBoolBool(
2076 	   void**                ptrarray,           /**< pointer array to be sorted */
2077 	   int*                  intarray1,          /**< first int array to be permuted in the same way */
2078 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
2079 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
2080 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
2081 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2082 	   void*                 keyval,             /**< key value of new element */
2083 	   int                   field1val,          /**< additional value of new element */
2084 	   int                   field2val,          /**< additional value of new element */
2085 	   SCIP_Bool             field3val,          /**< additional value of new element */
2086 	   SCIP_Bool             field4val,          /**< additional value of new element */
2087 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2088 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2089 	   );
2090 	
2091 	/** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
2092 	SCIP_EXPORT
2093 	void SCIPsortedvecInsertIntPtrIntIntBoolBool(
2094 	   int*                  intarray1,          /**< int array to be sorted */
2095 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
2096 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
2097 	   int*                  intarray3,          /**< thrid int array to be permuted in the same way */
2098 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
2099 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
2100 	   int                   keyval,             /**< key value of new element */
2101 	   void*                 field1val,          /**< additional value of new element */
2102 	   int                   field2val,          /**< additional value of new element */
2103 	   int                   field3val,          /**< additional value of new element */
2104 	   SCIP_Bool             field4val,          /**< additional value of new element */
2105 	   SCIP_Bool             field5val,          /**< additional value of new element */
2106 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2107 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2108 	   );
2109 	
2110 	
2111 	/* downwards insertion */
2112 	
2113 	/** insert a new element into an index array in non-increasing order */
2114 	SCIP_EXPORT
2115 	void SCIPsortedvecInsertDownInd(
2116 	   int*                  indarray,           /**< pointer to the index array where an element is to be inserted */
2117 	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
2118 	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
2119 	   int                   keyval,             /**< key value of new element */
2120 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2121 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2122 	   );
2123 	
2124 	/** insert a new element into an array of pointers in non-increasing order */
2125 	SCIP_EXPORT
2126 	void SCIPsortedvecInsertDownPtr(
2127 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2128 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2129 	   void*                 keyval,             /**< key value of new element */
2130 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2131 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2132 	   );
2133 	
2134 	/** insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
2135 	SCIP_EXPORT
2136 	void SCIPsortedvecInsertDownPtrPtr(
2137 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2138 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2139 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2140 	   void*                 keyval,             /**< key value of new element */
2141 	   void*                 field1val,          /**< additional value of new element */
2142 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2143 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2144 	   );
2145 	
2146 	/** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
2147 	SCIP_EXPORT
2148 	void SCIPsortedvecInsertDownPtrReal(
2149 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2150 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2151 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2152 	   void*                 keyval,             /**< key value of new element */
2153 	   SCIP_Real             field1val,          /**< additional value of new element */
2154 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2155 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2156 	   );
2157 	
2158 	/** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order */
2159 	SCIP_EXPORT
2160 	void SCIPsortedvecInsertDownPtrInt(
2161 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2162 	   int*                  intarray,           /**< int array where an element is to be inserted */
2163 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2164 	   void*                 keyval,             /**< key value of new element */
2165 	   int                   field1val,          /**< additional value of new element */
2166 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2167 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2168 	   );
2169 	
2170 	/** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
2171 	SCIP_EXPORT
2172 	void SCIPsortedvecInsertDownPtrBool(
2173 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2174 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2175 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2176 	   void*                 keyval,             /**< key value of new element */
2177 	   SCIP_Bool             field1val,          /**< additional value of new element */
2178 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2179 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2180 	   );
2181 	
2182 	/** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
2183 	SCIP_EXPORT
2184 	void SCIPsortedvecInsertDownPtrIntInt(
2185 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2186 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2187 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2188 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2189 	   void*                 keyval,             /**< key value of new element */
2190 	   int                   field1val,          /**< additional value of new element */
2191 	   int                   field2val,          /**< additional value of new element */
2192 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2193 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2194 	   );
2195 	
2196 	/** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
2197 	SCIP_EXPORT
2198 	void SCIPsortedvecInsertDownPtrRealInt(
2199 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2200 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2201 	   int*                  intarray,           /**< int array where an element is to be inserted */
2202 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2203 	   void*                 keyval,             /**< key value of new element */
2204 	   SCIP_Real             field1val,          /**< additional value of new element */
2205 	   int                   field2val,          /**< additional value of new element */
2206 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2207 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2208 	   );
2209 	
2210 	/** insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order */
2211 	SCIP_EXPORT
2212 	void SCIPsortedvecInsertDownPtrRealBool(
2213 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2214 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2215 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2216 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2217 	   void*                 keyval,             /**< key value of new element */
2218 	   SCIP_Real             field1val,          /**< additional value of new element */
2219 	   SCIP_Bool             field2val,          /**< additional value of new element */
2220 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2221 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2222 	   );
2223 	
2224 	/** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
2225 	SCIP_EXPORT
2226 	void SCIPsortedvecInsertDownPtrPtrInt(
2227 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2228 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2229 	   int*                  intarray,           /**< int array where an element is to be inserted */
2230 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2231 	   void*                 keyval,             /**< key value of new element */
2232 	   void*                 field1val,          /**< additional value of new element */
2233 	   int                   field2val,          /**< additional value of new element */
2234 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2235 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2236 	   );
2237 	
2238 	/** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
2239 	SCIP_EXPORT
2240 	void SCIPsortedvecInsertDownPtrPtrReal(
2241 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2242 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2243 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2244 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2245 	   void*                 keyval,             /**< key value of new element */
2246 	   void*                 field1val,          /**< additional value of new element */
2247 	   SCIP_Real             field2val,          /**< additional value of new element */
2248 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2249 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2250 	   );
2251 	
2252 	/** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
2253 	SCIP_EXPORT
2254 	void SCIPsortedvecInsertDownPtrPtrIntInt(
2255 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2256 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2257 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2258 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2259 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2260 	   void*                 keyval,             /**< key value of new element */
2261 	   void*                 field1val,          /**< additional value of new element */
2262 	   int                   field2val,          /**< additional value of new element */
2263 	   int                   field3val,          /**< additional value of new element */
2264 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2265 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2266 	   );
2267 	
2268 	/** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
2269 	SCIP_EXPORT
2270 	void SCIPsortedvecInsertDownPtrRealIntInt(
2271 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2272 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2273 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2274 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2275 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2276 	   void*                 keyval,             /**< key value of new element */
2277 	   SCIP_Real             field1val,          /**< additional value of new element */
2278 	   int                   field2val,          /**< additional value of new element */
2279 	   int                   field3val,          /**< additional value of new element */
2280 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2281 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2282 	   );
2283 	
2284 	/** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
2285 	SCIP_EXPORT
2286 	void SCIPsortedvecInsertDownPtrPtrRealInt(
2287 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2288 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2289 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2290 	   int*                  intarray,           /**< int array where an element is to be inserted */
2291 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2292 	   void*                 keyval,             /**< key value of new element */
2293 	   void*                 field1val,          /**< additional value of new element */
2294 	   SCIP_Real             field2val,          /**< additional value of new element */
2295 	   int                   field3val,          /**< additional value of new element */
2296 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2297 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2298 	   );
2299 	
2300 	/** insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order */
2301 	SCIP_EXPORT
2302 	void SCIPsortedvecInsertDownPtrPtrRealBool(
2303 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2304 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2305 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2306 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2307 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2308 	   void*                 keyval,             /**< key value of new element */
2309 	   void*                 field1val,          /**< additional value of new element */
2310 	   SCIP_Real             field2val,          /**< additional value of new element */
2311 	   SCIP_Bool             field3val,          /**< additional value of new element */
2312 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2313 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2314 	   );
2315 	
2316 	
2317 	/** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
2318 	SCIP_EXPORT
2319 	void SCIPsortedvecInsertDownPtrPtrLongInt(
2320 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2321 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2322 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2323 	   int*                  intarray,           /**< int array where an element is to be inserted */
2324 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2325 	   void*                 keyval,             /**< key value of new element */
2326 	   void*                 field1val,          /**< additional value of new element */
2327 	   SCIP_Longint          field2val,          /**< additional value of new element */
2328 	   int                   field3val,          /**< additional value of new element */
2329 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2330 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2331 	   );
2332 	
2333 	/** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
2334 	SCIP_EXPORT
2335 	void SCIPsortedvecInsertDownPtrPtrLongIntInt(
2336 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2337 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2338 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2339 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2340 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2341 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2342 	   void*                 keyval,             /**< key value of new element */
2343 	   void*                 field1val,          /**< additional value of new element */
2344 	   SCIP_Longint          field2val,          /**< additional value of new element */
2345 	   int                   field3val,          /**< additional value of new element */
2346 	   int                   field4val,          /**< additional value of new element */
2347 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2348 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2349 	   );
2350 	
2351 	/** insert a new element into an array of Reals, sorted in non-increasing order */
2352 	SCIP_EXPORT
2353 	void SCIPsortedvecInsertDownReal(
2354 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2355 	   SCIP_Real             keyval,             /**< key value of new element */
2356 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2357 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2358 	   );
2359 	
2360 	/** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
2361 	SCIP_EXPORT
2362 	void SCIPsortedvecInsertDownRealBoolPtr(
2363 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
2364 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
2365 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
2366 	   SCIP_Real             keyval,             /**< key value of new element */
2367 	   SCIP_Bool             field1val,          /**< additional value of new element */
2368 	   void*                 field2val,          /**< additional value of new element */
2369 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2370 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2371 	   );
2372 	
2373 	/** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
2374 	SCIP_EXPORT
2375 	void SCIPsortedvecInsertDownRealPtr(
2376 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2377 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2378 	   SCIP_Real             keyval,             /**< key value of new element */
2379 	   void*                 field1val,          /**< additional value of new element */
2380 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2381 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2382 	   );
2383 	
2384 	/** insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order */
2385 	SCIP_EXPORT
2386 	void SCIPsortedvecInsertDownRealPtrPtr(
2387 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2388 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2389 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2390 	   SCIP_Real             keyval,             /**< key value of new element */
2391 	   void*                 field1val,          /**< additional value of new element */
2392 	   void*                 field2val,          /**< additional value of new element */
2393 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2394 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2395 	   );
2396 	
2397 	/** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order */
2398 	SCIP_EXPORT
2399 	void SCIPsortedvecInsertDownRealInt(
2400 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2401 	   int*                  intarray,           /**< int array where an element is to be inserted */
2402 	   SCIP_Real             keyval,             /**< key value of new element */
2403 	   int                   field1val,          /**< additional value of new element */
2404 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2405 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2406 	   );
2407 	
2408 	/** insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-increasing order */
2409 	SCIP_EXPORT
2410 	void SCIPsortedvecInsertDownRealIntInt(
2411 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2412 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2413 	   int*                  intarray2,          /**< int array where an element is to be inserted */
2414 	   SCIP_Real             keyval,             /**< key value of new element */
2415 	   int                   field1val,          /**< additional value of new element */
2416 	   int                   field2val,          /**< additional value of new element */
2417 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2418 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2419 	   );
2420 	
2421 	/** insert a new element into three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order */
2422 	SCIP_EXPORT
2423 	void SCIPsortedvecInsertDownRealRealInt(
2424 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2425 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
2426 	   int*                  intarray,           /**< int array where an element is to be inserted */
2427 	   SCIP_Real             keyval,             /**< key value of new element */
2428 	   SCIP_Real             field1val,          /**< additional value of new element */
2429 	   int                   field2val,          /**< additional value of new element */
2430 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2431 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2432 	   );
2433 	
2434 	/** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
2435 	SCIP_EXPORT
2436 	void SCIPsortedvecInsertDownRealIntLong(
2437 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
2438 	   int*                  intarray,           /**< int array to be permuted in the same way */
2439 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be permuted in the same way */
2440 	   SCIP_Real             keyval,             /**< key value of new element */
2441 	   int                   field1val,          /**< additional value of new element */
2442 	   SCIP_Longint          field2val,          /**< additional value of new element */
2443 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2444 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2445 	   );
2446 	
2447 	/** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
2448 	SCIP_EXPORT
2449 	void SCIPsortedvecInsertDownRealIntPtr(
2450 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2451 	   int*                  intarray,           /**< int array where an element is to be inserted */
2452 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2453 	   SCIP_Real             keyval,             /**< key value of new element */
2454 	   int                   field1val,          /**< additional value of new element */
2455 	   void*                 field2val,          /**< additional value of new element */
2456 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2457 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2458 	   );
2459 	
2460 	
2461 	/** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
2462 	SCIP_EXPORT
2463 	void SCIPsortedvecInsertDownRealRealPtr(
2464 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
2465 	   SCIP_Real*            realarray2,         /**< second  SCIP_Real array where an element is to be inserted */
2466 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2467 	   SCIP_Real             keyval,             /**< key value of new element */
2468 	   SCIP_Real             field1val,          /**< additional value of new element */
2469 	   void*                 field2val,          /**< additional value of new element */
2470 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2471 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2472 	   );
2473 	
2474 	/** insert a new element into three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order */
2475 	SCIP_EXPORT
2476 	void SCIPsortedvecInsertDownRealRealPtrPtr(
2477 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
2478 	   SCIP_Real*            realarray2,         /**< second  SCIP_Real array where an element is to be inserted */
2479 	   void**                ptrarray1,          /**< pointer array where an element is to be inserted */
2480 	   void**                ptrarray2,          /**< pointer array where an element is to be inserted */
2481 	   SCIP_Real             keyval,             /**< key value of new element */
2482 	   SCIP_Real             field1val,          /**< additional value of new element */
2483 	   void*                 field2val,          /**< additional value of new element */
2484 	   void*                 field3val,          /**< additional value of new element */
2485 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2486 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2487 	   );
2488 	
2489 	/** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
2490 	SCIP_EXPORT
2491 	void SCIPsortedvecInsertDownRealPtrPtrInt(
2492 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2493 	   void**                ptrarray1,          /**< pointer array where an element is to be inserted */
2494 	   void**                ptrarray2,          /**< pointer array where an element is to be inserted */
2495 	   int*                  intarray,           /**< int array where an element is to be inserted */
2496 	   SCIP_Real             keyval,             /**< key value of new element */
2497 	   void*                 field1val,          /**< additional value of new element */
2498 	   void*                 field2val,          /**< additional value of new element */
2499 	   int                   intval,             /**< additional value of new element */
2500 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2501 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2502 	   );
2503 	
2504 	/** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
2505 	SCIP_EXPORT
2506 	void SCIPsortedvecInsertDownRealPtrPtrIntInt(
2507 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2508 	   void**                ptrarray1,          /**< pointer array where an element is to be inserted */
2509 	   void**                ptrarray2,          /**< pointer array where an element is to be inserted */
2510 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2511 	   int*                  intarray2,          /**< int array where an element is to be inserted */
2512 	   SCIP_Real             keyval,             /**< key value of new element */
2513 	   void*                 field1val,          /**< additional value of new element */
2514 	   void*                 field2val,          /**< additional value of new element */
2515 	   int                   intval1,            /**< additional value of new element */
2516 	   int                   intval2,            /**< additional value of new element */
2517 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2518 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2519 	   );
2520 	
2521 	/** insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
2522 	SCIP_EXPORT
2523 	void SCIPsortedvecInsertDownRealLongRealInt(
2524 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
2525 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2526 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be inserted */
2527 	   int*                  intarray,           /**< int array  where an element is to be inserted */
2528 	   SCIP_Real             keyval,             /**< key value of new element */
2529 	   SCIP_Longint          field1val,          /**< additional value of new element */
2530 	   SCIP_Real             field2val,          /**< additional value of new element */
2531 	   int                   field3val,          /**< additional value of new element */
2532 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2533 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2534 	   );
2535 	
2536 	/** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
2537 	SCIP_EXPORT
2538 	void SCIPsortedvecInsertDownRealRealIntInt(
2539 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be inserted */
2540 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
2541 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2542 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2543 	   SCIP_Real             keyval,             /**< key value of new element */
2544 	   SCIP_Real             field1val,          /**< additional value of new element */
2545 	   int                   field2val,          /**< additional value of new element */
2546 	   int                   field3val,          /**< additional value of new element */
2547 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2548 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2549 	   );
2550 	
2551 	/** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
2552 	SCIP_EXPORT
2553 	void SCIPsortedvecInsertDownRealRealRealInt(
2554 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
2555 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
2556 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be inserted */
2557 	   int*                  intarray,           /**< int array where an element is to be inserted */
2558 	   SCIP_Real             keyval,             /**< key value of new element */
2559 	   SCIP_Real             field1val,          /**< additional value of new element */
2560 	   SCIP_Real             field2val,          /**< additional value of new element */
2561 	   int                   field3val,          /**< additional value of new element */
2562 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2563 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2564 	   );
2565 	
2566 	/** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
2567 	SCIP_EXPORT
2568 	void SCIPsortedvecInsertDownRealRealRealPtr(
2569 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
2570 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
2571 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be inserted */
2572 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2573 	   SCIP_Real             keyval,             /**< key value of new element */
2574 	   SCIP_Real             field1val,          /**< additional value of new element */
2575 	   SCIP_Real             field2val,          /**< additional value of new element */
2576 	   void*                 field3val,          /**< additional value of new element */
2577 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2578 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2579 	   );
2580 	
2581 	/** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
2582 	SCIP_EXPORT
2583 	void SCIPsortedvecInsertDownRealRealRealBoolPtr(
2584 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
2585 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
2586 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be inserted */
2587 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2588 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2589 	   SCIP_Real             keyval,             /**< key value of new element */
2590 	   SCIP_Real             field1val,          /**< additional value of new element */
2591 	   SCIP_Real             field2val,          /**< additional value of new element */
2592 	   SCIP_Bool             field3val,          /**< additional value of new element */
2593 	   void*                 field4val,          /**< additional value of new element */
2594 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2595 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2596 	   );
2597 	
2598 	/** insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order */
2599 	SCIP_EXPORT
2600 	void SCIPsortedvecInsertDownRealRealRealBoolBoolPtr(
2601 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be inserted */
2602 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be inserted */
2603 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be inserted */
2604 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array where an element is to be inserted */
2605 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array where an element is to be inserted */
2606 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2607 	   SCIP_Real             keyval,             /**< key value of new element */
2608 	   SCIP_Real             field1val,          /**< additional value of new element */
2609 	   SCIP_Real             field2val,          /**< additional value of new element */
2610 	   SCIP_Bool             field3val,          /**< additional value of new element */
2611 	   SCIP_Bool             field4val,          /**< additional value of new element */
2612 	   void*                 field5val,          /**< additional value of new element */
2613 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2614 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2615 	   );
2616 	
2617 	/** insert a new element into an array of ints in non-increasing order */
2618 	SCIP_EXPORT
2619 	void SCIPsortedvecInsertDownInt(
2620 	   int*                  intarray,           /**< int array where an element is to be inserted */
2621 	   int                   keyval,             /**< key value of new element */
2622 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2623 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2624 	   );
2625 	
2626 	/** insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order */
2627 	SCIP_EXPORT
2628 	void SCIPsortedvecInsertDownIntInt(
2629 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2630 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2631 	   int                   keyval,             /**< key value of new element */
2632 	   int                   field1val,          /**< additional value of new element */
2633 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2634 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2635 	   );
2636 	
2637 	/** insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order */
2638 	SCIP_EXPORT
2639 	void SCIPsortedvecInsertDownIntReal(
2640 	   int*                  intarray,           /**< int array where an element is to be inserted */
2641 	   SCIP_Real*            realarray,          /**< real array where an element is to be inserted */
2642 	   int                   keyval,             /**< key value of new element */
2643 	   SCIP_Real             field1val,          /**< additional value of new element */
2644 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2645 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2646 	   );
2647 	
2648 	/** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
2649 	SCIP_EXPORT
2650 	void SCIPsortedvecInsertDownIntIntInt(
2651 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2652 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2653 	   int*                  intarray3,          /**< third int array where an element is to be inserted */
2654 	   int                   keyval,             /**< key value of new element */
2655 	   int                   field1val,          /**< additional value of new element */
2656 	   int                   field2val,          /**< additional value of new element */
2657 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2658 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2659 	   );
2660 	
2661 	/** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
2662 	SCIP_EXPORT
2663 	void SCIPsortedvecInsertDownIntIntLong(
2664 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2665 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2666 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2667 	   int                   keyval,             /**< key value of new element */
2668 	   int                   field1val,          /**< additional value of new element */
2669 	   SCIP_Longint          field2val,          /**< additional value of new element */
2670 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2671 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2672 	   );
2673 	
2674 	/** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
2675 	SCIP_EXPORT
2676 	void SCIPsortedvecInsertDownIntIntPtr(
2677 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2678 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2679 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2680 	   int                   keyval,             /**< key value of new element */
2681 	   int                   field1val,          /**< additional value of new element */
2682 	   void*                 field2val,          /**< additional value of new element */
2683 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2684 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2685 	   );
2686 	
2687 	/** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
2688 	SCIP_EXPORT
2689 	void SCIPsortedvecInsertDownIntIntReal(
2690 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2691 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2692 	   SCIP_Real*            realarray,          /**< real array where an element is to be inserted */
2693 	   int                   keyval,             /**< key value of new element */
2694 	   int                   field1val,          /**< additional value of new element */
2695 	   SCIP_Real             field2val,          /**< additional value of new element */
2696 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2697 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2698 	   );
2699 	
2700 	/** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order */
2701 	SCIP_EXPORT
2702 	void SCIPsortedvecInsertDownIntPtr(
2703 	   int*                  intarray,           /**< int array where an element is to be inserted */
2704 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2705 	   int                   keyval,             /**< key value of new element */
2706 	   void*                 field1val,          /**< additional value of new element */
2707 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2708 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2709 	   );
2710 	
2711 	/** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
2712 	SCIP_EXPORT
2713 	void SCIPsortedvecInsertDownIntIntIntPtr(
2714 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2715 	   int*                  intarray2,          /**< int array where an element is to be inserted */
2716 	   int*                  intarray3,          /**< int array where an element is to be inserted */
2717 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2718 	   int                   keyval,             /**< key value of new element */
2719 	   int                   field1val,          /**< additional value of new element */
2720 	   int                   field2val,          /**< additional value of new element */
2721 	   void*                 field3val,          /**< additional value of new element */
2722 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2723 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2724 	   );
2725 	
2726 	/** insert a new element into four joint arrays of ints/int/ints/reals, sorted by first array in non-increasing order */
2727 	SCIP_EXPORT
2728 	void SCIPsortedvecInsertDownIntIntIntReal(
2729 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2730 	   int*                  intarray2,          /**< int array where an element is to be inserted */
2731 	   int*                  intarray3,          /**< int array where an element is to be inserted */
2732 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2733 	   int                   keyval,             /**< key value of new element */
2734 	   int                   field1val,          /**< additional value of new element */
2735 	   int                   field2val,          /**< additional value of new element */
2736 	   SCIP_Real             field3val,          /**< additional value of new element */
2737 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2738 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2739 	   );
2740 	
2741 	/** insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-increasing order */
2742 	SCIP_EXPORT
2743 	void SCIPsortedvecInsertDownIntPtrIntReal(
2744 	   int*                  intarray1,          /**< int array where an element is to be inserted */
2745 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2746 	   int*                  intarray2,          /**< int array where an element is to be inserted */
2747 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2748 	   int                   keyval,             /**< key value of new element */
2749 	   void*                 field1val,          /**< additional value of new element */
2750 	   int                   field2val,          /**< additional value of new element */
2751 	   SCIP_Real             field3val,          /**< additional value of new element */
2752 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2753 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2754 	   );
2755 	
2756 	/** insert a new element into an array of Longints, sorted in non-increasing order */
2757 	SCIP_EXPORT
2758 	void SCIPsortedvecInsertDownLong(
2759 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2760 	   SCIP_Longint          keyval,             /**< key value of new element */
2761 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2762 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2763 	   );
2764 	
2765 	/** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
2766 	SCIP_EXPORT
2767 	void SCIPsortedvecInsertDownLongPtr(
2768 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2769 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2770 	   SCIP_Longint          keyval,             /**< key value of new element */
2771 	   void*                 field1val,          /**< additional value of new element */
2772 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2773 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2774 	   );
2775 	
2776 	/** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
2777 	SCIP_EXPORT
2778 	void SCIPsortedvecInsertDownLongPtrInt(
2779 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2780 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2781 	   int*                  intarray,           /**< int array where an element is to be inserted */
2782 	   SCIP_Longint          keyval,             /**< key value of new element */
2783 	   void*                 field1val,          /**< additional value of new element */
2784 	   int                   field2val,          /**< additional value of new element */
2785 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2786 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2787 	   );
2788 	
2789 	/** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
2790 	SCIP_EXPORT
2791 	void SCIPsortedvecInsertDownLongPtrRealBool(
2792 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2793 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2794 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be inserted */
2795 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2796 	   SCIP_Longint          keyval,             /**< key value of new element */
2797 	   void*                 field1val,          /**< additional value of new element */
2798 	   SCIP_Real             field2val,          /**< additional value of new element */
2799 	   SCIP_Bool             field3val,          /**< additional value of new element */
2800 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2801 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2802 	   );
2803 	
2804 	/** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
2805 	SCIP_EXPORT
2806 	void SCIPsortedvecInsertDownLongPtrRealRealBool(
2807 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2808 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2809 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be inserted  */
2810 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
2811 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2812 	   SCIP_Longint          keyval,             /**< key value of new element */
2813 	   void*                 field1val,          /**< additional value of new element */
2814 	   SCIP_Real             field2val,          /**< additional value of new element */
2815 	   SCIP_Real             field3val,          /**< additional value of new element */
2816 	   SCIP_Bool             field4val,          /**< additional value of new element */
2817 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2818 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2819 	   );
2820 	
2821 	/** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
2822 	SCIP_EXPORT
2823 	void SCIPsortedvecInsertDownLongPtrRealRealIntBool(
2824 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2825 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2826 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be inserted  */
2827 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be inserted */
2828 	   int*                  intarray,           /**< int array where an element is to be inserted */
2829 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2830 	   SCIP_Longint          keyval,             /**< key value of new element */
2831 	   void*                 field1val,          /**< additional value of new element */
2832 	   SCIP_Real             field2val,          /**< additional value of new element */
2833 	   SCIP_Real             field3val,          /**< additional value of new element */
2834 	   int                   field4val,          /**< additional value of new element */
2835 	   SCIP_Bool             field5val,          /**< additional value of new element */
2836 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2837 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2838 	   );
2839 	
2840 	/** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
2841 	SCIP_EXPORT
2842 	void SCIPsortedvecInsertDownLongPtrPtrInt(
2843 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2844 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2845 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2846 	   int*                  intarray,           /**< int array where an element is to be inserted */
2847 	   SCIP_Longint          keyval,             /**< key value of new element */
2848 	   void*                 field1val,          /**< additional value of new element */
2849 	   void*                 field2val,          /**< additional value of new element */
2850 	   int                   field3val,          /**< additional value of new element */
2851 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2852 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2853 	   );
2854 	
2855 	/** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
2856 	SCIP_EXPORT
2857 	void SCIPsortedvecInsertDownLongPtrPtrIntInt(
2858 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2859 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2860 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2861 	   int*                  intarray1,          /**< first int array where an element is to be inserted */
2862 	   int*                  intarray2,          /**< second int array where an element is to be inserted */
2863 	   SCIP_Longint          keyval,             /**< key value of new element */
2864 	   void*                 field1val,          /**< additional value of new element */
2865 	   void*                 field2val,          /**< additional value of new element */
2866 	   int                   field3val,          /**< additional value of new element */
2867 	   int                   field4val,          /**< additional value of new element */
2868 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2869 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2870 	   );
2871 	
2872 	/** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
2873 	SCIP_EXPORT
2874 	void SCIPsortedvecInsertDownLongPtrPtrBoolInt(
2875 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be inserted */
2876 	   void**                ptrarray1,          /**< first pointer array where an element is to be inserted */
2877 	   void**                ptrarray2,          /**< second pointer array where an element is to be inserted */
2878 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2879 	   int*                  intarray,           /**< int array where an element is to be inserted */
2880 	   SCIP_Longint          keyval,             /**< key value of new element */
2881 	   void*                 field1val,          /**< additional value of new element */
2882 	   void*                 field2val,          /**< additional value of new element */
2883 	   SCIP_Bool             field3val,          /**< additional value of new element */
2884 	   int                   field4val,          /**< additional value of new element */
2885 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2886 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2887 	   );
2888 	
2889 	/** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2890 	SCIP_EXPORT
2891 	void SCIPsortedvecInsertDownPtrIntIntBoolBool(
2892 	   void**                ptrarray,           /**< pointer array to be sorted */
2893 	   int*                  intarray1,          /**< first int array to be permuted in the same way */
2894 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
2895 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
2896 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
2897 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2898 	   void*                 keyval,             /**< key value of new element */
2899 	   int                   field1val,          /**< additional value of new element */
2900 	   int                   field2val,          /**< additional value of new element */
2901 	   SCIP_Bool             field3val,          /**< additional value of new element */
2902 	   SCIP_Bool             field4val,          /**< additional value of new element */
2903 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2904 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2905 	   );
2906 	
2907 	/** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order */
2908 	SCIP_EXPORT
2909 	void SCIPsortedvecInsertDownIntPtrIntIntBoolBool(
2910 	   int*                  intarray1,          /**< int array to be sorted */
2911 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
2912 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
2913 	   int*                  intarray3,          /**< thrid int array to be permuted in the same way */
2914 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
2915 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
2916 	   int                   keyval,             /**< key value of new element */
2917 	   void*                 field1val,          /**< additional value of new element */
2918 	   int                   field2val,          /**< additional value of new element */
2919 	   int                   field3val,          /**< additional value of new element */
2920 	   SCIP_Bool             field4val,          /**< additional value of new element */
2921 	   SCIP_Bool             field5val,          /**< additional value of new element */
2922 	   int*                  len,                /**< pointer to length of arrays (will be increased by 1) */
2923 	   int*                  pos                 /**< pointer to store the insertion position, or NULL */
2924 	   );
2925 	
2926 	/* upwards position deletion */
2927 	
2928 	/** delete the element at the given position from an index array in non-decreasing order */
2929 	SCIP_EXPORT
2930 	void SCIPsortedvecDelPosInd(
2931 	   int*                  indarray,           /**< pointer to the index array where an element is to be deleted */
2932 	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
2933 	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
2934 	   int                   pos,                /**< array position of element to be deleted */
2935 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
2936 	   );
2937 	
2938 	/** delete the element at the given position from an array of pointers in non-decreasing order */
2939 	SCIP_EXPORT
2940 	void SCIPsortedvecDelPosPtr(
2941 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
2942 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2943 	   int                   pos,                /**< array position of element to be deleted */
2944 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
2945 	   );
2946 	
2947 	/** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
2948 	SCIP_EXPORT
2949 	void SCIPsortedvecDelPosPtrPtr(
2950 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
2951 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
2952 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2953 	   int                   pos,                /**< array position of element to be deleted */
2954 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
2955 	   );
2956 	
2957 	/** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
2958 	SCIP_EXPORT
2959 	void SCIPsortedvecDelPosPtrReal(
2960 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
2961 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
2962 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2963 	   int                   pos,                /**< array position of element to be deleted */
2964 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
2965 	   );
2966 	
2967 	/** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
2968 	SCIP_EXPORT
2969 	void SCIPsortedvecDelPosPtrInt(
2970 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
2971 	   int*                  intarray,           /**< int array where an element is to be deleted */
2972 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2973 	   int                   pos,                /**< array position of element to be deleted */
2974 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
2975 	   );
2976 	
2977 	/** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
2978 	SCIP_EXPORT
2979 	void SCIPsortedvecDelPosPtrBool(
2980 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
2981 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
2982 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2983 	   int                   pos,                /**< array position of element to be deleted */
2984 	   int*                  len                 /**< pointer to length of arrays (will be increased by 1) */
2985 	   );
2986 	
2987 	/** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
2988 	SCIP_EXPORT
2989 	void SCIPsortedvecDelPosPtrIntInt(
2990 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
2991 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
2992 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
2993 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
2994 	   int                   pos,                /**< array position of element to be deleted */
2995 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
2996 	   );
2997 	
2998 	/** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
2999 	SCIP_EXPORT
3000 	void SCIPsortedvecDelPosPtrRealInt(
3001 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3002 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3003 	   int*                  intarray,           /**< int array where an element is to be deleted */
3004 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3005 	   int                   pos,                /**< array position of element to be deleted */
3006 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3007 	   );
3008 	
3009 	/** delete the element at the given position from four joint arrays of pointers/RealsReals//ints, sorted by first array in non-decreasing order */
3010 	SCIP_EXPORT
3011 	void SCIPsortedvecDelPosPtrRealRealInt(
3012 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3013 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3014 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3015 	   int*                  intarray,           /**< int array where an element is to be deleted */
3016 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3017 	   int                   pos,                /**< array position of element to be deleted */
3018 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3019 	   );
3020 	
3021 	/** delete the element at the given position from four joint arrays of pointers/RealsReals/SCIP_Bools/SCIP_Bools, sorted by first array in non-decreasing order */
3022 	SCIP_EXPORT
3023 	void SCIPsortedvecDelPosPtrRealRealBoolBool(
3024 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3025 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3026 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3027 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array where an element is to be deleted */
3028 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array where an element is to be deleted */
3029 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3030 	   int                   pos,                /**< array position of element to be deleted */
3031 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3032 	   );
3033 	
3034 	/** delete the element at the given position from four joint arrays of pointers/RealsReals/ints/SCIP_Bools, sorted by first array in non-decreasing order */
3035 	SCIP_EXPORT
3036 	void SCIPsortedvecDelPosPtrRealRealIntBool(
3037 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3038 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3039 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3040 	   int*                  intarray,           /**< int array where an element is to be deleted */
3041 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3042 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3043 	   int                   pos,                /**< array position of element to be deleted */
3044 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3045 	   );
3046 	
3047 	/** delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order */
3048 	SCIP_EXPORT
3049 	void SCIPsortedvecDelPosPtrRealBool(
3050 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3051 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3052 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3053 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3054 	   int                   pos,                /**< array position of element to be deleted */
3055 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3056 	   );
3057 	
3058 	/** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
3059 	SCIP_EXPORT
3060 	void SCIPsortedvecDelPosPtrPtrInt(
3061 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3062 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3063 	   int*                  intarray,           /**< int array where an element is to be deleted */
3064 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3065 	   int                   pos,                /**< array position of element to be deleted */
3066 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3067 	   );
3068 	
3069 	/** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
3070 	SCIP_EXPORT
3071 	void SCIPsortedvecDelPosPtrPtrReal(
3072 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3073 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3074 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3075 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3076 	   int                   pos,                /**< array position of element to be deleted */
3077 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3078 	   );
3079 	
3080 	/** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
3081 	SCIP_EXPORT
3082 	void SCIPsortedvecDelPosPtrPtrIntInt(
3083 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3084 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3085 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3086 	   int*                  intarray2,          /**< second array where an element is to be deleted */
3087 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3088 	   int                   pos,                /**< array position of element to be deleted */
3089 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3090 	   );
3091 	
3092 	/** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
3093 	SCIP_EXPORT
3094 	void SCIPsortedvecDelPosPtrRealIntInt(
3095 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3096 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3097 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3098 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3099 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3100 	   int                   pos,                /**< array position of element to be deleted */
3101 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3102 	   );
3103 	
3104 	/** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
3105 	SCIP_EXPORT
3106 	void SCIPsortedvecDelPosPtrPtrRealInt(
3107 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3108 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3109 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3110 	   int*                  intarray,           /**< int array where an element is to be deleted */
3111 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3112 	   int                   pos,                /**< array position of element to be deleted */
3113 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3114 	   );
3115 	
3116 	/** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order */
3117 	SCIP_EXPORT
3118 	void SCIPsortedvecDelPosPtrPtrRealBool(
3119 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3120 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3121 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3122 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3123 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3124 	   int                   pos,                /**< array position of element to be deleted */
3125 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3126 	   );
3127 	
3128 	/** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
3129 	SCIP_EXPORT
3130 	void SCIPsortedvecDelPosPtrPtrLongInt(
3131 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3132 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3133 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3134 	   int*                  intarray,           /**< int array where an element is to be deleted */
3135 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3136 	   int                   pos,                /**< array position of element to be deleted */
3137 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3138 	   );
3139 	
3140 	/** deletes the element at the given position from five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
3141 	SCIP_EXPORT
3142 	void SCIPsortedvecDelPosPtrPtrLongIntInt(
3143 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3144 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3145 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3146 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3147 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3148 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3149 	   int                   pos,                /**< array position of element to be deleted */
3150 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3151 	   );
3152 	
3153 	/** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
3154 	SCIP_EXPORT
3155 	void SCIPsortedvecDelPosRealBoolPtr(
3156 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
3157 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
3158 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
3159 	   int                   pos,                /**< array position of element to be deleted */
3160 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3161 	   );
3162 	
3163 	/** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
3164 	SCIP_EXPORT
3165 	void SCIPsortedvecDelPosRealPtr(
3166 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3167 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3168 	   int                   pos,                /**< array position of element to be deleted */
3169 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3170 	   );
3171 	
3172 	/** delete the element at the given position from an arrays of Reals, sorted in non-decreasing order */
3173 	SCIP_EXPORT
3174 	void SCIPsortedvecDelPosReal(
3175 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3176 	   int                   pos,                /**< array position of element to be deleted */
3177 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3178 	   );
3179 	
3180 	/** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
3181 	SCIP_EXPORT
3182 	void SCIPsortedvecDelPosRealInt(
3183 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3184 	   int*                  intarray,           /**< int array where an element is to be deleted */
3185 	   int                   pos,                /**< array position of element to be deleted */
3186 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3187 	   );
3188 	
3189 	/** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
3190 	SCIP_EXPORT
3191 	void SCIPsortedvecDelPosRealIntInt(
3192 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3193 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3194 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3195 	   int                   pos,                /**< array position of element to be deleted */
3196 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3197 	   );
3198 	
3199 	/** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
3200 	SCIP_EXPORT
3201 	void SCIPsortedvecDelPosRealIntLong(
3202 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3203 	   int*                  intarray,           /**< int array where an element is to be deleted */
3204 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3205 	   int                   pos,                /**< array position of element to be deleted */
3206 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3207 	   );
3208 	
3209 	/** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
3210 	SCIP_EXPORT
3211 	void SCIPsortedvecDelPosRealIntPtr(
3212 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3213 	   int*                  intarray,           /**< int array where an element is to be deleted */
3214 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3215 	   int                   pos,                /**< array position of element to be deleted */
3216 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3217 	   );
3218 	
3219 	/** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
3220 	SCIP_EXPORT
3221 	void SCIPsortedvecDelPosRealRealPtr(
3222 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be deleted */
3223 	   SCIP_Real*            realarray2,         /**< second  SCIP_Real array where an element is to be deleted */
3224 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3225 	   int                   pos,                /**< array position of element to be deleted */
3226 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3227 	   );
3228 	
3229 	/** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
3230 	SCIP_EXPORT
3231 	void SCIPsortedvecDelPosRealPtrPtrInt(
3232 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3233 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3234 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3235 	   int*                  intarray,           /**< int array where an element is to be deleted */
3236 	   int                   pos,                /**< array position of element to be deleted */
3237 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3238 	   );
3239 	
3240 	/** delete the element at the given position from five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
3241 	SCIP_EXPORT
3242 	void SCIPsortedvecDelPosRealPtrPtrIntInt(
3243 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3244 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3245 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3246 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3247 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3248 	   int                   pos,                /**< array position of element to be deleted */
3249 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3250 	   );
3251 	
3252 	/** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
3253 	SCIP_EXPORT
3254 	void SCIPsortedvecDelPosRealLongRealInt(
3255 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3256 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3257 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3258 	   int*                  intarray,           /**< int array  where an element is to be deleted */
3259 	   int                   pos,                /**< array position of element to be deleted */
3260 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3261 	   );
3262 	
3263 	/** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
3264 	SCIP_EXPORT
3265 	void SCIPsortedvecDelPosRealRealIntInt(
3266 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3267 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3268 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3269 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3270 	   int                   pos,                /**< array position of element to be deleted */
3271 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3272 	   );
3273 	
3274 	/** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
3275 	SCIP_EXPORT
3276 	void SCIPsortedvecDelPosRealRealRealInt(
3277 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3278 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3279 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3280 	   int*                  intarray,           /**< int array where an element is to be deleted */
3281 	   int                   pos,                /**< array position of element to be deleted */
3282 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3283 	   );
3284 	
3285 	/** delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
3286 	SCIP_EXPORT
3287 	void SCIPsortedvecDelPosRealRealRealPtr(
3288 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3289 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3290 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3291 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3292 	   int                   pos,                /**< array position of element to be deleted */
3293 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3294 	   );
3295 	
3296 	/** delete the element at the given position from five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
3297 	SCIP_EXPORT
3298 	void SCIPsortedvecDelPosRealRealRealBoolPtr(
3299 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3300 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3301 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3302 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3303 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3304 	   int                   pos,                /**< array position of element to be deleted */
3305 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3306 	   );
3307 	
3308 	/** delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order */
3309 	SCIP_EXPORT
3310 	void SCIPsortedvecDelPosRealRealRealBoolBoolPtr(
3311 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3312 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3313 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3314 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array where an element is to be deleted */
3315 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array where an element is to be deleted */
3316 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3317 	   int                   pos,                /**< array position of element to be deleted */
3318 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3319 	   );
3320 	
3321 	/** delete the element at the given position from an array of ints in non-decreasing order */
3322 	SCIP_EXPORT
3323 	void SCIPsortedvecDelPosInt(
3324 	   int*                  intarray,           /**< int array where an element is to be deleted */
3325 	   int                   pos,                /**< array position of element to be deleted */
3326 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3327 	   );
3328 	
3329 	/** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order */
3330 	SCIP_EXPORT
3331 	void SCIPsortedvecDelPosIntInt(
3332 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3333 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3334 	   int                   pos,                /**< array position of element to be deleted */
3335 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3336 	   );
3337 	
3338 	/** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order */
3339 	SCIP_EXPORT
3340 	void SCIPsortedvecDelPosIntReal(
3341 	   int*                  intarray,           /**< int array where an element is to be deleted */
3342 	   SCIP_Real*            realarray,          /**< real array where an element is to be deleted */
3343 	   int                   pos,                /**< array position of element to be deleted */
3344 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3345 	   );
3346 	
3347 	/** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
3348 	SCIP_EXPORT
3349 	void SCIPsortedvecDelPosIntIntInt(
3350 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3351 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3352 	   int*                  intarray3,          /**< third int array where an element is to be deleted */
3353 	   int                   pos,                /**< array position of element to be deleted */
3354 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3355 	   );
3356 	
3357 	/** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
3358 	SCIP_EXPORT
3359 	void SCIPsortedvecDelPosIntIntLong(
3360 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3361 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3362 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3363 	   int                   pos,                /**< array position of element to be deleted */
3364 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3365 	   );
3366 	
3367 	/** delete the element at the given position from three joint arrays of ints/SCIP_Real/SCIP_Longint, sorted by first array in non-decreasing order */
3368 	SCIP_EXPORT
3369 	void SCIPsortedvecDelPosIntRealLong(
3370 	   int*                  intarray,           /**< int array where an element is to be deleted */
3371 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3372 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3373 	   int                   pos,                /**< array position of element to be deleted */
3374 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3375 	   );
3376 	
3377 	/** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
3378 	SCIP_EXPORT
3379 	void SCIPsortedvecDelPosIntIntPtr(
3380 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3381 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3382 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3383 	   int                   pos,                /**< array position of element to be deleted */
3384 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3385 	   );
3386 	
3387 	/** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
3388 	SCIP_EXPORT
3389 	void SCIPsortedvecDelPosIntIntReal(
3390 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3391 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3392 	   SCIP_Real*            realarray,          /**< real array where an element is to be deleted */
3393 	   int                   pos,                /**< array position of element to be deleted */
3394 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3395 	   );
3396 	
3397 	/** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
3398 	SCIP_EXPORT
3399 	void SCIPsortedvecDelPosIntPtr(
3400 	   int*                  intarray,           /**< int array where an element is to be deleted */
3401 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3402 	   int                   pos,                /**< array position of element to be deleted */
3403 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3404 	   );
3405 	
3406 	/** delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
3407 	SCIP_EXPORT
3408 	void SCIPsortedvecDelPosIntPtrReal(
3409 	   int*                  intarray,           /**< int array where an element is to be deleted */
3410 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3411 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3412 	   int                   pos,                /**< array position of element to be deleted */
3413 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3414 	   );
3415 	
3416 	/** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
3417 	SCIP_EXPORT
3418 	void SCIPsortedvecDelPosIntIntIntPtr(
3419 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3420 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3421 	   int*                  intarray3,          /**< int array where an element is to be deleted */
3422 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3423 	   int                   pos,                /**< array position of element to be deleted */
3424 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3425 	   );
3426 	
3427 	/** delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
3428 	SCIP_EXPORT
3429 	void SCIPsortedvecDelPosIntIntIntReal(
3430 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3431 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3432 	   int*                  intarray3,          /**< int array where an element is to be deleted */
3433 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3434 	   int                   pos,                /**< array position of element to be deleted */
3435 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3436 	   );
3437 	
3438 	/** delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
3439 	SCIP_EXPORT
3440 	void SCIPsortedvecDelPosIntPtrIntReal(
3441 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3442 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3443 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3444 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3445 	   int                   pos,                /**< array position of element to be deleted */
3446 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3447 	   );
3448 	
3449 	/** delete the element at the given position from an array of Longints, sorted by in non-decreasing order */
3450 	SCIP_EXPORT
3451 	void SCIPsortedvecDelPosLong(
3452 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3453 	   int                   pos,                /**< array position of element to be deleted */
3454 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3455 	   );
3456 	
3457 	/** delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
3458 	SCIP_EXPORT
3459 	void SCIPsortedvecDelPosLongPtr(
3460 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3461 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3462 	   int                   pos,                /**< array position of element to be deleted */
3463 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3464 	   );
3465 	
3466 	/** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order */
3467 	SCIP_EXPORT
3468 	void SCIPsortedvecDelPosLongPtrInt(
3469 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3470 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3471 	   int*                  intarray,           /**< int array where an element is to be deleted */
3472 	   int                   pos,                /**< array position of element to be deleted */
3473 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3474 	   );
3475 	
3476 	/** delete the element at the given position from four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
3477 	SCIP_EXPORT
3478 	void SCIPsortedvecDelPosLongPtrRealBool(
3479 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3480 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3481 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3482 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3483 	   int                   pos,                /**< array position of element to be deleted */
3484 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3485 	   );
3486 	
3487 	/** delete the element at the given position from five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
3488 	SCIP_EXPORT
3489 	void SCIPsortedvecDelPosLongPtrRealRealBool(
3490 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3491 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3492 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3493 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
3494 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3495 	   int                   pos,                /**< array position of element to be deleted */
3496 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3497 	   );
3498 	
3499 	/** delete the element at the given position from six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
3500 	SCIP_EXPORT
3501 	void SCIPsortedvecDelPosLongPtrRealRealIntBool(
3502 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3503 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3504 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3505 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
3506 	   int*                  intarray,           /**< int array where an element is to be deleted */
3507 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3508 	   int                   pos,                /**< array position of element to be deleted */
3509 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3510 	   );
3511 	
3512 	/** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
3513 	SCIP_EXPORT
3514 	void SCIPsortedvecDelPosLongPtrPtrInt(
3515 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3516 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3517 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3518 	   int*                  intarray,           /**< int array where an element is to be deleted */
3519 	   int                   pos,                /**< array position of element to be deleted */
3520 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3521 	   );
3522 	
3523 	/** delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
3524 	SCIP_EXPORT
3525 	void SCIPsortedvecDelPosLongPtrPtrIntInt(
3526 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3527 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3528 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3529 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3530 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3531 	   int                   pos,                /**< array position of element to be deleted */
3532 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3533 	   );
3534 	
3535 	/** delete the element at the given position from five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
3536 	SCIP_EXPORT
3537 	void SCIPsortedvecDelPosLongPtrPtrBoolInt(
3538 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3539 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3540 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3541 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3542 	   int*                  intarray,           /**< int array where an element is to be deleted */
3543 	   int                   pos,                /**< array position of element to be deleted */
3544 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3545 	   );
3546 	
3547 	/** delete the element at the given position from five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
3548 	SCIP_EXPORT
3549 	void SCIPsortedvecDelPosPtrIntIntBoolBool(
3550 	   void**                ptrarray,           /**< pointer array to be sorted */
3551 	   int*                  intarray1,          /**< first int array to be permuted in the same way */
3552 	   int*                  intarray2,          /**< second 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 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3556 	   int                   pos,                /**< array position of element to be deleted */
3557 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3558 	   );
3559 	
3560 	/** delete the element at the given position from six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
3561 	SCIP_EXPORT
3562 	void SCIPsortedvecDelPosIntPtrIntIntBoolBool(
3563 	   int*                  intarray1,          /**< int array to be sorted */
3564 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
3565 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
3566 	   int*                  intarray3,          /**< thrid int array to be permuted in the same way */
3567 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
3568 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
3569 	   int                   pos,                /**< array position of element to be deleted */
3570 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3571 	   );
3572 	
3573 	/* downwards position deletion */
3574 	
3575 	/** delete the element at the given position from an index array in non-increasing order */
3576 	SCIP_EXPORT
3577 	void SCIPsortedvecDelPosDownInd(
3578 	   int*                  indarray,           /**< pointer to the index array where an element is to be deleted */
3579 	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
3580 	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
3581 	   int                   pos,                /**< array position of element to be deleted */
3582 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3583 	   );
3584 	
3585 	/** delete the element at the given position from an array of pointers in non-increasing order */
3586 	SCIP_EXPORT
3587 	void SCIPsortedvecDelPosDownPtr(
3588 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3589 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3590 	   int                   pos,                /**< array position of element to be deleted */
3591 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3592 	   );
3593 	
3594 	/** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
3595 	SCIP_EXPORT
3596 	void SCIPsortedvecDelPosDownPtrPtr(
3597 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3598 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3599 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3600 	   int                   pos,                /**< array position of element to be deleted */
3601 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3602 	   );
3603 	
3604 	/** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
3605 	SCIP_EXPORT
3606 	void SCIPsortedvecDelPosDownPtrReal(
3607 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3608 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3609 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3610 	   int                   pos,                /**< array position of element to be deleted */
3611 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3612 	   );
3613 	
3614 	/** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-increasing order */
3615 	SCIP_EXPORT
3616 	void SCIPsortedvecDelPosDownPtrInt(
3617 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3618 	   int*                  intarray,           /**< int array where an element is to be deleted */
3619 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3620 	   int                   pos,                /**< array position of element to be deleted */
3621 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3622 	   );
3623 	
3624 	/** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
3625 	SCIP_EXPORT
3626 	void SCIPsortedvecDelPosDownPtrBool(
3627 	   void**                ptrarray,           /**< pointer array where an element is to be inserted */
3628 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be inserted */
3629 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3630 	   int                   pos,                /**< array position of element to be deleted */
3631 	   int*                  len                 /**< pointer to length of arrays (will be increased by 1) */
3632 	   );
3633 	
3634 	/** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
3635 	SCIP_EXPORT
3636 	void SCIPsortedvecDelPosDownPtrIntInt(
3637 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3638 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3639 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3640 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3641 	   int                   pos,                /**< array position of element to be deleted */
3642 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3643 	   );
3644 	
3645 	/** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
3646 	SCIP_EXPORT
3647 	void SCIPsortedvecDelPosDownPtrRealInt(
3648 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3649 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3650 	   int*                  intarray,           /**< int array where an element is to be deleted */
3651 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3652 	   int                   pos,                /**< array position of element to be deleted */
3653 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3654 	   );
3655 	
3656 	/** delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order */
3657 	SCIP_EXPORT
3658 	void SCIPsortedvecDelPosDownPtrRealBool(
3659 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3660 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3661 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3662 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3663 	   int                   pos,                /**< array position of element to be deleted */
3664 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3665 	   );
3666 	
3667 	/** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
3668 	SCIP_EXPORT
3669 	void SCIPsortedvecDelPosDownPtrPtrInt(
3670 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3671 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3672 	   int*                  intarray,           /**< int array where an element is to be deleted */
3673 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3674 	   int                   pos,                /**< array position of element to be deleted */
3675 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3676 	   );
3677 	
3678 	/** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
3679 	SCIP_EXPORT
3680 	void SCIPsortedvecDelPosDownPtrPtrReal(
3681 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3682 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3683 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3684 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3685 	   int                   pos,                /**< array position of element to be deleted */
3686 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3687 	   );
3688 	
3689 	/** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3690 	SCIP_EXPORT
3691 	void SCIPsortedvecDelPosDownPtrPtrIntInt(
3692 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3693 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3694 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3695 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3696 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3697 	   int                   pos,                /**< array position of element to be deleted */
3698 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3699 	   );
3700 	
3701 	/** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
3702 	SCIP_EXPORT
3703 	void SCIPsortedvecDelPosDownPtrRealIntInt(
3704 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3705 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3706 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3707 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3708 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3709 	   int                   pos,                /**< array position of element to be deleted */
3710 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3711 	   );
3712 	
3713 	/** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
3714 	SCIP_EXPORT
3715 	void SCIPsortedvecDelPosDownPtrPtrRealInt(
3716 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3717 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3718 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3719 	   int*                  intarray,           /**< int array where an element is to be deleted */
3720 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3721 	   int                   pos,                /**< array position of element to be deleted */
3722 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3723 	   );
3724 	
3725 	/** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order */
3726 	SCIP_EXPORT
3727 	void SCIPsortedvecDelPosDownPtrPtrRealBool(
3728 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3729 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3730 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3731 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3732 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3733 	   int                   pos,                /**< array position of element to be deleted */
3734 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3735 	   );
3736 	
3737 	/** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
3738 	SCIP_EXPORT
3739 	void SCIPsortedvecDelPosDownPtrPtrLongInt(
3740 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3741 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3742 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3743 	   int*                  intarray,           /**< int array where an element is to be deleted */
3744 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3745 	   int                   pos,                /**< array position of element to be deleted */
3746 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3747 	   );
3748 	
3749 	/** deletes the element at the given position from five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
3750 	SCIP_EXPORT
3751 	void SCIPsortedvecDelPosDownPtrPtrLongIntInt(
3752 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3753 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3754 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3755 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3756 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3757 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
3758 	   int                   pos,                /**< array position of element to be deleted */
3759 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3760 	   );
3761 	
3762 	/** delete the element at the given position from an array of Reals, sorted in non-increasing order */
3763 	SCIP_EXPORT
3764 	void SCIPsortedvecDelPosDownReal(
3765 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3766 	   int                   pos,                /**< array position of element to be deleted */
3767 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3768 	   );
3769 	
3770 	
3771 	/** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
3772 	SCIP_EXPORT
3773 	void SCIPsortedvecDelPosDownRealBoolPtr(
3774 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be sorted */
3775 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array to be permuted in the same way */
3776 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
3777 	   int                   pos,                /**< array position of element to be deleted */
3778 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3779 	   );
3780 	
3781 	/** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3782 	SCIP_EXPORT
3783 	void SCIPsortedvecDelPosDownRealPtr(
3784 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3785 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3786 	   int                   pos,                /**< array position of element to be deleted */
3787 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3788 	   );
3789 	
3790 	/** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order */
3791 	SCIP_EXPORT
3792 	void SCIPsortedvecDelPosDownRealInt(
3793 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3794 	   int*                  intarray,           /**< pointer array where an element is to be deleted */
3795 	   int                   pos,                /**< array position of element to be deleted */
3796 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3797 	   );
3798 	
3799 	/** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order */
3800 	SCIP_EXPORT
3801 	void SCIPsortedvecDelPosDownRealIntInt(
3802 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3803 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
3804 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3805 	   int                   pos,                /**< array position of element to be deleted */
3806 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3807 	   );
3808 	
3809 	/** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
3810 	SCIP_EXPORT
3811 	void SCIPsortedvecDelPosDownRealIntLong(
3812 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3813 	   int*                  intarray,           /**< int array where an element is to be deleted */
3814 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3815 	   int                   pos,                /**< array position of element to be deleted */
3816 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3817 	   );
3818 	
3819 	/** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
3820 	SCIP_EXPORT
3821 	void SCIPsortedvecDelPosDownRealIntPtr(
3822 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
3823 	   int*                  intarray,           /**< int array where an element is to be deleted */
3824 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3825 	   int                   pos,                /**< array position of element to be deleted */
3826 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3827 	   );
3828 	
3829 	/** delete the element at the given position from three joint arrays of Reals/Reals/ints, sorted by first array in non-increasing order */
3830 	SCIP_EXPORT
3831 	void SCIPsortedvecDelPosDownRealRealInt(
3832 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be deleted */
3833 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
3834 	   int*                  intarray,           /**< integer array where an element is to be deleted */
3835 	   int                   pos,                /**< array position of element to be deleted */
3836 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3837 	   );
3838 	
3839 	/** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
3840 	SCIP_EXPORT
3841 	void SCIPsortedvecDelPosDownRealRealPtr(
3842 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be deleted */
3843 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
3844 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3845 	   int                   pos,                /**< array position of element to be deleted */
3846 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3847 	   );
3848 	
3849 	/** delete the element at the given position from three joint arrays of Reals/Reals/Pointer/Pointer, sorted by first array in non-increasing order */
3850 	SCIP_EXPORT
3851 	void SCIPsortedvecDelPosDownRealRealPtrPtr(
3852 	   SCIP_Real*            realarray1,         /**< first SCIP_Real array where an element is to be deleted */
3853 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
3854 	   void**                ptrarray1,          /**< pointer array where an element is to be deleted */
3855 	   void**                ptrarray2,          /**< pointer array where an element is to be deleted */
3856 	   int                   pos,                /**< array position of element to be deleted */
3857 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3858 	   );
3859 	
3860 	/** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
3861 	SCIP_EXPORT
3862 	void SCIPsortedvecDelPosDownRealPtrPtr(
3863 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3864 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3865 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3866 	   int                   pos,                /**< array position of element to be deleted */
3867 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3868 	   );
3869 	
3870 	/** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
3871 	SCIP_EXPORT
3872 	void SCIPsortedvecDelPosDownRealPtrPtrInt(
3873 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3874 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3875 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3876 	   int*                  intarray,           /**< int array where an element is to be deleted */
3877 	   int                   pos,                /**< array position of element to be deleted */
3878 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3879 	   );
3880 	
3881 	/** delete the element at the given position from five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3882 	SCIP_EXPORT
3883 	void SCIPsortedvecDelPosDownRealPtrPtrIntInt(
3884 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
3885 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
3886 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
3887 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3888 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3889 	   int                   pos,                /**< array position of element to be deleted */
3890 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3891 	   );
3892 	
3893 	/** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-increasing order */
3894 	SCIP_EXPORT
3895 	void SCIPsortedvecDelPosDownRealLongRealInt(
3896 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3897 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
3898 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3899 	   int*                  intarray,           /**< int array where an element is to be deleted */
3900 	   int                   pos,                /**< array position of element to be deleted */
3901 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3902 	   );
3903 	
3904 	/** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
3905 	SCIP_EXPORT
3906 	void SCIPsortedvecDelPosDownRealRealIntInt(
3907 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3908 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3909 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3910 	   int*                  intarray2,          /**< int array where an element is to be deleted */
3911 	   int                   pos,                /**< array position of element to be deleted */
3912 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3913 	   );
3914 	
3915 	/** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
3916 	SCIP_EXPORT
3917 	void SCIPsortedvecDelPosDownRealRealRealInt(
3918 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3919 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3920 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3921 	   int*                  intarray,           /**< int array where an element is to be deleted */
3922 	   int                   pos,                /**< array position of element to be deleted */
3923 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3924 	   );
3925 	
3926 	/** delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
3927 	SCIP_EXPORT
3928 	void SCIPsortedvecDelPosDownRealRealRealPtr(
3929 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3930 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3931 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3932 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3933 	   int                   pos,                /**< array position of element to be deleted */
3934 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3935 	   );
3936 	
3937 	/** delete the element at the given position from five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
3938 	SCIP_EXPORT
3939 	void SCIPsortedvecDelPosDownRealRealRealBoolPtr(
3940 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3941 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3942 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3943 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
3944 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3945 	   int                   pos,                /**< array position of element to be deleted */
3946 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3947 	   );
3948 	
3949 	/** delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order */
3950 	SCIP_EXPORT
3951 	void SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr(
3952 	   SCIP_Real*            realarray1,         /**< SCIP_Real array where an element is to be deleted */
3953 	   SCIP_Real*            realarray2,         /**< SCIP_Real array where an element is to be deleted */
3954 	   SCIP_Real*            realarray3,         /**< SCIP_Real array where an element is to be deleted */
3955 	   SCIP_Bool*            boolarray1,         /**< SCIP_Bool array where an element is to be deleted */
3956 	   SCIP_Bool*            boolarray2,         /**< SCIP_Bool array where an element is to be deleted */
3957 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
3958 	   int                   pos,                /**< array position of element to be deleted */
3959 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3960 	   );
3961 	
3962 	/** delete the element at the given position from an array of ints in non-increasing order */
3963 	SCIP_EXPORT
3964 	void SCIPsortedvecDelPosDownInt(
3965 	   int*                  intarray,           /**< int array where an element is to be deleted */
3966 	   int                   pos,                /**< array position of element to be deleted */
3967 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3968 	   );
3969 	
3970 	/** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-increasing order */
3971 	SCIP_EXPORT
3972 	void SCIPsortedvecDelPosDownIntInt(
3973 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3974 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3975 	   int                   pos,                /**< array position of element to be deleted */
3976 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3977 	   );
3978 	
3979 	/** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-increasing order */
3980 	SCIP_EXPORT
3981 	void SCIPsortedvecDelPosDownIntReal(
3982 	   int*                  intarray,           /**< int array where an element is to be deleted */
3983 	   SCIP_Real*            realarray,          /**< real array where an element is to be deleted */
3984 	   int                   pos,                /**< array position of element to be deleted */
3985 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3986 	   );
3987 	
3988 	/** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
3989 	SCIP_EXPORT
3990 	void SCIPsortedvecDelPosDownIntIntInt(
3991 	   int*                  intarray1,          /**< int array where an element is to be deleted */
3992 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
3993 	   int*                  intarray3,          /**< third int array where an element is to be deleted */
3994 	   int                   pos,                /**< array position of element to be deleted */
3995 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
3996 	   );
3997 	
3998 	/** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
3999 	SCIP_EXPORT
4000 	void SCIPsortedvecDelPosDownIntIntLong(
4001 	   int*                  intarray1,          /**< int array where an element is to be deleted */
4002 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
4003 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4004 	   int                   pos,                /**< array position of element to be deleted */
4005 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4006 	   );
4007 	
4008 	/** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
4009 	SCIP_EXPORT
4010 	void SCIPsortedvecDelPosDownIntIntPtr(
4011 	   int*                  intarray1,          /**< int array where an element is to be deleted */
4012 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
4013 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4014 	   int                   pos,                /**< array position of element to be deleted */
4015 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4016 	   );
4017 	
4018 	/** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
4019 	SCIP_EXPORT
4020 	void SCIPsortedvecDelPosDownIntIntReal(
4021 	   int*                  intarray1,          /**< int array where an element is to be deleted */
4022 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
4023 	   SCIP_Real*            realarray,          /**< real array where an element is to be deleted */
4024 	   int                   pos,                /**< array position of element to be deleted */
4025 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4026 	   );
4027 	
4028 	/** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-increasing order */
4029 	SCIP_EXPORT
4030 	void SCIPsortedvecDelPosDownIntPtr(
4031 	   int*                  intarray,           /**< int array where an element is to be deleted */
4032 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4033 	   int                   pos,                /**< array position of element to be deleted */
4034 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4035 	   );
4036 	
4037 	/** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
4038 	SCIP_EXPORT
4039 	void SCIPsortedvecDelPosDownIntIntIntPtr(
4040 	   int*                  intarray1,          /**< int array where an element is to be deleted */
4041 	   int*                  intarray2,          /**< int array where an element is to be deleted */
4042 	   int*                  intarray3,          /**< int array where an element is to be deleted */
4043 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4044 	   int                   pos,                /**< array position of element to be deleted */
4045 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4046 	   );
4047 	
4048 	/** delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
4049 	SCIP_EXPORT
4050 	void SCIPsortedvecDelPosDownIntIntIntReal(
4051 	   int*                  intarray1,          /**< int array where an element is to be deleted */
4052 	   int*                  intarray2,          /**< int array where an element is to be deleted */
4053 	   int*                  intarray3,          /**< int array where an element is to be deleted */
4054 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
4055 	   int                   pos,                /**< array position of element to be deleted */
4056 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4057 	   );
4058 	
4059 	/** delete the element at the given position from four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order */
4060 	SCIP_EXPORT
4061 	void SCIPsortedvecDelPosDownIntPtrIntReal(
4062 	   int*                  intarray1,          /**< int array where an element is to be deleted */
4063 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4064 	   int*                  intarray2,          /**< int array where an element is to be deleted */
4065 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
4066 	   int                   pos,                /**< array position of element to be deleted */
4067 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4068 	   );
4069 	
4070 	/** delete the element at the given position from an array of Longints, sorted in non-increasing order */
4071 	SCIP_EXPORT
4072 	void SCIPsortedvecDelPosDownLong(
4073 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4074 	   int                   pos,                /**< array position of element to be deleted */
4075 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4076 	   );
4077 	
4078 	/** delete the element at the given position from two arrays of Long/pointer, sorted by the first array in non-increasing order */
4079 	SCIP_EXPORT
4080 	void SCIPsortedvecDelPosDownLongPtr(
4081 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4082 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4083 	   int                   pos,                /**< array position of element to be deleted */
4084 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4085 	   );
4086 	
4087 	/** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-increasing order */
4088 	SCIP_EXPORT
4089 	void SCIPsortedvecDelPosDownLongPtrInt(
4090 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4091 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4092 	   int*                  intarray,           /**< int array where an element is to be deleted */
4093 	   int                   pos,                /**< array position of element to be deleted */
4094 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4095 	   );
4096 	
4097 	/** delete the element at the given position from three joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
4098 	SCIP_EXPORT
4099 	void SCIPsortedvecDelPosDownLongPtrRealBool(
4100 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4101 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4102 	   SCIP_Real*            realarray,          /**< SCIP_Real array where an element is to be deleted */
4103 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
4104 	   int                   pos,                /**< array position of element to be deleted */
4105 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4106 	   );
4107 	
4108 	/** delete the element at the given position from five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
4109 	SCIP_EXPORT
4110 	void SCIPsortedvecDelPosDownLongPtrRealRealBool(
4111 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4112 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4113 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
4114 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
4115 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
4116 	   int                   pos,                /**< array position of element to be deleted */
4117 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4118 	   );
4119 	
4120 	/** delete the element at the given position from six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
4121 	SCIP_EXPORT
4122 	void SCIPsortedvecDelPosDownLongPtrRealRealIntBool(
4123 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4124 	   void**                ptrarray,           /**< pointer array where an element is to be deleted */
4125 	   SCIP_Real*            realarray,          /**< first SCIP_Real array where an element is to be deleted */
4126 	   SCIP_Real*            realarray2,         /**< second SCIP_Real array where an element is to be deleted */
4127 	   int*                  intarray,           /**< int array where an element is to be deleted */
4128 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
4129 	   int                   pos,                /**< array position of element to be deleted */
4130 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4131 	   );
4132 	
4133 	
4134 	/** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
4135 	SCIP_EXPORT
4136 	void SCIPsortedvecDelPosDownLongPtrPtrInt(
4137 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4138 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
4139 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
4140 	   int*                  intarray,           /**< int array where an element is to be deleted */
4141 	   int                   pos,                /**< array position of element to be deleted */
4142 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4143 	   );
4144 	
4145 	/** delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
4146 	SCIP_EXPORT
4147 	void SCIPsortedvecDelPosDownLongPtrPtrIntInt(
4148 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4149 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
4150 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
4151 	   int*                  intarray1,          /**< first int array where an element is to be deleted */
4152 	   int*                  intarray2,          /**< second int array where an element is to be deleted */
4153 	   int                   pos,                /**< array position of element to be deleted */
4154 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4155 	   );
4156 	
4157 	/** delete the element at the given position from five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
4158 	SCIP_EXPORT
4159 	void SCIPsortedvecDelPosDownLongPtrPtrBoolInt(
4160 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array where an element is to be deleted */
4161 	   void**                ptrarray1,          /**< first pointer array where an element is to be deleted */
4162 	   void**                ptrarray2,          /**< second pointer array where an element is to be deleted */
4163 	   SCIP_Bool*            boolarray,          /**< SCIP_Bool array where an element is to be deleted */
4164 	   int*                  intarray,           /**< int array where an element is to be deleted */
4165 	   int                   pos,                /**< array position of element to be deleted */
4166 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4167 	   );
4168 	
4169 	/** delete the element at the given position from five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
4170 	SCIP_EXPORT
4171 	void SCIPsortedvecDelPosDownPtrIntIntBoolBool(
4172 	   void**                ptrarray,           /**< pointer array to be sorted */
4173 	   int*                  intarray1,          /**< first int array to be permuted in the same way */
4174 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
4175 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
4176 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
4177 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
4178 	   int                   pos,                /**< array position of element to be deleted */
4179 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4180 	   );
4181 	
4182 	/** delete the element at the given position from six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
4183 	SCIP_EXPORT
4184 	void SCIPsortedvecDelPosDownIntPtrIntIntBoolBool(
4185 	   int*                  intarray1,          /**< int array to be sorted */
4186 	   void**                ptrarray,           /**< pointer array to be permuted in the same way */
4187 	   int*                  intarray2,          /**< second int array to be permuted in the same way */
4188 	   int*                  intarray3,          /**< thrid int array to be permuted in the same way */
4189 	   SCIP_Bool*            boolarray1,         /**< first SCIP_Bool array to be permuted in the same way */
4190 	   SCIP_Bool*            boolarray2,         /**< second SCIP_Bool array to be permuted in the same way */
4191 	   int                   pos,                /**< array position of element to be deleted */
4192 	   int*                  len                 /**< pointer to length of arrays (will be decreased by 1) */
4193 	   );
4194 	
4195 	
4196 	/* upwards binary search */
4197 	
4198 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4199 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4200 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4201 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4202 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4203 	 */
4204 	SCIP_EXPORT
4205 	SCIP_Bool SCIPsortedvecFindInd(
4206 	   int*                  indarray,           /**< index array to be searched */
4207 	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
4208 	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
4209 	   int                   val,                /**< value to search */
4210 	   int                   len,                /**< length of array */
4211 	   int*                  pos                 /**< pointer to store position of element */
4212 	   );
4213 	
4214 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4215 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4216 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4217 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4218 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4219 	 */
4220 	SCIP_EXPORT
4221 	SCIP_Bool SCIPsortedvecFindPtr(
4222 	   void**                ptrarray,           /**< pointer array to be searched */
4223 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
4224 	   void*                 val,                /**< value to search */
4225 	   int                   len,                /**< length of array */
4226 	   int*                  pos                 /**< pointer to store position of element */
4227 	   );
4228 	
4229 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4230 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4231 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4232 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4233 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4234 	 */
4235 	SCIP_EXPORT
4236 	SCIP_Bool SCIPsortedvecFindReal(
4237 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be searched */
4238 	   SCIP_Real             val,                /**< value to search */
4239 	   int                   len,                /**< length of array */
4240 	   int*                  pos                 /**< pointer to store position of element */
4241 	   );
4242 	
4243 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4244 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4245 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4246 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4247 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4248 	 */
4249 	SCIP_EXPORT
4250 	SCIP_Bool SCIPsortedvecFindInt(
4251 	   int*                  intarray,           /**< int array to be searched */
4252 	   int                   val,                /**< value to search */
4253 	   int                   len,                /**< length of array */
4254 	   int*                  pos                 /**< pointer to store position of element */
4255 	   );
4256 	
4257 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4258 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4259 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4260 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4261 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4262 	 */
4263 	SCIP_EXPORT
4264 	SCIP_Bool SCIPsortedvecFindLong(
4265 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be searched */
4266 	   SCIP_Longint          val,                /**< value to search */
4267 	   int                   len,                /**< length of array */
4268 	   int*                  pos                 /**< pointer to store position of element */
4269 	   );
4270 	
4271 	
4272 	/* downwards binary search */
4273 	
4274 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4275 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4276 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4277 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4278 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4279 	 */
4280 	SCIP_EXPORT
4281 	SCIP_Bool SCIPsortedvecFindDownInd(
4282 	   int*                  indarray,           /**< index array to be searched */
4283 	   SCIP_DECL_SORTINDCOMP((*indcomp)),        /**< data element comparator */
4284 	   void*                 dataptr,            /**< pointer to data field that is given to the external compare method */
4285 	   int                   val,                /**< value to search */
4286 	   int                   len,                /**< length of array */
4287 	   int*                  pos                 /**< pointer to store position of element */
4288 	   );
4289 	
4290 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4291 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4292 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4293 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4294 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4295 	 */
4296 	SCIP_EXPORT
4297 	SCIP_Bool SCIPsortedvecFindDownPtr(
4298 	   void**                ptrarray,           /**< pointer array to be searched */
4299 	   SCIP_DECL_SORTPTRCOMP((*ptrcomp)),        /**< data element comparator */
4300 	   void*                 val,                /**< value to search */
4301 	   int                   len,                /**< length of array */
4302 	   int*                  pos                 /**< pointer to store position of element */
4303 	   );
4304 	
4305 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4306 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4307 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4308 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4309 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4310 	 */
4311 	SCIP_EXPORT
4312 	SCIP_Bool SCIPsortedvecFindDownReal(
4313 	   SCIP_Real*            realarray,          /**< SCIP_Real array to be searched */
4314 	   SCIP_Real             val,                /**< value to search */
4315 	   int                   len,                /**< length of array */
4316 	   int*                  pos                 /**< pointer to store position of element */
4317 	   );
4318 	
4319 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4320 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4321 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4322 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4323 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4324 	 */
4325 	SCIP_EXPORT
4326 	SCIP_Bool SCIPsortedvecFindDownInt(
4327 	   int*                  intarray,           /**< int array to be searched */
4328 	   int                   val,                /**< value to search */
4329 	   int                   len,                /**< length of array */
4330 	   int*                  pos                 /**< pointer to store position of element */
4331 	   );
4332 	
4333 	/** Finds the position at which 'val' is located in the sorted vector by binary search.
4334 	 *  If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4335 	 *  If the element does not exist, the method returns FALSE and stores the position of the element that follows
4336 	 *  'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4337 	 *  Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4338 	 */
4339 	SCIP_EXPORT
4340 	SCIP_Bool SCIPsortedvecFindDownLong(
4341 	   SCIP_Longint*         longarray,          /**< SCIP_Longint array to be searched */
4342 	   SCIP_Longint          val,                /**< value to search */
4343 	   int                   len,                /**< length of array */
4344 	   int*                  pos                 /**< pointer to store position of element */
4345 	   );
4346 	
4347 	/**@} */
4348 	
4349 	#ifdef __cplusplus
4350 	}
4351 	#endif
4352 	
4353 	#endif
4354