Scippy

SCIP

Solving Constraint Integer Programs

pub_misc.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2014 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file pub_misc.h
17  * @brief public data structures and miscellaneous methods
18  * @author Tobias Achterberg
19  * @author Stefan Heinz
20  * @author Michael Winkler
21  *
22  * This file contains a bunch of data structures and miscellaneous methods:
23  *
24  * - \ref DataStructures "Data structures"
25  * - \ref MiscellaneousMethods "Miscellaneous Methods"
26  */
27 
28 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
29 
30 #ifndef __SCIP_PUB_MISC_H__
31 #define __SCIP_PUB_MISC_H__
32 
33 /* on SunOS, the function finite(a) (for the SCIPisFinite macro below) is declared in ieeefp.h */
34 #ifdef __sun
35 #include <ieeefp.h>
36 #endif
37 #include <math.h>
38 
39 #include "scip/def.h"
40 #include "blockmemshell/memory.h"
41 #include "scip/type_retcode.h"
42 #include "scip/type_misc.h"
43 #include "scip/type_message.h"
44 #include "scip/type_var.h"
45 
46 /* in optimized mode some of the function are handled via defines, for that the structs are needed */
47 #ifdef NDEBUG
48 #include "scip/struct_misc.h"
49 #endif
50 
51 #ifdef __cplusplus
52 extern "C" {
53 #endif
54 
55 /*
56  * GML graphical printing methods
57  * For a detailed format decription see http://docs.yworks.com/yfiles/doc/developers-guide/gml.html
58  */
59 
60 /**@defgroup GMLgraph GML graphical printing
61  *
62  * @{
63  */
64 
65 /** writes a node section to the given graph file */
66 extern
67 void SCIPgmlWriteNode(
68  FILE* file, /**< file to write to */
69  unsigned int id, /**< id of the node */
70  const char* label, /**< label of the node */
71  const char* nodetype, /**< type of the node, or NULL */
72  const char* fillcolor, /**< color of the node's interior, or NULL */
73  const char* bordercolor /**< color of the node's border, or NULL */
74  );
75 
76 /** writes a node section including weight to the given graph file */
77 extern
79  FILE* file, /**< file to write to */
80  unsigned int id, /**< id of the node */
81  const char* label, /**< label of the node */
82  const char* nodetype, /**< type of the node, or NULL */
83  const char* fillcolor, /**< color of the node's interior, or NULL */
84  const char* bordercolor, /**< color of the node's border, or NULL */
85  SCIP_Real weight /**< weight of node */
86  );
87 
88 /** writes an edge section to the given graph file */
89 extern
90 void SCIPgmlWriteEdge(
91  FILE* file, /**< file to write to */
92  unsigned int source, /**< source node id of the node */
93  unsigned int target, /**< target node id of the edge */
94  const char* label, /**< label of the edge, or NULL */
95  const char* color /**< color of the edge, or NULL */
96  );
97 
98 /** writes an arc section to the given graph file */
99 extern
100 void SCIPgmlWriteArc(
101  FILE* file, /**< file to write to */
102  unsigned int source, /**< source node id of the node */
103  unsigned int target, /**< target node id of the edge */
104  const char* label, /**< label of the edge, or NULL */
105  const char* color /**< color of the edge, or NULL */
106  );
107 
108 /** writes the starting line to a GML graph file, does not open a file */
109 extern
111  FILE* file, /**< file to write to */
112  SCIP_Bool directed /**< is the graph directed */
113  );
114 
115 /** writes the ending lines to a GML graph file, does not close a file */
116 extern
118  FILE* file /**< file to close */
119  );
120 
121 /**@} */
122 
123 
124 /** @defgroup DataStructures Data Structures
125  *
126  * Below you find a list of available data structures
127  *
128  * @{
129  */
130 
131 
132 /*
133  * Sparse solution
134  */
135 
136 /**@defgroup SparseSol Sparse solution
137  *
138  * @{
139  */
140 
141 /** creates a sparse solution */
142 extern
144  SCIP_SPARSESOL** sparsesol, /**< pointer to store the created sparse solution */
145  SCIP_VAR** vars, /**< variables in the sparse solution, must not contain continuous
146  * variables
147  */
148  int nvars, /**< number of variables to store, size of the lower and upper bound
149  * arrays
150  */
151  SCIP_Bool cleared /**< should the lower and upper bound arrays be cleared (entries set to
152  * 0)
153  */
154  );
155 
156 /** frees priority queue, but not the data elements themselves */
157 extern
158 void SCIPsparseSolFree(
159  SCIP_SPARSESOL** sparsesol /**< pointer to a sparse solution */
160  );
161 
162 /** returns the variables in the given sparse solution */
163 extern
165  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
166  );
167 
168 /** returns the number of variables in the given sparse solution */
169 extern
171  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
172  );
173 
174 /** returns the the lower bound array for all variables for a given sparse solution */
175 extern
177  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
178  );
179 
180 /** returns the the upper bound array for all variables for a given sparse solution */
181 extern
183  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
184  );
185 
186 /** constructs the first solution of sparse solution (all variables are set to their lower bound value */
187 extern
189  SCIP_SPARSESOL* sparsesol, /**< sparse solutions */
190  SCIP_Longint* sol, /**< array to store the first solution */
191  int nvars /**< number of variables */
192  );
193 
194 /** constructs the next solution of the sparse solution and return whether there was one more or not */
195 extern
197  SCIP_SPARSESOL* sparsesol, /**< sparse solutions */
198  SCIP_Longint* sol, /**< current solution array which get changed to the next solution */
199  int nvars /**< number of variables */
200  );
201 
202 /**@} */
203 
204 
205 /*
206  * Queue
207  */
208 
209 /**@defgroup Queue Queue
210  *
211  * @{
212  */
213 
214 
215 /** creates a (circular) queue, best used if the size will be fixed or will not be increased that much */
216 extern
218  SCIP_QUEUE** queue, /**< pointer to the new queue */
219  int initsize, /**< initial number of available element slots */
220  SCIP_Real sizefac /**< memory growing factor applied, if more element slots are needed */
221  );
222 
223 
224 /** frees queue, but not the data elements themselves */
225 extern
226 void SCIPqueueFree(
227  SCIP_QUEUE** queue /**< pointer to a queue */
228  );
229 
230 /** clears the queue, but doesn't free the data elements themselves */
231 extern
232 void SCIPqueueClear(
233  SCIP_QUEUE* queue /**< queue */
234  );
235 
236 /** inserts element at the end of the queue */
237 extern
239  SCIP_QUEUE* queue, /**< queue */
240  void* elem /**< element to be inserted */
241  );
242 
243 /** removes and returns the first element of the queue */
244 extern
245 void* SCIPqueueRemove(
246  SCIP_QUEUE* queue /**< queue */
247  );
248 
249 /** returns the first element of the queue without removing it */
250 extern
251 void* SCIPqueueFirst(
252  SCIP_QUEUE* queue /**< queue */
253  );
254 
255 /** returns whether the queue is empty */
256 extern
258  SCIP_QUEUE* queue /**< queue */
259  );
260 
261 /** returns the number of elements in the queue */
262 extern
263 int SCIPqueueNElems(
264  SCIP_QUEUE* queue /**< queue */
265  );
266 
267 /**@} */
268 
269 /*
270  * Priority Queue
271  */
272 
273 /**@defgroup PriorityQueue Priority Queue
274  *
275  * @{
276  */
277 
278 /** creates priority queue */
279 extern
281  SCIP_PQUEUE** pqueue, /**< pointer to a priority queue */
282  int initsize, /**< initial number of available element slots */
283  SCIP_Real sizefac, /**< memory growing factor applied, if more element slots are needed */
284  SCIP_DECL_SORTPTRCOMP((*ptrcomp)) /**< data element comparator */
285  );
286 
287 /** frees priority queue, but not the data elements themselves */
288 extern
289 void SCIPpqueueFree(
290  SCIP_PQUEUE** pqueue /**< pointer to a priority queue */
291  );
292 
293 /** clears the priority queue, but doesn't free the data elements themselves */
294 extern
295 void SCIPpqueueClear(
296  SCIP_PQUEUE* pqueue /**< priority queue */
297  );
298 
299 /** inserts element into priority queue */
300 extern
302  SCIP_PQUEUE* pqueue, /**< priority queue */
303  void* elem /**< element to be inserted */
304  );
305 
306 /** removes and returns best element from the priority queue */
307 extern
308 void* SCIPpqueueRemove(
309  SCIP_PQUEUE* pqueue /**< priority queue */
310  );
311 
312 /** returns the best element of the queue without removing it */
313 extern
314 void* SCIPpqueueFirst(
315  SCIP_PQUEUE* pqueue /**< priority queue */
316  );
317 
318 /** returns the number of elements in the queue */
319 extern
320 int SCIPpqueueNElems(
321  SCIP_PQUEUE* pqueue /**< priority queue */
322  );
323 
324 /** returns the elements of the queue; changing the returned array may destroy the queue's ordering! */
325 extern
326 void** SCIPpqueueElems(
327  SCIP_PQUEUE* pqueue /**< priority queue */
328  );
329 
330 /**@} */
331 
332 
333 /*
334  * Hash Table
335  */
336 
337 /**@defgroup HashTable Hash Table
338  *
339  *@{
340  */
341 
342 /** returns a reasonable hash table size (a prime number) that is at least as large as the specified value */
343 extern
345  int minsize /**< minimal size of the hash table */
346  );
347 
348 /** creates a hash table */
349 extern
351  SCIP_HASHTABLE** hashtable, /**< pointer to store the created hash table */
352  BMS_BLKMEM* blkmem, /**< block memory used to store hash table entries */
353  int tablesize, /**< size of the hash table */
354  SCIP_DECL_HASHGETKEY((*hashgetkey)), /**< gets the key of the given element */
355  SCIP_DECL_HASHKEYEQ ((*hashkeyeq)), /**< returns TRUE iff both keys are equal */
356  SCIP_DECL_HASHKEYVAL((*hashkeyval)), /**< returns the hash value of the key */
357  void* userptr /**< user pointer */
358  );
359 
360 /** frees the hash table */
361 extern
362 void SCIPhashtableFree(
363  SCIP_HASHTABLE** hashtable /**< pointer to the hash table */
364  );
365 
366 /** removes all elements of the hash table
367  *
368  * @note From a performance point of view you should not fill and clear a hash table too often since the clearing can
369  * be expensive. Clearing is done by looping over all buckets and removing the hash table lists one-by-one.
370  *
371  * @deprecated Please use SCIPhashtableRemoveAll()
372  */
373 extern
374 void SCIPhashtableClear(
375  SCIP_HASHTABLE* hashtable /**< hash table */
376  );
377 
378 /** inserts element in hash table (multiple inserts of same element possible)
379  *
380  * @note A pointer to a hashtablelist returned by SCIPhashtableRetrieveNext() might get invalid when adding an element
381  * to the hash table, due to dynamic resizing.
382  */
383 extern
385  SCIP_HASHTABLE* hashtable, /**< hash table */
386  void* element /**< element to insert into the table */
387  );
388 
389 /** inserts element in hash table (multiple insertion of same element is checked and results in an error)
390  *
391  * @note A pointer to a hashtablelist returned by SCIPhashtableRetrieveNext() might get invalid when adding a new
392  * element to the hash table, due to dynamic resizing.
393  */
394 extern
396  SCIP_HASHTABLE* hashtable, /**< hash table */
397  void* element /**< element to insert into the table */
398  );
399 
400 /** retrieve element with key from hash table, returns NULL if not existing */
401 extern
403  SCIP_HASHTABLE* hashtable, /**< hash table */
404  void* key /**< key to retrieve */
405  );
406 
407 /** retrieve element with key from hash table, returns NULL if not existing
408  * can be used to retrieve all entries with the same key (one-by-one)
409  *
410  * @note The returned hashtablelist pointer might get invalid when adding a new element to the hash table.
411  */
412 extern
414  SCIP_HASHTABLE* hashtable, /**< hash table */
415  SCIP_HASHTABLELIST** hashtablelist, /**< input: entry in hash table list from which to start searching, or NULL
416  * output: entry in hash table list corresponding to element after
417  * retrieved one, or NULL */
418  void* key /**< key to retrieve */
419  );
420 
421 /** returns whether the given element exists in the table */
422 extern
424  SCIP_HASHTABLE* hashtable, /**< hash table */
425  void* element /**< element to search in the table */
426  );
427 
428 /** removes element from the hash table, if it exists */
429 extern
431  SCIP_HASHTABLE* hashtable, /**< hash table */
432  void* element /**< element to remove from the table */
433  );
434 
435 /** removes all elements of the hash table
436  *
437  * @note From a performance point of view you should not fill and clear a hash table too often since the clearing can
438  * be expensive. Clearing is done by looping over all buckets and removing the hash table lists one-by-one.
439  */
440 extern
442  SCIP_HASHTABLE* hashtable /**< hash table */
443  );
444 
445 /** returns number of hash table elements */
446 extern
448  SCIP_HASHTABLE* hashtable /**< hash table */
449  );
450 
451 /** returns the load of the given hash table in percentage */
452 extern
454  SCIP_HASHTABLE* hashtable /**< hash table */
455  );
456 
457 /** prints statistics about hash table usage */
458 extern
460  SCIP_HASHTABLE* hashtable, /**< hash table */
461  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
462  );
463 
464 /** standard hash key comparator for string keys */
465 extern
466 SCIP_DECL_HASHKEYEQ(SCIPhashKeyEqString);
467 
468 /** standard hashing function for string keys */
469 extern
470 SCIP_DECL_HASHKEYVAL(SCIPhashKeyValString);
471 
472 /** gets the element as the key */
473 extern
474 SCIP_DECL_HASHGETKEY(SCIPhashGetKeyStandard);
475 
476 /** returns TRUE iff both keys(pointer) are equal */
477 extern
478 SCIP_DECL_HASHKEYEQ(SCIPhashKeyEqPtr);
479 
480 /** returns the hash value of the key */
481 extern
482 SCIP_DECL_HASHKEYVAL(SCIPhashKeyValPtr);
483 
484 /**@} */
485 
486 
487 /*
488  * Hash Map
489  */
490 
491 /**@defgroup HashMap Hash Map
492  *
493  *@{
494  */
495 
496 /** creates a hash map mapping pointers to pointers */
497 extern
499  SCIP_HASHMAP** hashmap, /**< pointer to store the created hash map */
500  BMS_BLKMEM* blkmem, /**< block memory used to store hash map entries */
501  int mapsize /**< size of the hash map */
502  );
503 
504 /** frees the hash map */
505 extern
506 void SCIPhashmapFree(
507  SCIP_HASHMAP** hashmap /**< pointer to the hash map */
508  );
509 
510 /** inserts new origin->image pair in hash map (must not be called for already existing origins!) */
511 extern
513  SCIP_HASHMAP* hashmap, /**< hash map */
514  void* origin, /**< origin to set image for */
515  void* image /**< new image for origin */
516  );
517 
518 /** retrieves image of given origin from the hash map, or NULL if no image exists */
519 extern
520 void* SCIPhashmapGetImage(
521  SCIP_HASHMAP* hashmap, /**< hash map */
522  void* origin /**< origin to retrieve image for */
523  );
524 
525 /** sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a
526  * new origin->image pair
527  */
528 extern
530  SCIP_HASHMAP* hashmap, /**< hash map */
531  void* origin, /**< origin to set image for */
532  void* image /**< new image for origin */
533  );
534 
535 /** checks whether an image to the given origin exists in the hash map */
536 extern
538  SCIP_HASHMAP* hashmap, /**< hash map */
539  void* origin /**< origin to search for */
540  );
541 
542 /** removes origin->image pair from the hash map, if it exists */
543 extern
545  SCIP_HASHMAP* hashmap, /**< hash map */
546  void* origin /**< origin to remove from the list */
547  );
548 
549 /** prints statistics about hash map usage */
550 extern
552  SCIP_HASHMAP* hashmap, /**< hash map */
553  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
554  );
555 
556 /** indicates whether a hash map has no entries */
557 extern
559  SCIP_HASHMAP* hashmap /**< hash map */
560 );
561 
562 /** gives the number of entries in a hash map */
563 extern
565  SCIP_HASHMAP* hashmap /**< hash map */
566 );
567 
568 /** gives the number of lists (buckets) in a hash map */
569 extern
571  SCIP_HASHMAP* hashmap /**< hash map */
572 );
573 
574 /** gives a specific list (bucket) in a hash map */
575 extern
577  SCIP_HASHMAP* hashmap, /**< hash map */
578  int listindex /**< index of hash map list */
579 );
580 
581 /** gives the number of entries in a list of a hash map */
582 extern
584  SCIP_HASHMAPLIST* hashmaplist /**< hash map list, can be NULL */
585 );
586 
587 /** retrieves origin of given entry in a hash map */
588 extern
590  SCIP_HASHMAPLIST* hashmaplist /**< hash map list */
591 );
592 
593 /** retrieves image of given entry in a hash map */
594 extern
596  SCIP_HASHMAPLIST* hashmaplist /**< hash map list */
597 );
598 
599 /** retrieves next entry from given entry in a hash map list, or NULL if at end of list. */
600 extern
602  SCIP_HASHMAPLIST* hashmaplist /**< hash map list */
603 );
604 
605 /** removes all entries in a hash map. */
606 extern
608  SCIP_HASHMAP* hashmap /**< hash map */
609 );
610 
611 /**@} */
612 
613 
614 
615 /*
616  * Activity
617  */
618 
619 /**@defgroup ResourceActivity Resource activity
620  *
621  *@{
622  */
623 
624 /** create a resource activity */
625 extern
627  SCIP_RESOURCEACTIVITY** activity, /**< pointer to store the resource activity */
628  SCIP_VAR* var, /**< start time variable of the activity */
629  int duration, /**< duration of the activity */
630  int demand /**< demand of the activity */
631  );
632 
633 /** frees a resource activity */
634 extern
635 void SCIPactivityFree(
636  SCIP_RESOURCEACTIVITY** activity /**< pointer to the resource activity */
637  );
638 
639 #ifndef NDEBUG
640 
641 /** returns the start time variable of the resource activity */
642 extern
644  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
645  );
646 
647 /** returns the duration of the resource activity */
648 extern
650  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
651  );
652 
653 /** returns the demand of the resource activity */
654 extern
656  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
657  );
658 
659 /** returns the energy of the resource activity */
660 extern
662  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
663  );
664 
665 #else
666 
667 #define SCIPactivityGetVar(activity) ((activity)->var)
668 #define SCIPactivityGetDuration(activity) ((activity)->duration)
669 #define SCIPactivityGetDemand(activity) ((activity)->demand)
670 #define SCIPactivityGetEnergy(activity) ((activity)->duration * (activity)->demand)
671 
672 #endif
673 
674 /**@} */
675 
676 
677 /*
678  * Resource Profile
679  */
680 
681 /**@defgroup ResourceProfile Resource Profile
682  *
683  *@{
684  */
685 
686 /** creates resource profile */
687 extern
689  SCIP_PROFILE** profile, /**< pointer to store the resource profile */
690  int capacity /**< resource capacity */
691  );
692 
693 /** frees given resource profile */
694 extern
695 void SCIPprofileFree(
696  SCIP_PROFILE** profile /**< pointer to the resource profile */
697  );
698 
699 /** output of the given resource profile */
700 extern
701 void SCIPprofilePrint(
702  SCIP_PROFILE* profile, /**< resource profile to output */
703  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
704  FILE* file /**< output file (or NULL for standard output) */
705  );
706 
707 /** returns the capacity of the resource profile */
708 extern
710  SCIP_PROFILE* profile /**< resource profile to use */
711  );
712 
713 /** returns the number time points of the resource profile */
714 extern
716  SCIP_PROFILE* profile /**< resource profile to use */
717  );
718 
719 /** returns the time points of the resource profile */
720 extern
722  SCIP_PROFILE* profile /**< resource profile to use */
723  );
724 
725 /** returns the loads of the resource profile */
726 extern
728  SCIP_PROFILE* profile /**< resource profile to use */
729  );
730 
731 /** returns the time point for given position of the resource profile */
732 extern
734  SCIP_PROFILE* profile, /**< resource profile to use */
735  int pos /**< position */
736  );
737 
738 /** returns the loads of the resource profile at the given position */
739 extern
741  SCIP_PROFILE* profile, /**< resource profile */
742  int pos /**< position */
743  );
744 
745 /** returns if the given time point exists in the resource profile and stores the position of the given time point if it
746  * exists; otherwise the position of the next smaller existing time point is stored
747  */
748 extern
750  SCIP_PROFILE* profile, /**< resource profile to search */
751  int timepoint, /**< time point to search for */
752  int* pos /**< pointer to store the position */
753  );
754 
755 /** insert a core into resource profile; if the core is non-empty the resource profile will be updated otherwise nothing
756  * happens
757  */
758 extern
760  SCIP_PROFILE* profile, /**< resource profile to use */
761  int left, /**< left side of the core */
762  int right, /**< right side of the core */
763  int height, /**< height of the core */
764  int* pos, /**< pointer to store the first position were it gets infeasible */
765  SCIP_Bool* infeasible /**< pointer to store if the core does not fit due to capacity */
766  );
767 
768 /** subtracts the height from the resource profile during core time */
769 extern
771  SCIP_PROFILE* profile, /**< resource profile to use */
772  int left, /**< left side of the core */
773  int right, /**< right side of the core */
774  int height /**< height of the core */
775  );
776 
777 /** return the earliest possible starting point within the time interval [lb,ub] for a given core (given by its height
778  * and duration)
779  */
780 extern
782  SCIP_PROFILE* profile, /**< resource profile to use */
783  int est, /**< earliest starting time of the given core */
784  int lst, /**< latest starting time of the given core */
785  int duration, /**< duration of the core */
786  int height, /**< height of the core */
787  SCIP_Bool* infeasible /**< pointer store if the corer cannot be inserted */
788  );
789 
790 /** return the latest possible starting point within the time interval [lb,ub] for a given core (given by its height and
791  * duration)
792  */
793 extern
795  SCIP_PROFILE* profile, /**< resource profile to use */
796  int lb, /**< earliest possible start point */
797  int ub, /**< latest possible start point */
798  int duration, /**< duration of the core */
799  int height, /**< height of the core */
800  SCIP_Bool* infeasible /**< pointer store if the core cannot be inserted */
801  );
802 
803 /**@} */
804 
805 /*
806  * Directed graph
807  */
808 
809 /**@defgroup DirectedGraph Directed Graph
810  *
811  *@{
812  */
813 
814 /** creates directed graph structure */
815 extern
817  SCIP_DIGRAPH** digraph, /**< pointer to store the created directed graph */
818  int nnodes /**< number of nodes */
819  );
820 
821 /** resize directed graph structure */
822 extern
824  SCIP_DIGRAPH* digraph, /**< directed graph */
825  int nnodes /**< new number of nodes */
826  );
827 
828 /** copies directed graph structure */
829 extern
831  SCIP_DIGRAPH** targetdigraph, /**< pointer to store the copied directed graph */
832  SCIP_DIGRAPH* sourcedigraph /**< source directed graph */
833  );
834 
835 /** sets the sizes of the successor lists for the nodes in a directed graph and allocates memory for the lists */
836 extern
838  SCIP_DIGRAPH* digraph, /**< directed graph */
839  int* sizes /**< sizes of the successor lists */
840  );
841 
842 /** frees given directed graph structure */
843 extern
844 void SCIPdigraphFree(
845  SCIP_DIGRAPH** digraph /**< pointer to the directed graph */
846  );
847 
848 /** add (directed) arc and a related data to the directed graph structure
849  *
850  * @note if the arc is already contained, it is added a second time
851  */
852 extern
854  SCIP_DIGRAPH* digraph, /**< directed graph */
855  int startnode, /**< start node of the arc */
856  int endnode, /**< start node of the arc */
857  void* data /**< data that should be stored for the arc; or NULL */
858  );
859 
860 /** add (directed) arc to the directed graph structure, if it is not contained, yet
861  *
862  * @note if there already exists an arc from startnode to endnode, the new arc is not added,
863  * even if its data is different
864  */
865 extern
867  SCIP_DIGRAPH* digraph, /**< directed graph */
868  int startnode, /**< start node of the arc */
869  int endnode, /**< start node of the arc */
870  void* data /**< data that should be stored for the arc; or NULL */
871  );
872 
873 /** returns the number of nodes of the given digraph */
874 extern
876  SCIP_DIGRAPH* digraph /**< directed graph */
877  );
878 
879 /** returns the node data, or NULL if no data exist */
880 extern
882  SCIP_DIGRAPH* digraph, /**< directed graph */
883  int node /**< node for which the node data is returned */
884  );
885 
886 /** sets the node data */
887 extern
889  SCIP_DIGRAPH* digraph, /**< directed graph */
890  void* dataptr, /**< user node data pointer, or NULL */
891  int node /**< node for which the node data is returned */
892  );
893 
894 /** returns the total number of arcs in the given digraph */
895 extern
897  SCIP_DIGRAPH* digraph /**< directed graph */
898  );
899 
900 /** returns the number of successor nodes of the given node */
901 extern
903  SCIP_DIGRAPH* digraph, /**< directed graph */
904  int node /**< node for which the number of outgoing arcs is returned */
905  );
906 
907 /** returns the array of indices of the successor nodes; this array must not be changed from outside */
908 extern
910  SCIP_DIGRAPH* digraph, /**< directed graph */
911  int node /**< node for which the array of outgoing arcs is returned */
912  );
913 
914 /** returns the array of datas corresponding to the arcs originating at the given node, or NULL if no data exist; this
915  * array must not be changed from outside
916  */
917 extern
919  SCIP_DIGRAPH* digraph, /**< directed graph */
920  int node /**< node for which the data corresponding to the outgoing arcs is returned */
921  );
922 
923 /** Compute undirected connected components on the given graph.
924  *
925  * @note For each arc, its reverse is added, so the graph does not need to be the directed representation of an
926  * undirected graph.
927  */
928 extern
930  SCIP_DIGRAPH* digraph, /**< directed graph */
931  int minsize, /**< all components with less nodes are ignored */
932  int* components, /**< array with as many slots as there are nodes in the directed graph
933  * to store for each node the component to which it belongs
934  * (components are numbered 0 to ncomponents - 1); or NULL, if components
935  * are accessed one-by-one using SCIPdigraphGetComponent() */
936  int* ncomponents /**< pointer to store the number of components; or NULL, if the
937  * number of components is accessed by SCIPdigraphGetNComponents() */
938  );
939 
940 /** Performes an (almost) topological sort on the undirected components of the given directed graph. The undirected
941  * components should be computed before using SCIPdigraphComputeUndirectedComponents().
942  *
943  * @note In general a topological sort is not unique. Note, that there might be directed cycles, that are randomly
944  * broken, which is the reason for having only almost topologically sorted arrays.
945  */
946 extern
948  SCIP_DIGRAPH* digraph /**< directed graph */
949  );
950 
951 /** returns the number of previously computed undirected components for the given directed graph */
952 extern
954  SCIP_DIGRAPH* digraph /**< directed graph */
955  );
956 
957 /** Returns the previously computed undirected component of the given number for the given directed graph.
958  * If the components were sorted using SCIPdigraphTopoSortComponents(), the component is (almost) topologically sorted.
959  */
960 extern
962  SCIP_DIGRAPH* digraph, /**< directed graph */
963  int compidx, /**< number of the component to return */
964  int** nodes, /**< pointer to store the nodes in the component; or NULL, if not needed */
965  int* nnodes /**< pointer to store the number of nodes in the component;
966  * or NULL, if not needed */
967  );
968 
969 /** frees the component information for the given directed graph */
970 extern
972  SCIP_DIGRAPH* digraph /**< directed graph */
973  );
974 
975 /** output of the given directed graph via the given message handler */
976 extern
977 void SCIPdigraphPrint(
978  SCIP_DIGRAPH* digraph, /**< directed graph */
979  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
980  FILE* file /**< output file (or NULL for standard output) */
981  );
982 
983 /** prints the given directed graph structure in GML format into the given file */
984 extern
986  SCIP_DIGRAPH* digraph, /**< directed graph */
987  FILE* file /**< file to write to */
988  );
989 
990 
991 /** output of the given directed graph via the given message handler */
992 extern
994  SCIP_DIGRAPH* digraph, /**< directed graph */
995  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
996  FILE* file /**< output file (or NULL for standard output) */
997  );
998 
999 /**@} */
1000 
1001 /*
1002  * Binary search tree
1003  */
1004 
1005 /**@defgroup BinaryTree Binary Tree
1006  *
1007  *@{
1008  */
1009 
1010 /** creates a binary tree node with sorting value and user data */
1011 extern
1013  SCIP_BT* tree, /**< binary search tree */
1014  SCIP_BTNODE** node, /**< pointer to store the created search node */
1015  void* dataptr /**< user node data pointer, or NULL */
1016  );
1017 
1018 /** frees the binary node including the rooted subtree
1019  *
1020  * @note The user pointer (object) is not freed. If needed, it has to be done by the user.
1021  */
1022 extern
1023 void SCIPbtnodeFree(
1024  SCIP_BT* tree, /**< binary tree */
1025  SCIP_BTNODE** node /**< node to be freed */
1026  );
1027 
1028 /** returns the user data pointer stored in that node */
1029 extern
1030 void* SCIPbtnodeGetData(
1031  SCIP_BTNODE* node /**< node */
1032  );
1033 
1034 /** returns the parent which can be NULL if the given node is the root */
1035 extern
1037  SCIP_BTNODE* node /**< node */
1038  );
1039 
1040 /** returns left child which can be NULL if the given node is a leaf */
1041 extern
1043  SCIP_BTNODE* node /**< node */
1044  );
1045 
1046 /** returns right child which can be NULL if the given node is a leaf */
1047 extern
1049  SCIP_BTNODE* node /**< node */
1050  );
1051 
1052 /** returns the sibling of the node or NULL if does not exist */
1053 extern
1055  SCIP_BTNODE* node /**< node */
1056  );
1057 
1058 /** returns whether the node is a root node */
1059 extern
1061  SCIP_BTNODE* node /**< node */
1062  );
1063 
1064 /** returns whether the node is a leaf */
1065 extern
1067  SCIP_BTNODE* node /**< node */
1068  );
1069 
1070 /** returns TRUE if the given node is left child */
1071 extern
1073  SCIP_BTNODE* node /**< node */
1074  );
1075 
1076 /** returns TRUE if the given node is right child */
1077 extern
1079  SCIP_BTNODE* node /**< node */
1080  );
1081 
1082 #ifdef NDEBUG
1083 
1084 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1085  * speed up the algorithms.
1086  */
1087 
1088 #define SCIPbtnodeGetData(node) ((node)->dataptr)
1089 #define SCIPbtnodeGetParent(node) ((node)->parent)
1090 #define SCIPbtnodeGetLeftchild(node) ((node)->left)
1091 #define SCIPbtnodeGetRightchild(node) ((node)->right)
1092 #define SCIPbtnodeGetSibling(node) ((node)->parent == NULL ? NULL : \
1093  (node)->parent->left == (node) ? (node)->parent->right : (node)->parent->left)
1094 #define SCIPbtnodeIsRoot(node) ((node)->parent == NULL)
1095 #define SCIPbtnodeIsLeaf(node) ((node)->left == NULL && (node)->right == NULL)
1096 #define SCIPbtnodeIsLeftchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->left == (node) ? TRUE : FALSE)
1097 #define SCIPbtnodeIsRightchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->right == (node) ? TRUE : FALSE)
1098 
1099 #endif
1100 
1101 /** sets the give node data
1102  *
1103  * @note The old user pointer is not freed.
1104  */
1105 extern
1106 void SCIPbtnodeSetData(
1107  SCIP_BTNODE* node, /**< node */
1108  void* dataptr /**< node user data pointer */
1109  );
1110 
1111 /** sets parent node
1112  *
1113  * @note The old parent including the rooted subtree is not delete.
1114  */
1115 extern
1116 void SCIPbtnodeSetParent(
1117  SCIP_BTNODE* node, /**< node */
1118  SCIP_BTNODE* parent /**< new parent node, or NULL */
1119  );
1120 
1121 /** sets left child
1122  *
1123  * @note The old left child including the rooted subtree is not delete.
1124  */
1125 extern
1127  SCIP_BTNODE* node, /**< node */
1128  SCIP_BTNODE* left /**< new left child, or NULL */
1129  );
1130 
1131 /** sets right child
1132  *
1133  * @note The old right child including the rooted subtree is not delete.
1134  */
1135 extern
1137  SCIP_BTNODE* node, /**< node */
1138  SCIP_BTNODE* right /**< new right child, or NULL */
1139  );
1140 
1141 /** creates an binary tree */
1142 extern
1144  SCIP_BT** tree, /**< pointer to store the created binary tree */
1145  BMS_BLKMEM* blkmem /**< block memory used to create nodes */
1146  );
1147 
1148 /** frees binary tree
1149  *
1150  * @note The user pointers (object) of the search nodes are not freed. If needed, it has to be done by the user.
1151  */
1152 extern
1153 void SCIPbtFree(
1154  SCIP_BT** tree /**< pointer to binary tree */
1155  );
1156 
1157 /** prints the binary tree in GML format into the given file */
1158 extern
1159 void SCIPbtPrintGml(
1160  SCIP_BT* tree, /**< binary tree */
1161  FILE* file /**< file to write to */
1162  );
1163 
1164 /** returns whether the binary tree is empty (has no nodes) */
1165 extern
1167  SCIP_BT * tree /**< binary tree */
1168  );
1169 
1170 /** returns the root node of the binary tree or NULL if the binary tree is empty */
1171 extern
1173  SCIP_BT* tree /**< tree to be evaluated */
1174  );
1175 
1176 #ifdef NDEBUG
1177 
1178 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1179  * speed up the algorithms.
1180  */
1181 
1182 #define SCIPbtIsEmpty(tree) (tree->root == NULL)
1183 #define SCIPbtGetRoot(tree) (tree->root)
1184 
1185 #endif
1186 
1187 /** sets root node
1188  *
1189  * @note The old root including the rooted subtree is not delete.
1190  */
1191 extern
1192 void SCIPbtSetRoot(
1193  SCIP_BT* tree, /**< tree to be evaluated */
1194  SCIP_BTNODE* root /**< new root, or NULL */
1195  );
1196 
1197 /**@} */
1198 
1199 /**@} */
1200 
1201 /*
1202  * Sorting algorithms
1203  */
1204 
1205 /**@defgroup SortingAlgorithms Sorting Algorithms
1206  *
1207  * @{
1208  */
1209 
1210 /** default comparer for integers */
1211 extern
1212 SCIP_DECL_SORTPTRCOMP(SCIPsortCompInt);
1213 
1214 /* first all upwards-sorting methods */
1215 
1216 /** sort an indexed element set in non-decreasing order, resulting in a permutation index array */
1217 extern
1218 void SCIPsort(
1219  int* perm, /**< pointer to store the resulting permutation */
1220  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1221  void* dataptr, /**< pointer to data field that is given to the external compare method */
1222  int len /**< number of elements to be sorted (valid index range) */
1223  );
1224 
1225 /** sort an index array in non-decreasing order */
1226 extern
1227 void SCIPsortInd(
1228  int* indarray, /**< pointer to the index array to be sorted */
1229  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1230  void* dataptr, /**< pointer to data field that is given to the external compare method */
1231  int len /**< length of array */
1232  );
1233 
1234 /** sort of an array of pointers in non-decreasing order */
1235 extern
1236 void SCIPsortPtr(
1237  void** ptrarray, /**< pointer array to be sorted */
1238  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1239  int len /**< length of array */
1240  );
1241 
1242 /** sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
1243 extern
1244 void SCIPsortPtrPtr(
1245  void** ptrarray1, /**< first pointer array to be sorted */
1246  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1247  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1248  int len /**< length of arrays */
1249  );
1250 
1251 /** sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
1252 extern
1253 void SCIPsortPtrReal(
1254  void** ptrarray, /**< pointer array to be sorted */
1255  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1256  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1257  int len /**< length of arrays */
1258  );
1259 
1260 /** sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
1261 extern
1262 void SCIPsortPtrInt(
1263  void** ptrarray, /**< pointer array to be sorted */
1264  int* intarray, /**< int array to be permuted in the same way */
1265  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1266  int len /**< length of arrays */
1267  );
1268 
1269 /** sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
1270 extern
1271 void SCIPsortPtrBool(
1272  void** ptrarray, /**< pointer array to be sorted */
1273  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1274  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1275  int len /**< length of arrays */
1276  );
1277 
1278 
1279 /** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
1280 extern
1281 void SCIPsortPtrIntInt(
1282  void** ptrarray, /**< pointer array to be sorted */
1283  int* intarray1, /**< first int array to be permuted in the same way */
1284  int* intarray2, /**< second int array to be permuted in the same way */
1285  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1286  int len /**< length of arrays */
1287  );
1288 
1289 /** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
1290 extern
1291 void SCIPsortPtrRealInt(
1292  void** ptrarray, /**< pointer array to be sorted */
1293  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1294  int* intarray, /**< int array to be permuted in the same way */
1295  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1296  int len /**< length of arrays */
1297  );
1298 
1299 /** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order */
1300 extern
1301 void SCIPsortPtrPtrInt(
1302  void** ptrarray1, /**< first pointer array to be sorted */
1303  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1304  int* intarray, /**< int array to be permuted in the same way */
1305  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1306  int len /**< length of arrays */
1307  );
1308 
1309 /** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
1310 extern
1311 void SCIPsortPtrPtrReal(
1312  void** ptrarray1, /**< first pointer array to be sorted */
1313  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1314  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1315  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1316  int len /**< length of arrays */
1317  );
1318 
1319 /** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1320 extern
1322  void** ptrarray1, /**< first pointer array to be sorted */
1323  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1324  int* intarray1, /**< first int array to be permuted in the same way */
1325  int* intarray2, /**< second int array to be permuted in the same way */
1326  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1327  int len /**< length of arrays */
1328  );
1329 
1330 /** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
1331 extern
1333  void** ptrarray, /**< pointer array to be sorted */
1334  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1335  int* intarray1, /**< first int array to be permuted in the same way */
1336  int* intarray2, /**< second int array to be permuted in the same way */
1337  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1338  int len /**< length of arrays */
1339  );
1340 
1341 /** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
1342 extern
1344  void** ptrarray1, /**< first pointer array to be sorted */
1345  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1346  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1347  int* intarray, /**< int array to be permuted in the same way */
1348  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1349  int len /**< length of arrays */
1350  );
1351 
1352 /** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
1353 extern
1355  void** ptrarray1, /**< first pointer array to be sorted */
1356  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1357  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1358  int* intarray, /**< int array to be permuted in the same way */
1359  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1360  int len /**< length of arrays */
1361  );
1362 
1363 /** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
1364 extern
1366  void** ptrarray1, /**< first pointer array to be sorted */
1367  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1368  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1369  int* intarray1, /**< first int array to be permuted in the same way */
1370  int* intarray2, /**< second int array to be permuted in the same way */
1371  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1372  int len /**< length of arrays */
1373  );
1374 
1375 /** sort an array of Reals in non-decreasing order */
1376 extern
1377 void SCIPsortReal(
1378  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1379  int len /**< length of arrays */
1380  );
1381 
1382 /** sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
1383 extern
1384 void SCIPsortRealPtr(
1385  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1386  void** ptrarray, /**< pointer array to be permuted in the same way */
1387  int len /**< length of arrays */
1388  );
1389 
1390 /** sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
1391 extern
1392 void SCIPsortRealInt(
1393  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1394  int* intarray, /**< int array to be permuted in the same way */
1395  int len /**< length of arrays */
1396  );
1397 
1398 /** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order */
1399 extern
1400 void SCIPsortRealBoolPtr(
1401  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1402  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1403  void** ptrarray, /**< pointer array to be permuted in the same way */
1404  int len /**< length of arrays */
1405  );
1406 
1407 /** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
1408 extern
1409 void SCIPsortRealIntLong(
1410  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1411  int* intarray, /**< int array to be permuted in the same way */
1412  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1413  int len /**< length of arrays */
1414  );
1415 
1416 /** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
1417 extern
1418 void SCIPsortRealIntPtr(
1419  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1420  int* intarray, /**< int array to be permuted in the same way */
1421  void** ptrarray, /**< pointer array to be permuted in the same way */
1422  int len /**< length of arrays */
1423  );
1424 
1425 /** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
1426 extern
1427 void SCIPsortRealRealPtr(
1428  SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
1429  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1430  void** ptrarray, /**< pointer array to be permuted in the same way */
1431  int len /**< length of arrays */
1432  );
1433 
1434 /** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
1435 extern
1437  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1438  void** ptrarray1, /**< pointer array to be permuted in the same way */
1439  void** ptrarray2, /**< pointer array to be permuted in the same way */
1440  int* intarray, /**< int array to be sorted */
1441  int len /**< length of arrays */
1442  );
1443 
1444 /** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1445 extern
1447  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1448  void** ptrarray1, /**< pointer array to be permuted in the same way */
1449  void** ptrarray2, /**< pointer array to be permuted in the same way */
1450  int* intarray1, /**< int array to be sorted */
1451  int* intarray2, /**< int array to be sorted */
1452  int len /**< length of arrays */
1453  );
1454 
1455 /** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order */
1456 extern
1458  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1459  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1460  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1461  int* intarray, /**< int array to be permuted in the same way */
1462  int len /**< length of arrays */
1463  );
1464 
1465 /** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
1466 extern
1468  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1469  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1470  int* intarray1, /**< int array to be permuted in the same way */
1471  int* intarray2, /**< int array to be permuted in the same way */
1472  int len /**< length of arrays */
1473  );
1474 
1475 /** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
1476 extern
1478  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1479  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1480  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1481  int* intarray, /**< int array to be permuted in the same way */
1482  int len /**< length of arrays */
1483  );
1484 
1485 /** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
1486 extern
1488  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1489  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1490  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1491  void** ptrarray, /**< pointer array to be permuted in the same way */
1492  int len /**< length of arrays */
1493  );
1494 
1495 /** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
1496 extern
1498  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1499  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1500  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1501  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1502  void** ptrarray, /**< pointer array to be permuted in the same way */
1503  int len /**< length of arrays */
1504  );
1505 
1506 /** sort array of ints in non-decreasing order */
1507 extern
1508 void SCIPsortInt(
1509  int* intarray, /**< int array to be sorted */
1510  int len /**< length of arrays */
1511  );
1512 
1513 /** sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order */
1514 extern
1515 void SCIPsortIntInt(
1516  int* intarray1, /**< int array to be sorted */
1517  int* intarray2, /**< second int array to be permuted in the same way */
1518  int len /**< length of arrays */
1519  );
1520 
1521 /** sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
1522 extern
1523 void SCIPsortIntPtr(
1524  int* intarray, /**< int array to be sorted */
1525  void** ptrarray, /**< pointer array to be permuted in the same way */
1526  int len /**< length of arrays */
1527  );
1528 
1529 /** sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order */
1530 extern
1531 void SCIPsortIntReal(
1532  int* intarray, /**< int array to be sorted */
1533  SCIP_Real* realarray, /**< real array to be permuted in the same way */
1534  int len /**< length of arrays */
1535  );
1536 
1537 /** sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
1538 extern
1539 void SCIPsortIntIntInt(
1540  int* intarray1, /**< int array to be sorted */
1541  int* intarray2, /**< second int array to be permuted in the same way */
1542  int* intarray3, /**< third int array to be permuted in the same way */
1543  int len /**< length of arrays */
1544  );
1545 
1546 /** sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order */
1547 extern
1548 void SCIPsortIntIntLong(
1549  int* intarray1, /**< int array to be sorted */
1550  int* intarray2, /**< second int array to be permuted in the same way */
1551  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1552  int len /**< length of arrays */
1553  );
1554 
1555 /** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
1556 extern
1557 void SCIPsortIntIntPtr(
1558  int* intarray1, /**< int array to be sorted */
1559  int* intarray2, /**< second int array to be permuted in the same way */
1560  void** ptrarray, /**< pointer array to be permuted in the same way */
1561  int len /**< length of arrays */
1562  );
1563 
1564 /** sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order */
1565 extern
1566 void SCIPsortIntIntReal(
1567  int* intarray1, /**< int array to be sorted */
1568  int* intarray2, /**< second int array to be permuted in the same way */
1569  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1570  int len /**< length of arrays */
1571  );
1572 
1573 /** sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order */
1574 extern
1575 void SCIPsortIntPtrReal(
1576  int* intarray, /**< int array to be sorted */
1577  void** ptrarray, /**< pointer array to be permuted in the same way */
1578  SCIP_Real* realarray, /**< real array to be permuted in the same way */
1579  int len /**< length of arrays */
1580  );
1581 
1582 /** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
1583 extern
1585  int* intarray1, /**< int array to be sorted */
1586  int* intarray2, /**< int array to be permuted in the same way */
1587  int* intarray3, /**< int array to be permuted in the same way */
1588  void** ptrarray, /**< pointer array to be permuted in the same way */
1589  int len /**< length of arrays */
1590  );
1591 
1592 /** sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
1593 extern
1595  int* intarray1, /**< int array to be sorted */
1596  void** ptrarray, /**< pointer array to be permuted in the same way */
1597  int* intarray2, /**< int array to be permuted in the same way */
1598  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1599  int len /**< length of arrays */
1600  );
1601 
1602 /** sort an array of Longints in non-decreasing order */
1603 extern
1604 void SCIPsortLong(
1605  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1606  int len /**< length of arrays */
1607  );
1608 
1609 /** sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
1610 extern
1611 void SCIPsortLongPtr(
1612  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1613  void** ptrarray, /**< pointer array to be permuted in the same way */
1614  int len /**< length of arrays */
1615  );
1616 
1617 /** sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
1618 extern
1619 void SCIPsortLongPtrInt(
1620  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1621  void** ptrarray, /**< pointer array to be permuted in the same way */
1622  int* intarray, /**< int array to be permuted in the same way */
1623  int len /**< length of arrays */
1624  );
1625 
1626 /** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
1627 extern
1629  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1630  void** ptrarray, /**< pointer array to be permuted in the same way */
1631  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1632  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1633  int len /**< length of arrays */
1634  );
1635 
1636 /** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
1637 extern
1639  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1640  void** ptrarray, /**< pointer array to be permuted in the same way */
1641  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
1642  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1643  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1644  int len /**< length of arrays */
1645  );
1646 
1647 /** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
1648 extern
1650  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1651  void** ptrarray, /**< pointer array to be permuted in the same way */
1652  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
1653  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1654  int* intarray, /**< int array to be permuted in the same way */
1655  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1656  int len /**< length of arrays */
1657  );
1658 
1659 /** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
1660 extern
1662  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1663  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1664  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1665  int* intarray, /**< int array to be permuted in the same way */
1666  int len /**< length of arrays */
1667  );
1668 
1669 /** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
1670 extern
1672  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1673  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1674  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1675  int* intarray1, /**< first int array to be permuted in the same way */
1676  int* intarray2, /**< second int array to be permuted in the same way */
1677  int len /**< length of arrays */
1678  );
1679 
1680 /** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
1681 extern
1683  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1684  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1685  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1686  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1687  int* intarray, /**< int array to be sorted */
1688  int len /**< length of arrays */
1689  );
1690 
1691 /** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
1692 extern
1694  void** ptrarray, /**< pointer array to be sorted */
1695  int* intarray1, /**< first int array to be permuted in the same way */
1696  int* intarray2, /**< second int array to be permuted in the same way */
1697  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
1698  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
1699  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1700  int len /**< length of arrays */
1701  );
1702 
1703 /** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
1704 extern
1706  int* intarray1, /**< int array to be sorted */
1707  void** ptrarray, /**< pointer array to be permuted in the same way */
1708  int* intarray2, /**< second int array to be permuted in the same way */
1709  int* intarray3, /**< thrid int array to be permuted in the same way */
1710  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
1711  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
1712  int len /**< length of arrays */
1713  );
1714 
1715 /* now all downwards-sorting methods */
1716 
1717 /** sort an indexed element set in non-increasing order, resulting in a permutation index array */
1718 extern
1719 void SCIPsortDown(
1720  int* perm, /**< pointer to store the resulting permutation */
1721  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1722  void* dataptr, /**< pointer to data field that is given to the external compare method */
1723  int len /**< number of elements to be sorted (valid index range) */
1724  );
1725 
1726 /** sort an index array in non-increasing order */
1727 extern
1728 void SCIPsortDownInd(
1729  int* indarray, /**< pointer to the index array to be sorted */
1730  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1731  void* dataptr, /**< pointer to data field that is given to the external compare method */
1732  int len /**< length of array */
1733  );
1734 
1735 /** sort of an array of pointers in non-increasing order */
1736 extern
1737 void SCIPsortDownPtr(
1738  void** ptrarray, /**< pointer array to be sorted */
1739  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1740  int len /**< length of array */
1741  );
1742 
1743 /** sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
1744 extern
1745 void SCIPsortDownPtrPtr(
1746  void** ptrarray1, /**< first pointer array to be sorted */
1747  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1748  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1749  int len /**< length of arrays */
1750  );
1751 
1752 /** sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
1753 extern
1754 void SCIPsortDownPtrReal(
1755  void** ptrarray, /**< pointer array to be sorted */
1756  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1757  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1758  int len /**< length of arrays */
1759  );
1760 
1761 /** sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order */
1762 extern
1763 void SCIPsortDownPtrInt(
1764  void** ptrarray, /**< pointer array to be sorted */
1765  int* intarray, /**< int array to be permuted in the same way */
1766  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1767  int len /**< length of arrays */
1768  );
1769 
1770 /** sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
1771 extern
1772 void SCIPsortDownPtrBool(
1773  void** ptrarray, /**< pointer array to be sorted */
1774  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1775  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1776  int len /**< length of arrays */
1777  );
1778 
1779 /** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
1780 extern
1782  void** ptrarray, /**< pointer array to be sorted */
1783  int* intarray1, /**< first int array to be permuted in the same way */
1784  int* intarray2, /**< second int array to be permuted in the same way */
1785  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1786  int len /**< length of arrays */
1787  );
1788 
1789 /** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
1790 extern
1792  void** ptrarray, /**< pointer array to be sorted */
1793  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1794  int* intarray, /**< int array to be permuted in the same way */
1795  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1796  int len /**< length of arrays */
1797  );
1798 
1799 /** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order */
1800 extern
1802  void** ptrarray1, /**< first pointer array to be sorted */
1803  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1804  int* intarray, /**< int array to be permuted in the same way */
1805  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1806  int len /**< length of arrays */
1807  );
1808 
1809 /** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
1810 extern
1812  void** ptrarray1, /**< first pointer array to be sorted */
1813  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1814  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1815  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1816  int len /**< length of arrays */
1817  );
1818 
1819 /** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
1820 extern
1822  void** ptrarray1, /**< first pointer array to be sorted */
1823  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1824  int* intarray1, /**< first int array to be permuted in the same way */
1825  int* intarray2, /**< second int array to be permuted in the same way */
1826  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1827  int len /**< length of arrays */
1828  );
1829 
1830 /** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
1831 extern
1833  void** ptrarray, /**< pointer array to be sorted */
1834  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1835  int* intarray1, /**< first int array to be permuted in the same way */
1836  int* intarray2, /**< second int array to be permuted in the same way */
1837  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1838  int len /**< length of arrays */
1839  );
1840 
1841 /** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
1842 extern
1844  void** ptrarray1, /**< first pointer array to be sorted */
1845  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1846  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1847  int* intarray, /**< int array to be permuted in the same way */
1848  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1849  int len /**< length of arrays */
1850  );
1851 
1852 /** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
1853 extern
1855  void** ptrarray1, /**< first pointer array to be sorted */
1856  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1857  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1858  int* intarray, /**< int array to be permuted in the same way */
1859  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1860  int len /**< length of arrays */
1861  );
1862 
1863 /** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
1864 extern
1866  void** ptrarray1, /**< first pointer array to be sorted */
1867  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1868  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1869  int* intarray1, /**< first int array to be permuted in the same way */
1870  int* intarray2, /**< second int array to be permuted in the same way */
1871  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1872  int len /**< length of arrays */
1873  );
1874 
1875 /** sort an array of Reals in non-increasing order */
1876 extern
1877 void SCIPsortDownReal(
1878  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1879  int len /**< length of arrays */
1880  );
1881 
1882 /** sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
1883 extern
1884 void SCIPsortDownRealPtr(
1885  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1886  void** ptrarray, /**< pointer array to be permuted in the same way */
1887  int len /**< length of arrays */
1888  );
1889 
1890 /** sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order */
1891 extern
1892 void SCIPsortDownRealInt(
1893  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1894  int* intarray, /**< pointer array to be permuted in the same way */
1895  int len /**< length of arrays */
1896  );
1897 
1898 /** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order */
1899 extern
1901  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1902  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1903  void** ptrarray, /**< pointer array to be permuted in the same way */
1904  int len /**< length of arrays */
1905  );
1906 
1907 /** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
1908 extern
1910  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1911  int* intarray, /**< int array to be permuted in the same way */
1912  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1913  int len /**< length of arrays */
1914  );
1915 
1916 /** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
1917 extern
1919  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1920  int* intarray, /**< int array to be permuted in the same way */
1921  void** ptrarray, /**< pointer array to be permuted in the same way */
1922  int len /**< length of arrays */
1923  );
1924 
1925 /** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
1926 extern
1928  SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
1929  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1930  void** ptrarray, /**< pointer array to be permuted in the same way */
1931  int len /**< length of arrays */
1932  );
1933 
1934 /** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
1935 extern
1937  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1938  void** ptrarray1, /**< pointer array to be permuted in the same way */
1939  void** ptrarray2, /**< pointer array to be permuted in the same way */
1940  int* intarray, /**< int array to be sorted */
1941  int len /**< length of arrays */
1942  );
1943 
1944 /** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
1945 extern
1947  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1948  void** ptrarray1, /**< pointer array to be permuted in the same way */
1949  void** ptrarray2, /**< pointer array to be permuted in the same way */
1950  int* intarray1, /**< int array to be sorted */
1951  int* intarray2, /**< int array to be sorted */
1952  int len /**< length of arrays */
1953  );
1954 
1955 /** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
1956 extern
1958  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1959  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1960  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1961  int* intarray, /**< int array to be permuted in the same way */
1962  int len /**< length of arrays */
1963  );
1964 
1965 /** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
1966 extern
1968  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1969  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1970  int* intarray1, /**< int array to be permuted in the same way */
1971  int* intarray2, /**< int array to be permuted in the same way */
1972  int len /**< length of arrays */
1973  );
1974 
1975 
1976 /** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
1977 extern
1979  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1980  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1981  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1982  int* intarray, /**< int array to be permuted in the same way */
1983  int len /**< length of arrays */
1984  );
1985 
1986 /** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
1987 extern
1989  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1990  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1991  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1992  void** ptrarray, /**< pointer array to be permuted in the same way */
1993  int len /**< length of arrays */
1994  );
1995 
1996 /** sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
1997 extern
1999  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2000  void** ptrarray1, /**< pointer array to be permuted in the same way */
2001  void** ptrarray2, /**< pointer array to be permuted in the same way */
2002  int len /**< length of arrays */
2003  );
2004 
2005 /** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
2006 extern
2008  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2009  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2010  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2011  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2012  void** ptrarray, /**< pointer array to be permuted in the same way */
2013  int len /**< length of arrays */
2014  );
2015 
2016 /** sort array of ints in non-increasing order */
2017 extern
2018 void SCIPsortDownInt(
2019  int* intarray, /**< int array to be sorted */
2020  int len /**< length of arrays */
2021  );
2022 
2023 /** sort of two joint arrays of ints/ints, sorted by first array in non-increasing order */
2024 extern
2025 void SCIPsortDownIntInt(
2026  int* intarray1, /**< int array to be sorted */
2027  int* intarray2, /**< second int array to be permuted in the same way */
2028  int len /**< length of arrays */
2029  );
2030 
2031 /** sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order */
2032 extern
2033 void SCIPsortDownIntPtr(
2034  int* intarray, /**< int array to be sorted */
2035  void** ptrarray, /**< pointer array to be permuted in the same way */
2036  int len /**< length of arrays */
2037  );
2038 
2039 /** sort of two joint arrays of ints/reals, sorted by first array in non-increasing order */
2040 extern
2041 void SCIPsortDownIntReal(
2042  int* intarray, /**< int array to be sorted */
2043  SCIP_Real* realarray, /**< real array to be permuted in the same way */
2044  int len /**< length of arrays */
2045  );
2046 
2047 /** sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
2048 extern
2050  int* intarray1, /**< int array to be sorted */
2051  int* intarray2, /**< second int array to be permuted in the same way */
2052  int* intarray3, /**< third int array to be permuted in the same way */
2053  int len /**< length of arrays */
2054  );
2055 
2056 /** sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
2057 extern
2059  int* intarray1, /**< int array to be sorted */
2060  int* intarray2, /**< second int array to be permuted in the same way */
2061  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2062  int len /**< length of arrays */
2063  );
2064 
2065 /** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
2066 extern
2068  int* intarray1, /**< int array to be sorted */
2069  int* intarray2, /**< second int array to be permuted in the same way */
2070  void** ptrarray, /**< pointer array to be permuted in the same way */
2071  int len /**< length of arrays */
2072  );
2073 
2074 /** sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
2075 extern
2077  int* intarray1, /**< int array to be sorted */
2078  int* intarray2, /**< second int array to be permuted in the same way */
2079  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2080  int len /**< length of arrays */
2081  );
2082 
2083 /** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order */
2084 extern
2086  int* intarray1, /**< int array to be sorted */
2087  int* intarray2, /**< int array to be permuted in the same way */
2088  int* intarray3, /**< int array to be permuted in the same way */
2089  void** ptrarray, /**< pointer array to be permuted in the same way */
2090  int len /**< length of arrays */
2091  );
2092 
2093 /** sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
2094 extern
2096  int* intarray1, /**< int array to be sorted */
2097  void** ptrarray, /**< pointer array to be permuted in the same way */
2098  int* intarray2, /**< int array to be permuted in the same way */
2099  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2100  int len /**< length of arrays */
2101  );
2102 
2103 /** sort an array of Longints in non-increasing order */
2104 extern
2105 void SCIPsortDownLong(
2106  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2107  int len /**< length of arrays */
2108  );
2109 
2110 /** sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
2111 extern
2112 void SCIPsortDownLongPtr(
2113  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2114  void** ptrarray, /**< pointer array to be permuted in the same way */
2115  int len /**< length of arrays */
2116  );
2117 
2118 /** sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
2119 extern
2121  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2122  void** ptrarray, /**< pointer array to be permuted in the same way */
2123  int* intarray, /**< int array to be permuted in the same way */
2124  int len /**< length of arrays */
2125  );
2126 
2127 /** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
2128 extern
2130  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2131  void** ptrarray, /**< pointer array to be permuted in the same way */
2132  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2133  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2134  int len /**< length of arrays */
2135  );
2136 
2137 /** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
2138 extern
2140  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2141  void** ptrarray, /**< pointer array to be permuted in the same way */
2142  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
2143  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2144  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2145  int len /**< length of arrays */
2146  );
2147 
2148 /** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
2149 extern
2151  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2152  void** ptrarray, /**< pointer array to be permuted in the same way */
2153  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
2154  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2155  int* intarray, /**< int array to be permuted in the same way */
2156  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2157  int len /**< length of arrays */
2158  );
2159 
2160 /** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
2161 extern
2163  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2164  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2165  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2166  int* intarray, /**< int array to be permuted in the same way */
2167  int len /**< length of arrays */
2168  );
2169 
2170 /** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
2171 extern
2173  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2174  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2175  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2176  int* intarray1, /**< first int array to be permuted in the same way */
2177  int* intarray2, /**< second int array to be permuted in the same way */
2178  int len /**< length of arrays */
2179  );
2180 
2181 /** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
2182 extern
2184  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2185  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2186  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2187  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2188  int* intarray, /**< int array to be sorted */
2189  int len /**< length of arrays */
2190  );
2191 
2192 /** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2193 extern
2195  void** ptrarray, /**< pointer array to be sorted */
2196  int* intarray1, /**< first int array to be permuted in the same way */
2197  int* intarray2, /**< second int array to be permuted in the same way */
2198  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2199  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2200  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2201  int len /**< length of arrays */
2202  );
2203 
2204 /** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2205 extern
2207  int* intarray1, /**< int array to be sorted */
2208  void** ptrarray, /**< pointer array to be permuted in the same way */
2209  int* intarray2, /**< second int array to be permuted in the same way */
2210  int* intarray3, /**< thrid int array to be permuted in the same way */
2211  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2212  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2213  int len /**< length of arrays */
2214  );
2215 
2216 /*
2217  * Sorted vectors
2218  */
2219 
2220 /* upwards insertion */
2221 
2222 /** insert a new element into an index array in non-decreasing order */
2223 extern
2225  int* indarray, /**< pointer to the index array where an element is to be inserted */
2226  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
2227  void* dataptr, /**< pointer to data field that is given to the external compare method */
2228  int keyval, /**< key value of new element */
2229  int* len, /**< pointer to length of arrays (will be increased by 1) */
2230  int* pos /**< pointer to store the insertion position, or NULL */
2231  );
2232 
2233 /** insert a new element into an array of pointers in non-decreasing order */
2234 extern
2236  void** ptrarray, /**< pointer to the pointer array where an element is to be inserted */
2237  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2238  void* keyval, /**< key value of new element */
2239  int* len, /**< pointer to length of arrays (will be increased by 1) */
2240  int* pos /**< pointer to store the insertion position, or NULL */
2241  );
2242 
2243 /** insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order */
2244 extern
2246  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2247  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2248  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2249  void* keyval, /**< key value of new element */
2250  void* field1val, /**< additional value of new element */
2251  int* len, /**< pointer to length of arrays (will be increased by 1) */
2252  int* pos /**< pointer to store the insertion position, or NULL */
2253  );
2254 
2255 /** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
2256 extern
2258  void** ptrarray, /**< pointer array where an element is to be inserted */
2259  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2260  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2261  void* keyval, /**< key value of new element */
2262  SCIP_Real field1val, /**< additional value of new element */
2263  int* len, /**< pointer to length of arrays (will be increased by 1) */
2264  int* pos /**< pointer to store the insertion position, or NULL */
2265  );
2266 
2267 /** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
2268 extern
2270  void** ptrarray, /**< pointer array where an element is to be inserted */
2271  int* intarray, /**< int array where an element is to be inserted */
2272  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2273  void* keyval, /**< key value of new element */
2274  int field1val, /**< additional value of new element */
2275  int* len, /**< pointer to length of arrays (will be increased by 1) */
2276  int* pos /**< pointer to store the insertion position, or NULL */
2277  );
2278 
2279 /** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
2280 extern
2282  void** ptrarray, /**< pointer array where an element is to be inserted */
2283  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2284  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2285  void* keyval, /**< key value of new element */
2286  SCIP_Bool field1val, /**< additional value of new element */
2287  int* len, /**< pointer to length of arrays (will be increased by 1) */
2288  int* pos /**< pointer to store the insertion position, or NULL */
2289  );
2290 
2291 /** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
2292 extern
2294  void** ptrarray, /**< pointer array where an element is to be inserted */
2295  int* intarray1, /**< first int array where an element is to be inserted */
2296  int* intarray2, /**< second int array where an element is to be inserted */
2297  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2298  void* keyval, /**< key value of new element */
2299  int field1val, /**< additional value of new element */
2300  int field2val, /**< additional value of new element */
2301  int* len, /**< pointer to length of arrays (will be increased by 1) */
2302  int* pos /**< pointer to store the insertion position, or NULL */
2303  );
2304 
2305 /** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
2306 extern
2308  void** ptrarray, /**< pointer array where an element is to be inserted */
2309  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2310  int* intarray, /**< int array where an element is to be inserted */
2311  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2312  void* keyval, /**< key value of new element */
2313  SCIP_Real field1val, /**< additional value of new element */
2314  int field2val, /**< additional value of new element */
2315  int* len, /**< pointer to length of arrays (will be increased by 1) */
2316  int* pos /**< pointer to store the insertion position, or NULL */
2317  );
2318 
2319 /** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
2320 extern
2322  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2323  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2324  int* intarray, /**< int array where an element is to be inserted */
2325  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2326  void* keyval, /**< key value of new element */
2327  void* field1val, /**< additional value of new element */
2328  int field2val, /**< 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 three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
2334 extern
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_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2339  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2340  void* keyval, /**< key value of new element */
2341  void* field1val, /**< additional value of new element */
2342  SCIP_Real field2val, /**< additional value of new element */
2343  int* len, /**< pointer to length of arrays (will be increased by 1) */
2344  int* pos /**< pointer to store the insertion position, or NULL */
2345  );
2346 
2347 /** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
2348 extern
2350  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2351  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2352  int* intarray1, /**< first int array where an element is to be inserted */
2353  int* intarray2, /**< second int array where an element is to be inserted */
2354  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2355  void* keyval, /**< key value of new element */
2356  void* field1val, /**< additional value of new element */
2357  int field2val, /**< additional value of new element */
2358  int field3val, /**< additional value of new element */
2359  int* len, /**< pointer to length of arrays (will be increased by 1) */
2360  int* pos /**< pointer to store the insertion position, or NULL */
2361  );
2362 
2363 /** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
2364 extern
2366  void** ptrarray, /**< pointer array where an element is to be inserted */
2367  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2368  int* intarray1, /**< first int array where an element is to be inserted */
2369  int* intarray2, /**< second int array where an element is to be inserted */
2370  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2371  void* keyval, /**< key value of new element */
2372  SCIP_Real field1val, /**< additional value of new element */
2373  int field2val, /**< additional value of new element */
2374  int field3val, /**< additional value of new element */
2375  int* len, /**< pointer to length of arrays (will be increased by 1) */
2376  int* pos /**< pointer to store the insertion position, or NULL */
2377  );
2378 
2379 /** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
2380 extern
2382  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2383  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2384  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2385  int* intarray, /**< int array to be sorted */
2386  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2387  void* keyval, /**< key value of new element */
2388  void* field1val, /**< additional value of new element */
2389  SCIP_Real field2val, /**< additional value of new element */
2390  int field3val, /**< additional value of new element */
2391  int* len, /**< pointer to length of arrays (will be increased by 1) */
2392  int* pos /**< pointer to store the insertion position, or NULL */
2393  );
2394 
2395 /** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
2396 extern
2398  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2399  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2400  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2401  int* intarray, /**< int array to be sorted */
2402  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2403  void* keyval, /**< key value of new element */
2404  void* field1val, /**< additional value of new element */
2405  SCIP_Longint field2val, /**< additional value of new element */
2406  int field3val, /**< additional value of new element */
2407  int* len, /**< pointer to length of arrays (will be increased by 1) */
2408  int* pos /**< pointer to store the insertion position, or NULL */
2409  );
2410 
2411 /** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
2412 extern
2414  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2415  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2416  SCIP_Longint* longarray, /**< SCIP_Longint where an element is to be inserted */
2417  int* intarray1, /**< first int array where an element is to be inserted */
2418  int* intarray2, /**< second int array where an element is to be inserted */
2419  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2420  void* keyval, /**< key value of new element */
2421  void* field1val, /**< additional value of new element */
2422  SCIP_Longint field2val, /**< additional value of new element */
2423  int field3val, /**< additional value of new element */
2424  int field4val, /**< additional value of new element */
2425  int* len, /**< pointer to length of arrays (will be increased by 1) */
2426  int* pos /**< pointer to store the insertion position, or NULL */
2427  );
2428 
2429 /** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
2430 extern
2432  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2433  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2434  void** ptrarray, /**< pointer array to be permuted in the same way */
2435  SCIP_Real keyval, /**< key value of new element */
2436  SCIP_Bool field1val, /**< additional value of new element */
2437  void* field2val, /**< additional value of new element */
2438  int* len, /**< pointer to length of arrays (will be increased by 1) */
2439  int* pos /**< pointer to store the insertion position, or NULL */
2440  );
2441 
2442 /** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
2443 extern
2445  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2446  void** ptrarray, /**< pointer array where an element is to be inserted */
2447  SCIP_Real keyval, /**< key value of new element */
2448  void* field1val, /**< additional value of new element */
2449  int* len, /**< pointer to length of arrays (will be increased by 1) */
2450  int* pos /**< pointer to store the insertion position, or NULL */
2451  );
2452 
2453 /** insert a new element into an arrays of Reals, sorted in non-decreasing order */
2454 extern
2456  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2457  SCIP_Real keyval, /**< key value of new element */
2458  int* len, /**< pointer to length of arrays (will be increased by 1) */
2459  int* pos /**< pointer to store the insertion position, or NULL */
2460  );
2461 
2462 /** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
2463 extern
2465  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2466  int* intarray, /**< int array where an element is to be inserted */
2467  SCIP_Real keyval, /**< key value of new element */
2468  int field1val, /**< additional value of new element */
2469  int* len, /**< pointer to length of arrays (will be increased by 1) */
2470  int* pos /**< pointer to store the insertion position, or NULL */
2471  );
2472 
2473 /** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
2474 extern
2476  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2477  int* intarray, /**< int array to be permuted in the same way */
2478  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2479  SCIP_Real keyval, /**< key value of new element */
2480  int field1val, /**< additional value of new element */
2481  SCIP_Longint field2val, /**< additional value of new element */
2482  int* len, /**< pointer to length of arrays (will be increased by 1) */
2483  int* pos /**< pointer to store the insertion position, or NULL */
2484  );
2485 
2486 /** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
2487 extern
2489  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2490  int* intarray, /**< int array where an element is to be inserted */
2491  void** ptrarray, /**< pointer array where an element is to be inserted */
2492  SCIP_Real keyval, /**< key value of new element */
2493  int field1val, /**< additional value of new element */
2494  void* field2val, /**< additional value of new element */
2495  int* len, /**< pointer to length of arrays (will be increased by 1) */
2496  int* pos /**< pointer to store the insertion position, or NULL */
2497  );
2498 
2499 /** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
2500 extern
2502  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2503  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2504  void** ptrarray, /**< pointer array where an element is to be inserted */
2505  SCIP_Real keyval, /**< key value of new element */
2506  SCIP_Real field1val, /**< additional value of new element */
2507  void* field2val, /**< additional value of new element */
2508  int* len, /**< pointer to length of arrays (will be increased by 1) */
2509  int* pos /**< pointer to store the insertion position, or NULL */
2510  );
2511 
2512 /** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
2513 extern
2515  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2516  void** ptrarray1, /**< pointer array where an element is to be inserted */
2517  void** ptrarray2, /**< pointer array where an element is to be inserted */
2518  int* intarray, /**< int array where an element is to be inserted */
2519  SCIP_Real keyval, /**< key value of new element */
2520  void* field1val, /**< additional value of new element */
2521  void* field2val, /**< additional value of new element */
2522  int intval, /**< additional value of new element */
2523  int* len, /**< pointer to length of arrays (will be increased by 1) */
2524  int* pos /**< pointer to store the insertion position, or NULL */
2525  );
2526 
2527 /** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
2528 extern
2530  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2531  void** ptrarray1, /**< pointer array where an element is to be inserted */
2532  void** ptrarray2, /**< pointer array where an element is to be inserted */
2533  int* intarray1, /**< int array where an element is to be inserted */
2534  int* intarray2, /**< int array where an element is to be inserted */
2535  SCIP_Real keyval, /**< key value of new element */
2536  void* field1val, /**< additional value of new element */
2537  void* field2val, /**< additional value of new element */
2538  int intval1, /**< additional value of new element */
2539  int intval2, /**< additional value of new element */
2540  int* len, /**< pointer to length of arrays (will be increased by 1) */
2541  int* pos /**< pointer to store the insertion position, or NULL */
2542  );
2543 
2544 /** insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
2545 extern
2547  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
2548  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2549  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
2550  int* intarray, /**< int array where an element is to be inserted */
2551  SCIP_Real keyval, /**< key value of new element */
2552  SCIP_Longint field1val, /**< additional value of new element */
2553  SCIP_Real field2val, /**< additional value of new element */
2554  int field3val, /**< additional value of new element */
2555  int* len, /**< pointer to length of arrays (will be increased by 1) */
2556  int* pos /**< pointer to store the insertion position, or NULL */
2557  );
2558 
2559 /** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
2560 extern
2562  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2563  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2564  int* intarray1, /**< first int array where an element is to be inserted */
2565  int* intarray2, /**< second int array where an element is to be inserted */
2566  SCIP_Real keyval, /**< key value of new element */
2567  SCIP_Real field1val, /**< additional value of new element */
2568  int field2val, /**< additional value of new element */
2569  int field3val, /**< additional value of new element */
2570  int* len, /**< pointer to length of arrays (will be increased by 1) */
2571  int* pos /**< pointer to store the insertion position, or NULL */
2572  );
2573 
2574 /** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
2575 extern
2577  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2578  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2579  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2580  int* intarray, /**< int array where an element is to be inserted */
2581  SCIP_Real keyval, /**< key value of new element */
2582  SCIP_Real field1val, /**< additional value of new element */
2583  SCIP_Real field2val, /**< additional value of new element */
2584  int field3val, /**< additional value of new element */
2585  int* len, /**< pointer to length of arrays (will be increased by 1) */
2586  int* pos /**< pointer to store the insertion position, or NULL */
2587  );
2588 
2589 /** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
2590 extern
2592  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2593  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2594  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2595  void** ptrarray, /**< pointer array where an element is to be inserted */
2596  SCIP_Real keyval, /**< key value of new element */
2597  SCIP_Real field1val, /**< additional value of new element */
2598  SCIP_Real field2val, /**< additional value of new element */
2599  void* field3val, /**< additional value of new element */
2600  int* len, /**< pointer to length of arrays (will be increased by 1) */
2601  int* pos /**< pointer to store the insertion position, or NULL */
2602  );
2603 
2604 /** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
2605 extern
2607  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2608  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2609  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2610  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2611  void** ptrarray, /**< pointer array where an element is to be inserted */
2612  SCIP_Real keyval, /**< key value of new element */
2613  SCIP_Real field1val, /**< additional value of new element */
2614  SCIP_Real field2val, /**< additional value of new element */
2615  SCIP_Bool field3val, /**< additional value of new element */
2616  void* field4val, /**< additional value of new element */
2617  int* len, /**< pointer to length of arrays (will be increased by 1) */
2618  int* pos /**< pointer to store the insertion position, or NULL */
2619  );
2620 
2621 /** insert a new element into an array of ints in non-decreasing order */
2622 extern
2624  int* intarray, /**< int array where an element is to be inserted */
2625  int keyval, /**< key value of new element */
2626  int* len, /**< pointer to length of arrays (will be increased by 1) */
2627  int* pos /**< pointer to store the insertion position, or NULL */
2628  );
2629 
2630 /** insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order */
2631 extern
2633  int* intarray1, /**< int array where an element is to be inserted */
2634  int* intarray2, /**< second int array where an element is to be inserted */
2635  int keyval, /**< key value of new element */
2636  int field1val, /**< additional value of new element */
2637  int* len, /**< pointer to length of arrays (will be increased by 1) */
2638  int* pos /**< pointer to store the insertion position, or NULL */
2639  );
2640 
2641 /** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
2642 extern
2644  int* intarray, /**< int array where an element is to be inserted */
2645  void** ptrarray, /**< pointer array where an element is to be inserted */
2646  int keyval, /**< key value of new element */
2647  void* field1val, /**< additional value of new element */
2648  int* len, /**< pointer to length of arrays (will be increased by 1) */
2649  int* pos /**< pointer to store the insertion position, or NULL */
2650  );
2651 
2652 /** insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order */
2653 extern
2655  int* intarray, /**< int array where an element is to be inserted */
2656  SCIP_Real* realarray, /**< real array where an element is to be inserted */
2657  int keyval, /**< key value of new element */
2658  SCIP_Real field1val, /**< additional value of new element */
2659  int* len, /**< pointer to length of arrays (will be increased by 1) */
2660  int* pos /**< pointer to store the insertion position, or NULL */
2661  );
2662 
2663 /** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
2664 extern
2666  int* intarray1, /**< int array where an element is to be inserted */
2667  int* intarray2, /**< second int array where an element is to be inserted */
2668  int* intarray3, /**< third int array where an element is to be inserted */
2669  int keyval, /**< key value of new element */
2670  int field1val, /**< additional value of new element */
2671  int field2val, /**< additional value of new element */
2672  int* len, /**< pointer to length of arrays (will be increased by 1) */
2673  int* pos /**< pointer to store the insertion position, or NULL */
2674  );
2675 
2676 /** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
2677 extern
2679  int* intarray1, /**< int array where an element is to be inserted */
2680  int* intarray2, /**< second int array where an element is to be inserted */
2681  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2682  int keyval, /**< key value of new element */
2683  int field1val, /**< additional value of new element */
2684  SCIP_Longint field2val, /**< additional value of new element */
2685  int* len, /**< pointer to length of arrays (will be increased by 1) */
2686  int* pos /**< pointer to store the insertion position, or NULL */
2687  );
2688 
2689 /** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
2690 extern
2692  int* intarray1, /**< first int array where an element is to be inserted */
2693  int* intarray2, /**< second int array where an element is to be inserted */
2694  void** ptrarray, /**< pointer array where an element is to be inserted */
2695  int keyval, /**< key value of new element */
2696  int field1val, /**< additional value of new element */
2697  void* field2val, /**< additional value of new element */
2698  int* len, /**< pointer to length of arrays (will be increased by 1) */
2699  int* pos /**< pointer to store the insertion position, or NULL */
2700  );
2701 
2702 /** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
2703 extern
2705  int* intarray1, /**< first int array where an element is to be inserted */
2706  int* intarray2, /**< second int array where an element is to be inserted */
2707  SCIP_Real* realarray, /**< real array where an element is to be inserted */
2708  int keyval, /**< key value of new element */
2709  int field1val, /**< additional value of new element */
2710  SCIP_Real field2val, /**< additional value of new element */
2711  int* len, /**< pointer to length of arrays (will be increased by 1) */
2712  int* pos /**< pointer to store the insertion position, or NULL */
2713  );
2714 
2715 /** insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
2716 extern
2718  int* intarray, /**< int array where an element is to be inserted */
2719  void** ptrarray, /**< pointer array where an element is to be inserted */
2720  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2721  int keyval, /**< key value of new element */
2722  void* field1val, /**< additional value of new element */
2723  SCIP_Real field2val, /**< additional value of new element */
2724  int* len, /**< pointer to length of arrays (will be increased by 1) */
2725  int* pos /**< pointer to store the insertion position, or NULL */
2726  );
2727 
2728 /** insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
2729 extern
2731  int* intarray1, /**< first int array where an element is to be inserted */
2732  int* intarray2, /**< second int array where an element is to be inserted */
2733  int* intarray3, /**< second int array where an element is to be inserted */
2734  void** ptrarray, /**< pointer array where an element is to be inserted */
2735  int keyval, /**< key value of new element */
2736  int field1val, /**< additional value of new element */
2737  int field2val, /**< additional value of new element */
2738  void* field3val, /**< additional value of new element */
2739  int* len, /**< pointer to length of arrays (will be increased by 1) */
2740  int* pos /**< pointer to store the insertion position, or NULL */
2741  );
2742 
2743 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
2744 extern
2746  int* intarray1, /**< first int array where an element is to be inserted */
2747  void** ptrarray, /**< pointer array where an element is to be inserted */
2748  int* intarray2, /**< second int array where an element is to be inserted */
2749  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2750  int keyval, /**< key value of new element */
2751  void* field1val, /**< additional value of new element */
2752  int field2val, /**< additional value of new element */
2753  SCIP_Real field3val, /**< additional value of new element */
2754  int* len, /**< pointer to length of arrays (will be increased by 1) */
2755  int* pos /**< pointer to store the insertion position, or NULL */
2756  );
2757 
2758 /** insert a new element into an array of Longints, sorted in non-decreasing order */
2759 extern
2761  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2762  SCIP_Longint keyval, /**< key value of new element */
2763  int* len, /**< pointer to length of arrays (will be increased by 1) */
2764  int* pos /**< pointer to store the insertion position, or NULL */
2765  );
2766 
2767 /** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
2768 extern
2770  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2771  void** ptrarray, /**< pointer array where an element is to be inserted */
2772  SCIP_Longint keyval, /**< key value of new element */
2773  void* field1val, /**< additional value of new element */
2774  int* len, /**< pointer to length of arrays (will be increased by 1) */
2775  int* pos /**< pointer to store the insertion position, or NULL */
2776  );
2777 
2778 /** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
2779 extern
2781  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2782  void** ptrarray, /**< pointer array where an element is to be inserted */
2783  int* intarray, /**< int array where an element is to be inserted */
2784  SCIP_Longint keyval, /**< key value of new element */
2785  void* field1val, /**< additional value of new element */
2786  int field2val, /**< additional value of new element */
2787  int* len, /**< pointer to length of arrays (will be increased by 1) */
2788  int* pos /**< pointer to store the insertion position, or NULL */
2789  );
2790 
2791 /** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
2792 extern
2794  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2795  void** ptrarray, /**< pointer array where an element is to be inserted */
2796  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2797  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2798  SCIP_Longint keyval, /**< key value of new element */
2799  void* field1val, /**< additional value of new element */
2800  SCIP_Real field2val, /**< additional value of new element */
2801  SCIP_Bool field3val, /**< additional value of new element */
2802  int* len, /**< pointer to length of arrays (will be increased by 1) */
2803  int* pos /**< pointer to store the insertion position, or NULL */
2804  );
2805 
2806 /** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
2807 extern
2809  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2810  void** ptrarray, /**< pointer array where an element is to be inserted */
2811  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
2812  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2813  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2814  SCIP_Longint keyval, /**< key value of new element */
2815  void* field1val, /**< additional value of new element */
2816  SCIP_Real field2val, /**< additional value of new element */
2817  SCIP_Real field3val, /**< additional value of new element */
2818  SCIP_Bool field4val, /**< additional value of new element */
2819  int* len, /**< pointer to length of arrays (will be increased by 1) */
2820  int* pos /**< pointer to store the insertion position, or NULL */
2821  );
2822 
2823 /** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
2824 extern
2826  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2827  void** ptrarray, /**< pointer array where an element is to be inserted */
2828  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
2829  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2830  int* intarray, /**< int array where an element is to be inserted */
2831  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2832  SCIP_Longint keyval, /**< key value of new element */
2833  void* field1val, /**< additional value of new element */
2834  SCIP_Real field2val, /**< additional value of new element */
2835  SCIP_Real field3val, /**< additional value of new element */
2836  int field4val, /**< additional value of new element */
2837  SCIP_Bool field5val, /**< additional value of new element */
2838  int* len, /**< pointer to length of arrays (will be increased by 1) */
2839  int* pos /**< pointer to store the insertion position, or NULL */
2840  );
2841 
2842 /** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
2843 extern
2845  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2846  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2847  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2848  int* intarray, /**< int array where an element is to be inserted */
2849  SCIP_Longint keyval, /**< key value of new element */
2850  void* field1val, /**< additional value of new element */
2851  void* field2val, /**< additional value of new element */
2852  int field3val, /**< additional value of new element */
2853  int* len, /**< pointer to length of arrays (will be increased by 1) */
2854  int* pos /**< pointer to store the insertion position, or NULL */
2855  );
2856 
2857 /** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
2858 extern
2860  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2861  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2862  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2863  int* intarray1, /**< first int array where an element is to be inserted */
2864  int* intarray2, /**< second int array where an element is to be inserted */
2865  SCIP_Longint keyval, /**< key value of new element */
2866  void* field1val, /**< additional value of new element */
2867  void* field2val, /**< additional value of new element */
2868  int field3val, /**< additional value of new element */
2869  int field4val, /**< additional value of new element */
2870  int* len, /**< pointer to length of arrays (will be increased by 1) */
2871  int* pos /**< pointer to store the insertion position, or NULL */
2872  );
2873 
2874 /** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
2875 extern
2877  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2878  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2879  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2880  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2881  int* intarray, /**< int array to be sorted */
2882  SCIP_Longint keyval, /**< key value of new element */
2883  void* field1val, /**< additional value of new element */
2884  void* field2val, /**< additional value of new element */
2885  SCIP_Bool field3val, /**< additional value of new element */
2886  int field4val, /**< additional value of new element */
2887  int* len, /**< pointer to length of arrays (will be increased by 1) */
2888  int* pos /**< pointer to store the insertion position, or NULL */
2889  );
2890 
2891 /** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
2892 extern
2894  void** ptrarray, /**< pointer array to be sorted */
2895  int* intarray1, /**< first int array to be permuted in the same way */
2896  int* intarray2, /**< second int array to be permuted in the same way */
2897  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2898  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2899  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2900  void* keyval, /**< key value of new element */
2901  int field1val, /**< additional value of new element */
2902  int field2val, /**< additional value of new element */
2903  SCIP_Bool field3val, /**< additional value of new element */
2904  SCIP_Bool field4val, /**< additional value of new element */
2905  int* len, /**< pointer to length of arrays (will be increased by 1) */
2906  int* pos /**< pointer to store the insertion position, or NULL */
2907  );
2908 
2909 /** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
2910 extern
2912  int* intarray1, /**< int array to be sorted */
2913  void** ptrarray, /**< pointer array to be permuted in the same way */
2914  int* intarray2, /**< second int array to be permuted in the same way */
2915  int* intarray3, /**< thrid int array to be permuted in the same way */
2916  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2917  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2918  int keyval, /**< key value of new element */
2919  void* field1val, /**< additional value of new element */
2920  int field2val, /**< additional value of new element */
2921  int field3val, /**< additional value of new element */
2922  SCIP_Bool field4val, /**< additional value of new element */
2923  SCIP_Bool field5val, /**< additional value of new element */
2924  int* len, /**< pointer to length of arrays (will be increased by 1) */
2925  int* pos /**< pointer to store the insertion position, or NULL */
2926  );
2927 
2928 
2929 /* downwards insertion */
2930 
2931 /** insert a new element into an index array in non-increasing order */
2932 extern
2934  int* indarray, /**< pointer to the index array where an element is to be inserted */
2935  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
2936  void* dataptr, /**< pointer to data field that is given to the external compare method */
2937  int keyval, /**< key value of new element */
2938  int* len, /**< pointer to length of arrays (will be increased by 1) */
2939  int* pos /**< pointer to store the insertion position, or NULL */
2940  );
2941 
2942 /** insert a new element into an array of pointers in non-increasing order */
2943 extern
2945  void** ptrarray, /**< pointer array where an element is to be inserted */
2946  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2947  void* keyval, /**< key value of new element */
2948  int* len, /**< pointer to length of arrays (will be increased by 1) */
2949  int* pos /**< pointer to store the insertion position, or NULL */
2950  );
2951 
2952 /** insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
2953 extern
2955  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2956  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2957  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2958  void* keyval, /**< key value of new element */
2959  void* field1val, /**< additional value of new element */
2960  int* len, /**< pointer to length of arrays (will be increased by 1) */
2961  int* pos /**< pointer to store the insertion position, or NULL */
2962  );
2963 
2964 /** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
2965 extern
2967  void** ptrarray, /**< pointer array where an element is to be inserted */
2968  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2969  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2970  void* keyval, /**< key value of new element */
2971  SCIP_Real field1val, /**< additional value of new element */
2972  int* len, /**< pointer to length of arrays (will be increased by 1) */
2973  int* pos /**< pointer to store the insertion position, or NULL */
2974  );
2975 
2976 /** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order */
2977 extern
2979  void** ptrarray, /**< pointer array where an element is to be inserted */
2980  int* intarray, /**< int array where an element is to be inserted */
2981  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2982  void* keyval, /**< key value of new element */
2983  int field1val, /**< additional value of new element */
2984  int* len, /**< pointer to length of arrays (will be increased by 1) */
2985  int* pos /**< pointer to store the insertion position, or NULL */
2986  );
2987 
2988 /** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
2989 extern
2991  void** ptrarray, /**< pointer array where an element is to be inserted */
2992  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2993  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2994  void* keyval, /**< key value of new element */
2995  SCIP_Bool field1val, /**< additional value of new element */
2996  int* len, /**< pointer to length of arrays (will be increased by 1) */
2997  int* pos /**< pointer to store the insertion position, or NULL */
2998  );
2999 
3000 /** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
3001 extern
3003  void** ptrarray, /**< pointer array where an element is to be inserted */
3004  int* intarray1, /**< first int array where an element is to be inserted */
3005  int* intarray2, /**< second int array where an element is to be inserted */
3006  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3007  void* keyval, /**< key value of new element */
3008  int field1val, /**< additional value of new element */
3009  int field2val, /**< additional value of new element */
3010  int* len, /**< pointer to length of arrays (will be increased by 1) */
3011  int* pos /**< pointer to store the insertion position, or NULL */
3012  );
3013 
3014 /** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
3015 extern
3017  void** ptrarray, /**< pointer array where an element is to be inserted */
3018  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3019  int* intarray, /**< int array where an element is to be inserted */
3020  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3021  void* keyval, /**< key value of new element */
3022  SCIP_Real field1val, /**< additional value of new element */
3023  int field2val, /**< additional value of new element */
3024  int* len, /**< pointer to length of arrays (will be increased by 1) */
3025  int* pos /**< pointer to store the insertion position, or NULL */
3026  );
3027 
3028 /** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
3029 extern
3031  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3032  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3033  int* intarray, /**< int array where an element is to be inserted */
3034  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3035  void* keyval, /**< key value of new element */
3036  void* field1val, /**< additional value of new element */
3037  int field2val, /**< additional value of new element */
3038  int* len, /**< pointer to length of arrays (will be increased by 1) */
3039  int* pos /**< pointer to store the insertion position, or NULL */
3040  );
3041 
3042 /** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
3043 extern
3045  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3046  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3047  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3048  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3049  void* keyval, /**< key value of new element */
3050  void* field1val, /**< additional value of new element */
3051  SCIP_Real field2val, /**< additional value of new element */
3052  int* len, /**< pointer to length of arrays (will be increased by 1) */
3053  int* pos /**< pointer to store the insertion position, or NULL */
3054  );
3055 
3056 /** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3057 extern
3059  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3060  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3061  int* intarray1, /**< first int array where an element is to be inserted */
3062  int* intarray2, /**< second int array where an element is to be inserted */
3063  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3064  void* keyval, /**< key value of new element */
3065  void* field1val, /**< additional value of new element */
3066  int field2val, /**< additional value of new element */
3067  int field3val, /**< additional value of new element */
3068  int* len, /**< pointer to length of arrays (will be increased by 1) */
3069  int* pos /**< pointer to store the insertion position, or NULL */
3070  );
3071 
3072 /** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
3073 extern
3075  void** ptrarray, /**< pointer array where an element is to be inserted */
3076  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3077  int* intarray1, /**< first int array where an element is to be inserted */
3078  int* intarray2, /**< second int array where an element is to be inserted */
3079  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3080  void* keyval, /**< key value of new element */
3081  SCIP_Real field1val, /**< additional value of new element */
3082  int field2val, /**< additional value of new element */
3083  int field3val, /**< additional value of new element */
3084  int* len, /**< pointer to length of arrays (will be increased by 1) */
3085  int* pos /**< pointer to store the insertion position, or NULL */
3086  );
3087 
3088 /** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
3089 extern
3091  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3092  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3093  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3094  int* intarray, /**< int array where an element is to be inserted */
3095  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3096  void* keyval, /**< key value of new element */
3097  void* field1val, /**< additional value of new element */
3098  SCIP_Real field2val, /**< additional value of new element */
3099  int field3val, /**< additional value of new element */
3100  int* len, /**< pointer to length of arrays (will be increased by 1) */
3101  int* pos /**< pointer to store the insertion position, or NULL */
3102  );
3103 
3104 /** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
3105 extern
3107  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3108  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3109  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3110  int* intarray, /**< int array where an element is to be inserted */
3111  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3112  void* keyval, /**< key value of new element */
3113  void* field1val, /**< additional value of new element */
3114  SCIP_Longint field2val, /**< additional value of new element */
3115  int field3val, /**< additional value of new element */
3116  int* len, /**< pointer to length of arrays (will be increased by 1) */
3117  int* pos /**< pointer to store the insertion position, or NULL */
3118  );
3119 
3120 /** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
3121 extern
3123  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3124  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3125  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3126  int* intarray1, /**< first int array where an element is to be inserted */
3127  int* intarray2, /**< second int array where an element is to be inserted */
3128  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3129  void* keyval, /**< key value of new element */
3130  void* field1val, /**< additional value of new element */
3131  SCIP_Longint field2val, /**< additional value of new element */
3132  int field3val, /**< additional value of new element */
3133  int field4val, /**< additional value of new element */
3134  int* len, /**< pointer to length of arrays (will be increased by 1) */
3135  int* pos /**< pointer to store the insertion position, or NULL */
3136  );
3137 
3138 /** insert a new element into an array of Reals, sorted in non-increasing order */
3139 extern
3141  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3142  SCIP_Real keyval, /**< key value of new element */
3143  int* len, /**< pointer to length of arrays (will be increased by 1) */
3144  int* pos /**< pointer to store the insertion position, or NULL */
3145  );
3146 
3147 /** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
3148 extern
3150  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3151  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
3152  void** ptrarray, /**< pointer array to be permuted in the same way */
3153  SCIP_Real keyval, /**< key value of new element */
3154  SCIP_Bool field1val, /**< additional value of new element */
3155  void* field2val, /**< additional value of new element */
3156  int* len, /**< pointer to length of arrays (will be increased by 1) */
3157  int* pos /**< pointer to store the insertion position, or NULL */
3158  );
3159 
3160 /** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3161 extern
3163  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3164  void** ptrarray, /**< pointer array where an element is to be inserted */
3165  SCIP_Real keyval, /**< key value of new element */
3166  void* field1val, /**< additional value of new element */
3167  int* len, /**< pointer to length of arrays (will be increased by 1) */
3168  int* pos /**< pointer to store the insertion position, or NULL */
3169  );
3170 
3171 /** insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3172 extern
3174  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3175  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3176  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3177  SCIP_Real keyval, /**< key value of new element */
3178  void* field1val, /**< additional value of new element */
3179  void* field2val, /**< additional value of new element */
3180  int* len, /**< pointer to length of arrays (will be increased by 1) */
3181  int* pos /**< pointer to store the insertion position, or NULL */
3182  );
3183 
3184 /** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order */
3185 extern
3187  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3188  int* intarray, /**< int array where an element is to be inserted */
3189  SCIP_Real keyval, /**< key value of new element */
3190  int field1val, /**< additional value of new element */
3191  int* len, /**< pointer to length of arrays (will be increased by 1) */
3192  int* pos /**< pointer to store the insertion position, or NULL */
3193  );
3194 
3195 /** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
3196 extern
3198  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3199  int* intarray, /**< int array to be permuted in the same way */
3200  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
3201  SCIP_Real keyval, /**< key value of new element */
3202  int field1val, /**< additional value of new element */
3203  SCIP_Longint field2val, /**< additional value of new element */
3204  int* len, /**< pointer to length of arrays (will be increased by 1) */
3205  int* pos /**< pointer to store the insertion position, or NULL */
3206  );
3207 
3208 /** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
3209 extern
3211  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3212  int* intarray, /**< int array where an element is to be inserted */
3213  void** ptrarray, /**< pointer array where an element is to be inserted */
3214  SCIP_Real keyval, /**< key value of new element */
3215  int field1val, /**< additional value of new element */
3216  void* field2val, /**< additional value of new element */
3217  int* len, /**< pointer to length of arrays (will be increased by 1) */
3218  int* pos /**< pointer to store the insertion position, or NULL */
3219  );
3220 
3221 /** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
3222 extern
3224  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
3225  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3226  void** ptrarray, /**< pointer array where an element is to be inserted */
3227  SCIP_Real keyval, /**< key value of new element */
3228  SCIP_Real field1val, /**< additional value of new element */
3229  void* field2val, /**< additional value of new element */
3230  int* len, /**< pointer to length of arrays (will be increased by 1) */
3231  int* pos /**< pointer to store the insertion position, or NULL */
3232  );
3233 
3234 /** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
3235 extern
3237  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3238  void** ptrarray1, /**< pointer array where an element is to be inserted */
3239  void** ptrarray2, /**< pointer array where an element is to be inserted */
3240  int* intarray, /**< int array where an element is to be inserted */
3241  SCIP_Real keyval, /**< key value of new element */
3242  void* field1val, /**< additional value of new element */
3243  void* field2val, /**< additional value of new element */
3244  int intval, /**< additional value of new element */
3245  int* len, /**< pointer to length of arrays (will be increased by 1) */
3246  int* pos /**< pointer to store the insertion position, or NULL */
3247  );
3248 
3249 /** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3250 extern
3252  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3253  void** ptrarray1, /**< pointer array where an element is to be inserted */
3254  void** ptrarray2, /**< pointer array where an element is to be inserted */
3255  int* intarray1, /**< int array where an element is to be inserted */
3256  int* intarray2, /**< int array where an element is to be inserted */
3257  SCIP_Real keyval, /**< key value of new element */
3258  void* field1val, /**< additional value of new element */
3259  void* field2val, /**< additional value of new element */
3260  int intval1, /**< additional value of new element */
3261  int intval2, /**< additional value of new element */
3262  int* len, /**< pointer to length of arrays (will be increased by 1) */
3263  int* pos /**< pointer to store the insertion position, or NULL */
3264  );
3265 
3266 /** insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
3267 extern
3269  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3270  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3271  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3272  int* intarray, /**< int array where an element is to be inserted */
3273  SCIP_Real keyval, /**< key value of new element */
3274  SCIP_Longint field1val, /**< additional value of new element */
3275  SCIP_Real field2val, /**< additional value of new element */
3276  int field3val, /**< additional value of new element */
3277  int* len, /**< pointer to length of arrays (will be increased by 1) */
3278  int* pos /**< pointer to store the insertion position, or NULL */
3279  );
3280 
3281 /** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
3282 extern
3284  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
3285  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3286  int* intarray1, /**< first int array where an element is to be inserted */
3287  int* intarray2, /**< second int array where an element is to be inserted */
3288  SCIP_Real keyval, /**< key value of new element */
3289  SCIP_Real field1val, /**< additional value of new element */
3290  int field2val, /**< additional value of new element */
3291  int field3val, /**< additional value of new element */
3292  int* len, /**< pointer to length of arrays (will be increased by 1) */
3293  int* pos /**< pointer to store the insertion position, or NULL */
3294  );
3295 
3296 /** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
3297 extern
3299  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3300  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3301  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3302  int* intarray, /**< int array where an element is to be inserted */
3303  SCIP_Real keyval, /**< key value of new element */
3304  SCIP_Real field1val, /**< additional value of new element */
3305  SCIP_Real field2val, /**< additional value of new element */
3306  int field3val, /**< additional value of new element */
3307  int* len, /**< pointer to length of arrays (will be increased by 1) */
3308  int* pos /**< pointer to store the insertion position, or NULL */
3309  );
3310 
3311 /** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
3312 extern
3314  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3315  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3316  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3317  void** ptrarray, /**< pointer array where an element is to be inserted */
3318  SCIP_Real keyval, /**< key value of new element */
3319  SCIP_Real field1val, /**< additional value of new element */
3320  SCIP_Real field2val, /**< additional value of new element */
3321  void* field3val, /**< additional value of new element */
3322  int* len, /**< pointer to length of arrays (will be increased by 1) */
3323  int* pos /**< pointer to store the insertion position, or NULL */
3324  );
3325 
3326 /** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
3327 extern
3329  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3330  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3331  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3332  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3333  void** ptrarray, /**< pointer array where an element is to be inserted */
3334  SCIP_Real keyval, /**< key value of new element */
3335  SCIP_Real field1val, /**< additional value of new element */
3336  SCIP_Real field2val, /**< additional value of new element */
3337  SCIP_Bool field3val, /**< additional value of new element */
3338  void* field4val, /**< additional value of new element */
3339  int* len, /**< pointer to length of arrays (will be increased by 1) */
3340  int* pos /**< pointer to store the insertion position, or NULL */
3341  );
3342 
3343 /** insert a new element into an array of ints in non-increasing order */
3344 extern
3346  int* intarray, /**< int array where an element is to be inserted */
3347  int keyval, /**< key value of new element */
3348  int* len, /**< pointer to length of arrays (will be increased by 1) */
3349  int* pos /**< pointer to store the insertion position, or NULL */
3350  );
3351 
3352 /** insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order */
3353 extern
3355  int* intarray1, /**< int array where an element is to be inserted */
3356  int* intarray2, /**< second int array where an element is to be inserted */
3357  int keyval, /**< key value of new element */
3358  int field1val, /**< additional value of new element */
3359  int* len, /**< pointer to length of arrays (will be increased by 1) */
3360  int* pos /**< pointer to store the insertion position, or NULL */
3361  );
3362 
3363 /** insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order */
3364 extern
3366  int* intarray, /**< int array where an element is to be inserted */
3367  SCIP_Real* realarray, /**< real array where an element is to be inserted */
3368  int keyval, /**< key value of new element */
3369  SCIP_Real field1val, /**< additional value of new element */
3370  int* len, /**< pointer to length of arrays (will be increased by 1) */
3371  int* pos /**< pointer to store the insertion position, or NULL */
3372  );
3373 
3374 /** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
3375 extern
3377  int* intarray1, /**< int array where an element is to be inserted */
3378  int* intarray2, /**< second int array where an element is to be inserted */
3379  int* intarray3, /**< third int array where an element is to be inserted */
3380  int keyval, /**< key value of new element */
3381  int field1val, /**< additional value of new element */
3382  int field2val, /**< additional value of new element */
3383  int* len, /**< pointer to length of arrays (will be increased by 1) */
3384  int* pos /**< pointer to store the insertion position, or NULL */
3385  );
3386 
3387 /** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
3388 extern
3390  int* intarray1, /**< int array where an element is to be inserted */
3391  int* intarray2, /**< second int array where an element is to be inserted */
3392  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3393  int keyval, /**< key value of new element */
3394  int field1val, /**< additional value of new element */
3395  SCIP_Longint field2val, /**< additional value of new element */
3396  int* len, /**< pointer to length of arrays (will be increased by 1) */
3397  int* pos /**< pointer to store the insertion position, or NULL */
3398  );
3399 
3400 /** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
3401 extern
3403  int* intarray1, /**< int array where an element is to be inserted */
3404  int* intarray2, /**< second int array where an element is to be inserted */
3405  void** ptrarray, /**< pointer array where an element is to be inserted */
3406  int keyval, /**< key value of new element */
3407  int field1val, /**< additional value of new element */
3408  void* field2val, /**< additional value of new element */
3409  int* len, /**< pointer to length of arrays (will be increased by 1) */
3410  int* pos /**< pointer to store the insertion position, or NULL */
3411  );
3412 
3413 /** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
3414 extern
3416  int* intarray1, /**< int array where an element is to be inserted */
3417  int* intarray2, /**< second int array where an element is to be inserted */
3418  SCIP_Real* realarray, /**< real array where an element is to be inserted */
3419  int keyval, /**< key value of new element */
3420  int field1val, /**< additional value of new element */
3421  SCIP_Real field2val, /**< additional value of new element */
3422  int* len, /**< pointer to length of arrays (will be increased by 1) */
3423  int* pos /**< pointer to store the insertion position, or NULL */
3424  );
3425 
3426 /** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order */
3427 extern
3429  int* intarray, /**< int array where an element is to be inserted */
3430  void** ptrarray, /**< pointer array where an element is to be inserted */
3431  int keyval, /**< key value of new element */
3432  void* field1val, /**< additional value of new element */
3433  int* len, /**< pointer to length of arrays (will be increased by 1) */
3434  int* pos /**< pointer to store the insertion position, or NULL */
3435  );
3436 
3437 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
3438 extern
3440  int* intarray1, /**< int array where an element is to be inserted */
3441  int* intarray2, /**< int array where an element is to be inserted */
3442  int* intarray3, /**< int array where an element is to be inserted */
3443  void** ptrarray, /**< pointer array where an element is to be inserted */
3444  int keyval, /**< key value of new element */
3445  int field1val, /**< additional value of new element */
3446  int field2val, /**< additional value of new element */
3447  void* field3val, /**< additional value of new element */
3448  int* len, /**< pointer to length of arrays (will be increased by 1) */
3449  int* pos /**< pointer to store the insertion position, or NULL */
3450  );
3451 
3452 
3453 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
3454 extern
3456  int* intarray1, /**< int array where an element is to be inserted */
3457  void** ptrarray, /**< pointer array where an element is to be inserted */
3458  int* intarray2, /**< int array where an element is to be inserted */
3459  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3460  int keyval, /**< key value of new element */
3461  void* field1val, /**< additional value of new element */
3462  int field2val, /**< additional value of new element */
3463  SCIP_Real field3val, /**< additional value of new element */
3464  int* len, /**< pointer to length of arrays (will be increased by 1) */
3465  int* pos /**< pointer to store the insertion position, or NULL */
3466  );
3467 
3468 /** insert a new element into an array of Longints, sorted in non-increasing order */
3469 extern
3471  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3472  SCIP_Longint keyval, /**< key value of new element */
3473  int* len, /**< pointer to length of arrays (will be increased by 1) */
3474  int* pos /**< pointer to store the insertion position, or NULL */
3475  );
3476 
3477 /** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
3478 extern
3480  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3481  void** ptrarray, /**< pointer array where an element is to be inserted */
3482  SCIP_Longint keyval, /**< key value of new element */
3483  void* field1val, /**< additional value of new element */
3484  int* len, /**< pointer to length of arrays (will be increased by 1) */
3485  int* pos /**< pointer to store the insertion position, or NULL */
3486  );
3487 
3488 /** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
3489 extern
3491  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3492  void** ptrarray, /**< pointer array where an element is to be inserted */
3493  int* intarray, /**< int array where an element is to be inserted */
3494  SCIP_Longint keyval, /**< key value of new element */
3495  void* field1val, /**< additional value of new element */
3496  int field2val, /**< additional value of new element */
3497  int* len, /**< pointer to length of arrays (will be increased by 1) */
3498  int* pos /**< pointer to store the insertion position, or NULL */
3499  );
3500 
3501 /** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
3502 extern
3504  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3505  void** ptrarray, /**< pointer array where an element is to be inserted */
3506  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3507  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3508  SCIP_Longint keyval, /**< key value of new element */
3509  void* field1val, /**< additional value of new element */
3510  SCIP_Real field2val, /**< additional value of new element */
3511  SCIP_Bool field3val, /**< additional value of new element */
3512  int* len, /**< pointer to length of arrays (will be increased by 1) */
3513  int* pos /**< pointer to store the insertion position, or NULL */
3514  );
3515 
3516 /** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
3517 extern
3519  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3520  void** ptrarray, /**< pointer array where an element is to be inserted */
3521  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3522  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3523  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3524  SCIP_Longint keyval, /**< key value of new element */
3525  void* field1val, /**< additional value of new element */
3526  SCIP_Real field2val, /**< additional value of new element */
3527  SCIP_Real field3val, /**< additional value of new element */
3528  SCIP_Bool field4val, /**< additional value of new element */
3529  int* len, /**< pointer to length of arrays (will be increased by 1) */
3530  int* pos /**< pointer to store the insertion position, or NULL */
3531  );
3532 
3533 /** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
3534 extern
3536  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3537  void** ptrarray, /**< pointer array where an element is to be inserted */
3538  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3539  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3540  int* intarray, /**< int array where an element is to be inserted */
3541  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3542  SCIP_Longint keyval, /**< key value of new element */
3543  void* field1val, /**< additional value of new element */
3544  SCIP_Real field2val, /**< additional value of new element */
3545  SCIP_Real field3val, /**< additional value of new element */
3546  int field4val, /**< additional value of new element */
3547  SCIP_Bool field5val, /**< additional value of new element */
3548  int* len, /**< pointer to length of arrays (will be increased by 1) */
3549  int* pos /**< pointer to store the insertion position, or NULL */
3550  );
3551 
3552 /** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
3553 extern
3555  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3556  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3557  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3558  int* intarray, /**< int array where an element is to be inserted */
3559  SCIP_Longint keyval, /**< key value of new element */
3560  void* field1val, /**< additional value of new element */
3561  void* field2val, /**< additional value of new element */
3562  int field3val, /**< additional value of new element */
3563  int* len, /**< pointer to length of arrays (will be increased by 1) */
3564  int* pos /**< pointer to store the insertion position, or NULL */
3565  );
3566 
3567 /** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
3568 extern
3570  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3571  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3572  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3573  int* intarray1, /**< first int array where an element is to be inserted */
3574  int* intarray2, /**< second int array where an element is to be inserted */
3575  SCIP_Longint keyval, /**< key value of new element */
3576  void* field1val, /**< additional value of new element */
3577  void* field2val, /**< additional value of new element */
3578  int field3val, /**< additional value of new element */
3579  int field4val, /**< additional value of new element */
3580  int* len, /**< pointer to length of arrays (will be increased by 1) */
3581  int* pos /**< pointer to store the insertion position, or NULL */
3582  );
3583 
3584 /** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
3585 extern
3587  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3588  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3589  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3590  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3591  int* intarray, /**< int array where an element is to be inserted */
3592  SCIP_Longint keyval, /**< key value of new element */
3593  void* field1val, /**< additional value of new element */
3594  void* field2val, /**< additional value of new element */
3595  SCIP_Bool field3val, /**< additional value of new element */
3596  int field4val, /**< additional value of new element */
3597  int* len, /**< pointer to length of arrays (will be increased by 1) */
3598  int* pos /**< pointer to store the insertion position, or NULL */
3599  );
3600 
3601 /** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
3602 extern
3604  void** ptrarray, /**< pointer array to be sorted */
3605  int* intarray1, /**< first int array to be permuted in the same way */
3606  int* intarray2, /**< second int array to be permuted in the same way */
3607  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3608  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3609  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3610  void* keyval, /**< key value of new element */
3611  int field1val, /**< additional value of new element */
3612  int field2val, /**< additional value of new element */
3613  SCIP_Bool field3val, /**< additional value of new element */
3614  SCIP_Bool field4val, /**< additional value of new element */
3615  int* len, /**< pointer to length of arrays (will be increased by 1) */
3616  int* pos /**< pointer to store the insertion position, or NULL */
3617  );
3618 
3619 /** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order */
3620 extern
3622  int* intarray1, /**< int array to be sorted */
3623  void** ptrarray, /**< pointer array to be permuted in the same way */
3624  int* intarray2, /**< second int array to be permuted in the same way */
3625  int* intarray3, /**< thrid int array to be permuted in the same way */
3626  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3627  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3628  int keyval, /**< key value of new element */
3629  void* field1val, /**< additional value of new element */
3630  int field2val, /**< additional value of new element */
3631  int field3val, /**< additional value of new element */
3632  SCIP_Bool field4val, /**< additional value of new element */
3633  SCIP_Bool field5val, /**< additional value of new element */
3634  int* len, /**< pointer to length of arrays (will be increased by 1) */
3635  int* pos /**< pointer to store the insertion position, or NULL */
3636  );
3637 
3638 /* upwards position deletion */
3639 
3640 /** delete the element at the given position from an index array in non-decreasing order */
3641 extern
3643  int* indarray, /**< pointer to the index array where an element is to be deleted */
3644  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
3645  void* dataptr, /**< pointer to data field that is given to the external compare method */
3646  int pos, /**< array position of element to be deleted */
3647  int* len /**< pointer to length of arrays (will be decreased by 1) */
3648  );
3649 
3650 /** delete the element at the given position from an array of pointers in non-decreasing order */
3651 extern
3653  void** ptrarray, /**< pointer array where an element is to be deleted */
3654  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3655  int pos, /**< array position of element to be deleted */
3656  int* len /**< pointer to length of arrays (will be decreased by 1) */
3657  );
3658 
3659 /** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
3660 extern
3662  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3663  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3664  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3665  int pos, /**< array position of element to be deleted */
3666  int* len /**< pointer to length of arrays (will be decreased by 1) */
3667  );
3668 
3669 /** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
3670 extern
3672  void** ptrarray, /**< pointer array where an element is to be deleted */
3673  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3674  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3675  int pos, /**< array position of element to be deleted */
3676  int* len /**< pointer to length of arrays (will be decreased by 1) */
3677  );
3678 
3679 /** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
3680 extern
3682  void** ptrarray, /**< pointer array where an element is to be deleted */
3683  int* intarray, /**< int 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 two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
3690 extern
3692  void** ptrarray, /**< pointer array where an element is to be inserted */
3693  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3694  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3695  int pos, /**< array position of element to be deleted */
3696  int* len /**< pointer to length of arrays (will be increased by 1) */
3697  );
3698 
3699 /** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
3700 extern
3702  void** ptrarray, /**< pointer array where an element is to be deleted */
3703  int* intarray1, /**< first int array where an element is to be deleted */
3704  int* intarray2, /**< second int array where an element is to be deleted */
3705  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3706  int pos, /**< array position of element to be deleted */
3707  int* len /**< pointer to length of arrays (will be decreased by 1) */
3708  );
3709 
3710 /** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
3711 extern
3713  void** ptrarray, /**< pointer array where an element is to be deleted */
3714  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3715  int* intarray, /**< int array where an element is to be deleted */
3716  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3717  int pos, /**< array position of element to be deleted */
3718  int* len /**< pointer to length of arrays (will be decreased by 1) */
3719  );
3720 
3721 /** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
3722 extern
3724  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3725  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3726  int* intarray, /**< int array where an element is to be deleted */
3727  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3728  int pos, /**< array position of element to be deleted */
3729  int* len /**< pointer to length of arrays (will be decreased by 1) */
3730  );
3731 
3732 /** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
3733 extern
3735  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3736  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3737  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3738  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3739  int pos, /**< array position of element to be deleted */
3740  int* len /**< pointer to length of arrays (will be decreased by 1) */
3741  );
3742 
3743 /** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
3744 extern
3746  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3747  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3748  int* intarray1, /**< first int array where an element is to be deleted */
3749  int* intarray2, /**< second array where an element is to be deleted */
3750  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3751  int pos, /**< array position of element to be deleted */
3752  int* len /**< pointer to length of arrays (will be decreased by 1) */
3753  );
3754 
3755 /** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
3756 extern
3758  void** ptrarray, /**< pointer array where an element is to be deleted */
3759  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3760  int* intarray1, /**< first int array where an element is to be deleted */
3761  int* intarray2, /**< second int array where an element is to be deleted */
3762  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3763  int pos, /**< array position of element to be deleted */
3764  int* len /**< pointer to length of arrays (will be decreased by 1) */
3765  );
3766 
3767 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
3768 extern
3770  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3771  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3772  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3773  int* intarray, /**< int array where an element is to be deleted */
3774  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3775  int pos, /**< array position of element to be deleted */
3776  int* len /**< pointer to length of arrays (will be decreased by 1) */
3777  );
3778 
3779 /** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
3780 extern
3782  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3783  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3784  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3785  int* intarray, /**< int array where an element is to be deleted */
3786  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3787  int pos, /**< array position of element to be deleted */
3788  int* len /**< pointer to length of arrays (will be decreased by 1) */
3789  );
3790 
3791 /** 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 */
3792 extern
3794  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3795  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3796  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3797  int* intarray1, /**< first int array where an element is to be deleted */
3798  int* intarray2, /**< second int array where an element is to be deleted */
3799  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3800  int pos, /**< array position of element to be deleted */
3801  int* len /**< pointer to length of arrays (will be decreased by 1) */
3802  );
3803 
3804 /** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
3805 extern
3807  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3808  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
3809  void** ptrarray, /**< pointer array to be permuted in the same way */
3810  int pos, /**< array position of element to be deleted */
3811  int* len /**< pointer to length of arrays (will be decreased by 1) */
3812  );
3813 
3814 /** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
3815 extern
3817  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3818  void** ptrarray, /**< pointer array where an element is to be deleted */
3819  int pos, /**< array position of element to be deleted */
3820  int* len /**< pointer to length of arrays (will be decreased by 1) */
3821  );
3822 
3823 /** delete the element at the given position from an arrays of Reals, sorted in non-decreasing order */
3824 extern
3826  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3827  int pos, /**< array position of element to be deleted */
3828  int* len /**< pointer to length of arrays (will be decreased by 1) */
3829  );
3830 
3831 /** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
3832 extern
3834  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3835  int* intarray, /**< int array where an element is to be deleted */
3836  int pos, /**< array position of element to be deleted */
3837  int* len /**< pointer to length of arrays (will be decreased by 1) */
3838  );
3839 
3840 /** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
3841 extern
3843  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3844  int* intarray, /**< int array where an element is to be deleted */
3845  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3846  int pos, /**< array position of element to be deleted */
3847  int* len /**< pointer to length of arrays (will be decreased by 1) */
3848  );
3849 
3850 /** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
3851 extern
3853  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3854  int* intarray, /**< int array where an element is to be deleted */
3855  void** ptrarray, /**< 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-decreasing order */
3861 extern
3863  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be deleted */
3864  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
3865  void** ptrarray, /**< 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-decreasing order */
3871 extern
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-decreasing order */
3882 extern
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-decreasing order */
3894 extern
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-decreasing order */
3905 extern
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-decreasing order */
3916 extern
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-decreasing order */
3927 extern
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-decreasing order */
3938 extern
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 an array of ints in non-decreasing order */
3950 extern
3952  int* intarray, /**< int array where an element is to be deleted */
3953  int pos, /**< array position of element to be deleted */
3954  int* len /**< pointer to length of arrays (will be decreased by 1) */
3955  );
3956 
3957 /** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order */
3958 extern
3960  int* intarray1, /**< int array where an element is to be deleted */
3961  int* intarray2, /**< second int array where an element is to be deleted */
3962  int pos, /**< array position of element to be deleted */
3963  int* len /**< pointer to length of arrays (will be decreased by 1) */
3964  );
3965 
3966 /** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order */
3967 extern
3969  int* intarray, /**< int array where an element is to be deleted */
3970  SCIP_Real* realarray, /**< real array where an element is to be deleted */
3971  int pos, /**< array position of element to be deleted */
3972  int* len /**< pointer to length of arrays (will be decreased by 1) */
3973  );
3974 
3975 /** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
3976 extern
3978  int* intarray1, /**< int array where an element is to be deleted */
3979  int* intarray2, /**< second int array where an element is to be deleted */
3980  int* intarray3, /**< third int array where an element is to be deleted */
3981  int pos, /**< array position of element to be deleted */
3982  int* len /**< pointer to length of arrays (will be decreased by 1) */
3983  );
3984 
3985 /** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
3986 extern
3988  int* intarray1, /**< int array where an element is to be deleted */
3989  int* intarray2, /**< second int array where an element is to be deleted */
3990  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3991  int pos, /**< array position of element to be deleted */
3992  int* len /**< pointer to length of arrays (will be decreased by 1) */
3993  );
3994 
3995 /** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
3996 extern
3998  int* intarray1, /**< int array where an element is to be deleted */
3999  int* intarray2, /**< second int array where an element is to be deleted */
4000  void** ptrarray, /**< pointer array where an element is to be deleted */
4001  int pos, /**< array position of element to be deleted */
4002  int* len /**< pointer to length of arrays (will be decreased by 1) */
4003  );
4004 
4005 /** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
4006 extern
4008  int* intarray1, /**< int array where an element is to be deleted */
4009  int* intarray2, /**< second int array where an element is to be deleted */
4010  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4011  int pos, /**< array position of element to be deleted */
4012  int* len /**< pointer to length of arrays (will be decreased by 1) */
4013  );
4014 
4015 /** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
4016 extern
4018  int* intarray, /**< int array where an element is to be deleted */
4019  void** ptrarray, /**< pointer array where an element is to be deleted */
4020  int pos, /**< array position of element to be deleted */
4021  int* len /**< pointer to length of arrays (will be decreased by 1) */
4022  );
4023 
4024 /** delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
4025 extern
4027  int* intarray, /**< int array where an element is to be deleted */
4028  void** ptrarray, /**< pointer array where an element is to be deleted */
4029  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4030  int pos, /**< array position of element to be deleted */
4031  int* len /**< pointer to length of arrays (will be decreased by 1) */
4032  );
4033 
4034 /** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
4035 extern
4037  int* intarray1, /**< int array where an element is to be deleted */
4038  int* intarray2, /**< int array where an element is to be deleted */
4039  int* intarray3, /**< int array where an element is to be deleted */
4040  void** ptrarray, /**< pointer array where an element is to be deleted */
4041  int pos, /**< array position of element to be deleted */
4042  int* len /**< pointer to length of arrays (will be decreased by 1) */
4043  );
4044 
4045 
4046 /** delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
4047 extern
4049  int* intarray1, /**< int array where an element is to be deleted */
4050  void** ptrarray, /**< pointer array where an element is to be deleted */
4051  int* intarray2, /**< int array where an element is to be deleted */
4052  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4053  int pos, /**< array position of element to be deleted */
4054  int* len /**< pointer to length of arrays (will be decreased by 1) */
4055  );
4056 
4057 /** delete the element at the given position from an array of Longints, sorted by in non-decreasing order */
4058 extern
4060  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4061  int pos, /**< array position of element to be deleted */
4062  int* len /**< pointer to length of arrays (will be decreased by 1) */
4063  );
4064 
4065 /** delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
4066 extern
4068  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4069  void** ptrarray, /**< pointer array where an element is to be deleted */
4070  int pos, /**< array position of element to be deleted */
4071  int* len /**< pointer to length of arrays (will be decreased by 1) */
4072  );
4073 
4074 /** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order */
4075 extern
4077  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4078  void** ptrarray, /**< pointer array where an element is to be deleted */
4079  int* intarray, /**< int array where an element is to be deleted */
4080  int pos, /**< array position of element to be deleted */
4081  int* len /**< pointer to length of arrays (will be decreased by 1) */
4082  );
4083 
4084 /** 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 */
4085 extern
4087  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4088  void** ptrarray, /**< pointer array where an element is to be deleted */
4089  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4090  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4091  int pos, /**< array position of element to be deleted */
4092  int* len /**< pointer to length of arrays (will be decreased by 1) */
4093  );
4094 
4095 /** 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 */
4096 extern
4098  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4099  void** ptrarray, /**< pointer array where an element is to be deleted */
4100  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4101  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4102  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4103  int pos, /**< array position of element to be deleted */
4104  int* len /**< pointer to length of arrays (will be decreased by 1) */
4105  );
4106 
4107 /** 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 */
4108 extern
4110  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4111  void** ptrarray, /**< pointer array where an element is to be deleted */
4112  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4113  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4114  int* intarray, /**< int 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 four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
4121 extern
4123  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4124  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4125  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4126  int* intarray, /**< int array where an element is to be deleted */
4127  int pos, /**< array position of element to be deleted */
4128  int* len /**< pointer to length of arrays (will be decreased by 1) */
4129  );
4130 
4131 /** 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 */
4132 extern
4134  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4135  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4136  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4137  int* intarray1, /**< first int array where an element is to be deleted */
4138  int* intarray2, /**< second int array where an element is to be deleted */
4139  int pos, /**< array position of element to be deleted */
4140  int* len /**< pointer to length of arrays (will be decreased by 1) */
4141  );
4142 
4143 /** 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 */
4144 extern
4146  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4147  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4148  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4149  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4150  int* intarray, /**< int array where an element is to be deleted */
4151  int pos, /**< array position of element to be deleted */
4152  int* len /**< pointer to length of arrays (will be decreased by 1) */
4153  );
4154 
4155 /** 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 */
4156 extern
4158  void** ptrarray, /**< pointer array to be sorted */
4159  int* intarray1, /**< first int array to be permuted in the same way */
4160  int* intarray2, /**< second int array to be permuted in the same way */
4161  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4162  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4163  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4164  int pos, /**< array position of element to be deleted */
4165  int* len /**< pointer to length of arrays (will be decreased by 1) */
4166  );
4167 
4168 /** 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 */
4169 extern
4171  int* intarray1, /**< int array to be sorted */
4172  void** ptrarray, /**< pointer array to be permuted in the same way */
4173  int* intarray2, /**< second int array to be permuted in the same way */
4174  int* intarray3, /**< thrid 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  int pos, /**< array position of element to be deleted */
4178  int* len /**< pointer to length of arrays (will be decreased by 1) */
4179  );
4180 
4181 /* downwards position deletion */
4182 
4183 /** delete the element at the given position from an index array in non-increasing order */
4184 extern
4186  int* indarray, /**< pointer to the index array where an element is to be deleted */
4187  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4188  void* dataptr, /**< pointer to data field that is given to the external compare method */
4189  int pos, /**< array position of element to be deleted */
4190  int* len /**< pointer to length of arrays (will be decreased by 1) */
4191  );
4192 
4193 /** delete the element at the given position from an array of pointers in non-increasing order */
4194 extern
4196  void** ptrarray, /**< pointer array where an element is to be deleted */
4197  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4198  int pos, /**< array position of element to be deleted */
4199  int* len /**< pointer to length of arrays (will be decreased by 1) */
4200  );
4201 
4202 /** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
4203 extern
4205  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4206  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4207  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4208  int pos, /**< array position of element to be deleted */
4209  int* len /**< pointer to length of arrays (will be decreased by 1) */
4210  );
4211 
4212 /** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
4213 extern
4215  void** ptrarray, /**< pointer array where an element is to be deleted */
4216  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4217  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4218  int pos, /**< array position of element to be deleted */
4219  int* len /**< pointer to length of arrays (will be decreased by 1) */
4220  );
4221 
4222 /** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-increasing order */
4223 extern
4225  void** ptrarray, /**< pointer array where an element is to be deleted */
4226  int* intarray, /**< int array where an element is to be deleted */
4227  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4228  int pos, /**< array position of element to be deleted */
4229  int* len /**< pointer to length of arrays (will be decreased by 1) */
4230  );
4231 
4232 /** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
4233 extern
4235  void** ptrarray, /**< pointer array where an element is to be inserted */
4236  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
4237  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4238  int pos, /**< array position of element to be deleted */
4239  int* len /**< pointer to length of arrays (will be increased by 1) */
4240  );
4241 
4242 /** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
4243 extern
4245  void** ptrarray, /**< pointer array where an element is to be deleted */
4246  int* intarray1, /**< first int array where an element is to be deleted */
4247  int* intarray2, /**< second int array where an element is to be deleted */
4248  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4249  int pos, /**< array position of element to be deleted */
4250  int* len /**< pointer to length of arrays (will be decreased by 1) */
4251  );
4252 
4253 /** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
4254 extern
4256  void** ptrarray, /**< pointer array where an element is to be deleted */
4257  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4258  int* intarray, /**< int array where an element is to be deleted */
4259  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4260  int pos, /**< array position of element to be deleted */
4261  int* len /**< pointer to length of arrays (will be decreased by 1) */
4262  );
4263 
4264 /** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
4265 extern
4267  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4268  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4269  int* intarray, /**< int array where an element is to be deleted */
4270  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4271  int pos, /**< array position of element to be deleted */
4272  int* len /**< pointer to length of arrays (will be decreased by 1) */
4273  );
4274 
4275 /** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
4276 extern
4278  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4279  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4280  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4281  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4282  int pos, /**< array position of element to be deleted */
4283  int* len /**< pointer to length of arrays (will be decreased by 1) */
4284  );
4285 
4286 /** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
4287 extern
4289  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4290  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4291  int* intarray1, /**< first int array where an element is to be deleted */
4292  int* intarray2, /**< second int array where an element is to be deleted */
4293  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4294  int pos, /**< array position of element to be deleted */
4295  int* len /**< pointer to length of arrays (will be decreased by 1) */
4296  );
4297 
4298 /** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
4299 extern
4301  void** ptrarray, /**< pointer array where an element is to be deleted */
4302  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4303  int* intarray1, /**< first int array where an element is to be deleted */
4304  int* intarray2, /**< second int array where an element is to be deleted */
4305  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4306  int pos, /**< array position of element to be deleted */
4307  int* len /**< pointer to length of arrays (will be decreased by 1) */
4308  );
4309 
4310 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
4311 extern
4313  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4314  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4315  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4316  int* intarray, /**< int array where an element is to be deleted */
4317  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4318  int pos, /**< array position of element to be deleted */
4319  int* len /**< pointer to length of arrays (will be decreased by 1) */
4320  );
4321 
4322 /** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
4323 extern
4325  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4326  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4327  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4328  int* intarray, /**< int array where an element is to be deleted */
4329  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4330  int pos, /**< array position of element to be deleted */
4331  int* len /**< pointer to length of arrays (will be decreased by 1) */
4332  );
4333 
4334 /** 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 */
4335 extern
4337  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4338  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4339  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4340  int* intarray1, /**< first int array where an element is to be deleted */
4341  int* intarray2, /**< second int array where an element is to be deleted */
4342  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4343  int pos, /**< array position of element to be deleted */
4344  int* len /**< pointer to length of arrays (will be decreased by 1) */
4345  );
4346 
4347 /** delete the element at the given position from an array of Reals, sorted in non-increasing order */
4348 extern
4350  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4351  int pos, /**< array position of element to be deleted */
4352  int* len /**< pointer to length of arrays (will be decreased by 1) */
4353  );
4354 
4355 
4356 /** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
4357 extern
4359  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
4360  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
4361  void** ptrarray, /**< pointer array to be permuted in the same way */
4362  int pos, /**< array position of element to be deleted */
4363  int* len /**< pointer to length of arrays (will be decreased by 1) */
4364  );
4365 
4366 /** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
4367 extern
4369  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4370  void** ptrarray, /**< pointer array where an element is to be deleted */
4371  int pos, /**< array position of element to be deleted */
4372  int* len /**< pointer to length of arrays (will be decreased by 1) */
4373  );
4374 
4375 /** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order */
4376 extern
4378  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4379  int* intarray, /**< pointer array where an element is to be deleted */
4380  int pos, /**< array position of element to be deleted */
4381  int* len /**< pointer to length of arrays (will be decreased by 1) */
4382  );
4383 
4384 /** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
4385 extern
4387  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4388  int* intarray, /**< int array where an element is to be deleted */
4389  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4390  int pos, /**< array position of element to be deleted */
4391  int* len /**< pointer to length of arrays (will be decreased by 1) */
4392  );
4393 
4394 /** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
4395 extern
4397  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4398  int* intarray, /**< int array where an element is to be deleted */
4399  void** ptrarray, /**< pointer array where an element is to be deleted */
4400  int pos, /**< array position of element to be deleted */
4401  int* len /**< pointer to length of arrays (will be decreased by 1) */
4402  );
4403 
4404 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
4405 extern
4407  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be deleted */
4408  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4409  void** ptrarray, /**< pointer array where an element is to be deleted */
4410  int pos, /**< array position of element to be deleted */
4411  int* len /**< pointer to length of arrays (will be decreased by 1) */
4412  );
4413 
4414 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
4415 extern
4417  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4418  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4419  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4420  int pos, /**< array position of element to be deleted */
4421  int* len /**< pointer to length of arrays (will be decreased by 1) */
4422  );
4423 
4424 /** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
4425 extern
4427  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4428  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4429  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4430  int* intarray, /**< int array where an element is to be deleted */
4431  int pos, /**< array position of element to be deleted */
4432  int* len /**< pointer to length of arrays (will be decreased by 1) */
4433  );
4434 
4435 /** 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 */
4436 extern
4438  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4439  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4440  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4441  int* intarray1, /**< int array where an element is to be deleted */
4442  int* intarray2, /**< int array where an element is to be deleted */
4443  int pos, /**< array position of element to be deleted */
4444  int* len /**< pointer to length of arrays (will be decreased by 1) */
4445  );
4446 
4447 /** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-increasing order */
4448 extern
4450  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4451  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4452  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4453  int* intarray, /**< int array where an element is to be deleted */
4454  int pos, /**< array position of element to be deleted */
4455  int* len /**< pointer to length of arrays (will be decreased by 1) */
4456  );
4457 
4458 /** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
4459 extern
4461  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4462  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4463  int* intarray1, /**< int array where an element is to be deleted */
4464  int* intarray2, /**< int array where an element is to be deleted */
4465  int pos, /**< array position of element to be deleted */
4466  int* len /**< pointer to length of arrays (will be decreased by 1) */
4467  );
4468 
4469 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
4470 extern
4472  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4473  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4474  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4475  int* intarray, /**< int array where an element is to be deleted */
4476  int pos, /**< array position of element to be deleted */
4477  int* len /**< pointer to length of arrays (will be decreased by 1) */
4478  );
4479 
4480 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
4481 extern
4483  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4484  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4485  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4486  void** ptrarray, /**< pointer array where an element is to be deleted */
4487  int pos, /**< array position of element to be deleted */
4488  int* len /**< pointer to length of arrays (will be decreased by 1) */
4489  );
4490 
4491 /** 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 */
4492 extern
4494  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4495  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4496  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4497  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4498  void** ptrarray, /**< pointer array where an element is to be deleted */
4499  int pos, /**< array position of element to be deleted */
4500  int* len /**< pointer to length of arrays (will be decreased by 1) */
4501  );
4502 
4503 /** delete the element at the given position from an array of ints in non-increasing order */
4504 extern
4506  int* intarray, /**< int array where an element is to be deleted */
4507  int pos, /**< array position of element to be deleted */
4508  int* len /**< pointer to length of arrays (will be decreased by 1) */
4509  );
4510 
4511 /** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-increasing order */
4512 extern
4514  int* intarray1, /**< int array where an element is to be deleted */
4515  int* intarray2, /**< second int array where an element is to be deleted */
4516  int pos, /**< array position of element to be deleted */
4517  int* len /**< pointer to length of arrays (will be decreased by 1) */
4518  );
4519 
4520 /** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-increasing order */
4521 extern
4523  int* intarray, /**< int array where an element is to be deleted */
4524  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4525  int pos, /**< array position of element to be deleted */
4526  int* len /**< pointer to length of arrays (will be decreased by 1) */
4527  );
4528 
4529 /** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
4530 extern
4532  int* intarray1, /**< int array where an element is to be deleted */
4533  int* intarray2, /**< second int array where an element is to be deleted */
4534  int* intarray3, /**< third int array where an element is to be deleted */
4535  int pos, /**< array position of element to be deleted */
4536  int* len /**< pointer to length of arrays (will be decreased by 1) */
4537  );
4538 
4539 /** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
4540 extern
4542  int* intarray1, /**< int array where an element is to be deleted */
4543  int* intarray2, /**< second int array where an element is to be deleted */
4544  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4545  int pos, /**< array position of element to be deleted */
4546  int* len /**< pointer to length of arrays (will be decreased by 1) */
4547  );
4548 
4549 /** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
4550 extern
4552  int* intarray1, /**< int array where an element is to be deleted */
4553  int* intarray2, /**< second int array where an element is to be deleted */
4554  void** ptrarray, /**< pointer array where an element is to be deleted */
4555  int pos, /**< array position of element to be deleted */
4556  int* len /**< pointer to length of arrays (will be decreased by 1) */
4557  );
4558 
4559 /** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
4560 extern
4562  int* intarray1, /**< int array where an element is to be deleted */
4563  int* intarray2, /**< second int array where an element is to be deleted */
4564  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4565  int pos, /**< array position of element to be deleted */
4566  int* len /**< pointer to length of arrays (will be decreased by 1) */
4567  );
4568 
4569 /** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-increasing order */
4570 extern
4572  int* intarray, /**< int array where an element is to be deleted */
4573  void** ptrarray, /**< pointer array where an element is to be deleted */
4574  int pos, /**< array position of element to be deleted */
4575  int* len /**< pointer to length of arrays (will be decreased by 1) */
4576  );
4577 
4578 
4579 /** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
4580 extern
4582  int* intarray1, /**< int array where an element is to be deleted */
4583  int* intarray2, /**< int array where an element is to be deleted */
4584  int* intarray3, /**< int array where an element is to be deleted */
4585  void** ptrarray, /**< pointer array where an element is to be deleted */
4586  int pos, /**< array position of element to be deleted */
4587  int* len /**< pointer to length of arrays (will be decreased by 1) */
4588  );
4589 
4590 /** delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
4591 extern
4593  int* intarray1, /**< int array where an element is to be deleted */
4594  void** ptrarray, /**< pointer array where an element is to be deleted */
4595  int* intarray2, /**< int array where an element is to be deleted */
4596  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4597  int pos, /**< array position of element to be deleted */
4598  int* len /**< pointer to length of arrays (will be decreased by 1) */
4599  );
4600 
4601 /** delete the element at the given position from an array of Longints, sorted in non-increasing order */
4602 extern
4604  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4605  int pos, /**< array position of element to be deleted */
4606  int* len /**< pointer to length of arrays (will be decreased by 1) */
4607  );
4608 
4609 /** delete the element at the given position from three two arrays of Long/pointer, sorted by the first array in non-increasing order */
4610 extern
4612  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4613  void** ptrarray, /**< pointer array where an element is to be deleted */
4614  int pos, /**< array position of element to be deleted */
4615  int* len /**< pointer to length of arrays (will be decreased by 1) */
4616  );
4617 
4618 /** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-increasing order */
4619 extern
4621  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4622  void** ptrarray, /**< pointer array where an element is to be deleted */
4623  int* intarray, /**< int array where an element is to be deleted */
4624  int pos, /**< array position of element to be deleted */
4625  int* len /**< pointer to length of arrays (will be decreased by 1) */
4626  );
4627 
4628 /** 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 */
4629 extern
4631  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4632  void** ptrarray, /**< pointer array where an element is to be deleted */
4633  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4634  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4635  int pos, /**< array position of element to be deleted */
4636  int* len /**< pointer to length of arrays (will be decreased by 1) */
4637  );
4638 
4639 /** 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 */
4640 extern
4642  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4643  void** ptrarray, /**< pointer array where an element is to be deleted */
4644  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4645  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4646  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4647  int pos, /**< array position of element to be deleted */
4648  int* len /**< pointer to length of arrays (will be decreased by 1) */
4649  );
4650 
4651 /** 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 */
4652 extern
4654  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4655  void** ptrarray, /**< pointer array where an element is to be deleted */
4656  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4657  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4658  int* intarray, /**< int array where an element is to be deleted */
4659  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4660  int pos, /**< array position of element to be deleted */
4661  int* len /**< pointer to length of arrays (will be decreased by 1) */
4662  );
4663 
4664 
4665 /** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
4666 extern
4668  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4669  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4670  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4671  int* intarray, /**< int array where an element is to be deleted */
4672  int pos, /**< array position of element to be deleted */
4673  int* len /**< pointer to length of arrays (will be decreased by 1) */
4674  );
4675 
4676 /** 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 */
4677 extern
4679  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4680  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4681  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4682  int* intarray1, /**< first int array where an element is to be deleted */
4683  int* intarray2, /**< second int array where an element is to be deleted */
4684  int pos, /**< array position of element to be deleted */
4685  int* len /**< pointer to length of arrays (will be decreased by 1) */
4686  );
4687 
4688 /** 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 */
4689 extern
4691  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4692  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4693  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4694  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4695  int* intarray, /**< int array where an element is to be deleted */
4696  int pos, /**< array position of element to be deleted */
4697  int* len /**< pointer to length of arrays (will be decreased by 1) */
4698  );
4699 
4700 /** 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 */
4701 extern
4703  void** ptrarray, /**< pointer array to be sorted */
4704  int* intarray1, /**< first int array to be permuted in the same way */
4705  int* intarray2, /**< second int array to be permuted in the same way */
4706  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4707  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4708  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4709  int pos, /**< array position of element to be deleted */
4710  int* len /**< pointer to length of arrays (will be decreased by 1) */
4711  );
4712 
4713 /** 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 */
4714 extern
4716  int* intarray1, /**< int array to be sorted */
4717  void** ptrarray, /**< pointer array to be permuted in the same way */
4718  int* intarray2, /**< second int array to be permuted in the same way */
4719  int* intarray3, /**< thrid int array to be permuted in the same way */
4720  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4721  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4722  int pos, /**< array position of element to be deleted */
4723  int* len /**< pointer to length of arrays (will be decreased by 1) */
4724  );
4725 
4726 
4727 /* upwards binary search */
4728 
4729 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4730  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4731  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4732  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4733  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4734  */
4735 extern
4737  int* indarray, /**< index array to be searched */
4738  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4739  void* dataptr, /**< pointer to data field that is given to the external compare method */
4740  int val, /**< value to search */
4741  int len, /**< length of array */
4742  int* pos /**< pointer to store position of element */
4743  );
4744 
4745 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4746  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4747  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4748  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4749  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4750  */
4751 extern
4753  void** ptrarray, /**< pointer array to be searched */
4754  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4755  void* val, /**< value to search */
4756  int len, /**< length of array */
4757  int* pos /**< pointer to store position of element */
4758  );
4759 
4760 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4761  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4762  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4763  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4764  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4765  */
4766 extern
4768  SCIP_Real* realarray, /**< SCIP_Real array to be searched */
4769  SCIP_Real val, /**< value to search */
4770  int len, /**< length of array */
4771  int* pos /**< pointer to store position of element */
4772  );
4773 
4774 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4775  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4776  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4777  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4778  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4779  */
4780 extern
4782  int* intarray, /**< int array to be searched */
4783  int val, /**< value to search */
4784  int len, /**< length of array */
4785  int* pos /**< pointer to store position of element */
4786  );
4787 
4788 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4789  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4790  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4791  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4792  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4793  */
4794 extern
4796  SCIP_Longint* longarray, /**< SCIP_Longint array to be searched */
4797  SCIP_Longint val, /**< value to search */
4798  int len, /**< length of array */
4799  int* pos /**< pointer to store position of element */
4800  );
4801 
4802 
4803 /* downwards binary search */
4804 
4805 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4806  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4807  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4808  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4809  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4810  */
4811 extern
4813  int* indarray, /**< index array to be searched */
4814  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4815  void* dataptr, /**< pointer to data field that is given to the external compare method */
4816  int val, /**< value to search */
4817  int len, /**< length of array */
4818  int* pos /**< pointer to store position of element */
4819  );
4820 
4821 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4822  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4823  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4824  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4825  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4826  */
4827 extern
4829  void** ptrarray, /**< pointer array to be searched */
4830  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4831  void* val, /**< value to search */
4832  int len, /**< length of array */
4833  int* pos /**< pointer to store position of element */
4834  );
4835 
4836 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4837  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4838  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4839  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4840  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4841  */
4842 extern
4844  SCIP_Real* realarray, /**< SCIP_Real array to be searched */
4845  SCIP_Real val, /**< value to search */
4846  int len, /**< length of array */
4847  int* pos /**< pointer to store position of element */
4848  );
4849 
4850 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4851  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4852  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4853  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4854  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4855  */
4856 extern
4858  int* intarray, /**< int array to be searched */
4859  int val, /**< value to search */
4860  int len, /**< length of array */
4861  int* pos /**< pointer to store position of element */
4862  );
4863 
4864 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4865  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4866  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4867  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4868  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4869  */
4870 extern
4872  SCIP_Longint* longarray, /**< SCIP_Longint array to be searched */
4873  SCIP_Longint val, /**< value to search */
4874  int len, /**< length of array */
4875  int* pos /**< pointer to store position of element */
4876  );
4877 
4878 /**@} */
4879 
4880 /**@defgroup MiscellaneousMethods Miscellaneous Methods
4881  *
4882  * Below you find a list of miscellaneous methods grouped by different categories
4883  *@{
4884  */
4885 
4886 /*
4887  * Numerical methods
4888  */
4889 
4890 /**@defgroup NumericalMethods Numerical Methods
4891  *
4892  *@{
4893  */
4894 
4895 /** returns the machine epsilon: the smallest number eps > 0, for which 1.0 + eps > 1.0 */
4896 extern
4898  void
4899  );
4900 
4901 /** calculates the greatest common divisor of the two given values */
4902 extern
4904  SCIP_Longint val1, /**< first value of greatest common devisor calculation */
4905  SCIP_Longint val2 /**< second value of greatest common devisor calculation */
4906  );
4907 
4908 /** calculates the smallest common multiple of the two given values */
4909 extern
4911  SCIP_Longint val1, /**< first value of smallest common multiple calculation */
4912  SCIP_Longint val2 /**< second value of smallest common multiple calculation */
4913  );
4914 
4915 /** converts a real number into a (approximate) rational representation, and returns TRUE iff the conversion was
4916  * successful
4917  */
4918 extern
4920  SCIP_Real val, /**< real value r to convert into rational number */
4921  SCIP_Real mindelta, /**< minimal allowed difference r - q of real r and rational q = n/d */
4922  SCIP_Real maxdelta, /**< maximal allowed difference r - q of real r and rational q = n/d */
4923  SCIP_Longint maxdnom, /**< maximal denominator allowed */
4924  SCIP_Longint* nominator, /**< pointer to store the nominator n of the rational number */
4925  SCIP_Longint* denominator /**< pointer to store the denominator d of the rational number */
4926  );
4927 
4928 /** tries to find a value, such that all given values, if scaled with this value become integral in relative allowed
4929  * difference in between mindelta and maxdelta
4930  */
4931 extern
4933  SCIP_Real* vals, /**< values to scale */
4934  int nvals, /**< number of values to scale */
4935  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
4936  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
4937  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
4938  SCIP_Real maxscale, /**< maximal allowed scalar */
4939  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
4940  SCIP_Bool* success /**< stores whether returned value is valid */
4941  );
4942 
4943 /** given a (usually very small) interval, tries to find a rational number with simple denominator (i.e. a small
4944  * number, probably multiplied with powers of 10) out of this interval; returns TRUE iff a valid rational
4945  * number inside the interval was found
4946  */
4947 extern
4949  SCIP_Real lb, /**< lower bound of the interval */
4950  SCIP_Real ub, /**< upper bound of the interval */
4951  SCIP_Longint maxdnom, /**< maximal denominator allowed for resulting rational number */
4952  SCIP_Longint* nominator, /**< pointer to store the nominator n of the rational number */
4953  SCIP_Longint* denominator /**< pointer to store the denominator d of the rational number */
4954  );
4955 
4956 /** given a (usually very small) interval, selects a value inside this interval; it is tried to select a rational number
4957  * with simple denominator (i.e. a small number, probably multiplied with powers of 10);
4958  * if no valid rational number inside the interval was found, selects the central value of the interval
4959  */
4960 extern
4962  SCIP_Real lb, /**< lower bound of the interval */
4963  SCIP_Real ub, /**< upper bound of the interval */
4964  SCIP_Longint maxdnom /**< maximal denominator allowed for resulting rational number */
4965  );
4966 
4967 /* The C99 standard defines the function (or macro) isfinite.
4968  * On MacOS X, isfinite is also available.
4969  * From the BSD world, there comes a function finite.
4970  * On SunOS, finite is also available.
4971  * In the MS compiler world, there is a function _finite.
4972  * As last resort, we check whether x == x does not hold, but this works only for NaN's, not for infinities!
4973  */
4974 #if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L || defined(__APPLE__)
4975 #define SCIPisFinite isfinite
4976 #elif defined(_BSD_SOURCE) || defined(__sun)
4977 #define SCIPisFinite finite
4978 #elif defined(_MSC_VER)
4979 #define SCIPisFinite _finite
4980 #else
4981 #define SCIPisFinite(x) ((x) == (x))
4982 #endif
4983 
4984 /* In debug mode, the following methods are implemented as function calls to ensure
4985  * type validity.
4986  */
4987 
4988 /** returns the relative difference: (val1-val2)/max(|val1|,|val2|,1.0) */
4989 extern
4991  SCIP_Real val1, /**< first value to be compared */
4992  SCIP_Real val2 /**< second value to be compared */
4993  );
4994 
4995 #ifdef NDEBUG
4996 
4997 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
4998  * speed up the algorithms.
4999  */
5000 
5001 #define SCIPrelDiff(val1, val2) ( ((val1)-(val2))/(MAX3(1.0,REALABS(val1),REALABS(val2))) )
5002 
5003 #endif
5004 
5005 /**@} */
5006 
5007 
5008 /*
5009  * Random Numbers
5010  */
5011 
5012 /**@defgroup RandomNumbers Random Numbers
5013  *
5014  *@{
5015  */
5016 
5017 /** returns a random integer between minrandval and maxrandval */
5018 extern
5019 int SCIPgetRandomInt(
5020  int minrandval, /**< minimal value to return */
5021  int maxrandval, /**< maximal value to return */
5022  unsigned int* seedp /**< pointer to seed value */
5023  );
5024 
5025 /** returns a random real between minrandval and maxrandval */
5026 extern
5028  SCIP_Real minrandval, /**< minimal value to return */
5029  SCIP_Real maxrandval, /**< maximal value to return */
5030  unsigned int* seedp /**< pointer to seed value */
5031  );
5032 
5033 /**@} */
5034 
5035 
5036 /*
5037  * Additional math functions
5038  */
5039 
5040 /**@defgroup AdditionalMathFunctions Additional math functions
5041  *
5042  *@{
5043  */
5044 
5045 /** calculates a binomial coefficient n over m, choose m elements out of n, maximal value will be 33 over 16 (because
5046  * the n=33 is the last line in the Pascal's triangle where each entry fits in a 4 byte value), an error occurs due to
5047  * big numbers or an negative value m (and m < n) and -1 will be returned
5048  */
5049 extern
5051  int n, /**< number of different elements */
5052  int m /**< number to choose out of the above */
5053  );
5054 
5055 /**@} */
5056 
5057 /*
5058  * Permutations / Shuffling
5059  */
5060 
5061 /**@defgroup PermutationsShuffling Permutations Shuffling
5062  *
5063  *@{
5064  */
5065 
5066 /** swaps two ints */
5067 extern
5068 void SCIPswapInts(
5069  int* value1, /**< pointer to first integer */
5070  int* value2 /**< pointer ti second integer */
5071  );
5072 
5073 /** swaps the addresses of two pointers */
5074 extern
5075 void SCIPswapPointers(
5076  void** pointer1, /**< first pointer */
5077  void** pointer2 /**< second pointer */
5078  );
5079 
5080 /** randomly shuffles parts of an integer array using the Fisher-Yates algorithm */
5081 extern
5082 void SCIPpermuteIntArray(
5083  int* array, /**< array to be shuffled */
5084  int begin, /**< first index that should be subject to shuffling (0 for whole array) */
5085  int end, /**< last index that should be subject to shuffling (array size for whole
5086  * array)
5087  */
5088  unsigned int* randseed /**< seed value for the random generator */
5089  );
5090 
5091 /** randomly shuffles parts of an array using the Fisher-Yates algorithm */
5092 extern
5093 void SCIPpermuteArray(
5094  void** array, /**< array to be shuffled */
5095  int begin, /**< first index that should be subject to shuffling (0 for whole array) */
5096  int end, /**< last index that should be subject to shuffling (array size for whole
5097  * array)
5098  */
5099  unsigned int* randseed /**< pointer to seed value for the random generator */
5100  );
5101 
5102 /** draws a random subset of disjoint elements from a given set of disjoint elements;
5103  * this implementation is suited for the case that nsubelems is considerably smaller then nelems
5104  */
5105 extern
5107  void** set, /**< original set, from which elements should be drawn */
5108  int nelems, /**< number of elements in original set */
5109  void** subset, /**< subset in which drawn elements should be stored */
5110  int nsubelems, /**< number of elements that should be drawn and stored */
5111  unsigned int randseed /**< seed value for random generator */
5112  );
5113 
5114 /**@} */
5115 
5116 /*
5117  * Strings
5118  */
5119 
5120 /**@defgroup StringMethods String Methods
5121  *
5122  *@{
5123  */
5124 
5125 /** copies characters from 'src' to 'dest', copying is stopped when either the 'stop' character is reached or after
5126  * 'cnt' characters have been copied, whichever comes first.
5127  *
5128  * @note undefined behaviuor on overlapping arrays
5129  */
5130 extern
5131 int SCIPmemccpy(
5132  char* dest, /**< destination pointer to copy to */
5133  const char* src, /**< source pointer to copy to */
5134  char stop, /**< character when found stop copying */
5135  unsigned int cnt /**< maximal number of characters to copy too */
5136  );
5137 
5138 /** prints an error message containing of the given string followed by a string describing the current system error;
5139  * prefers to use the strerror_r method, which is threadsafe; on systems where this method does not exist,
5140  * NO_STRERROR_R should be defined (see INSTALL), in this case, srerror is used which is not guaranteed to be
5141  * threadsafe (on SUN-systems, it actually is)
5142  */
5143 extern
5144 void SCIPprintSysError(
5145  const char* message /**< first part of the error message, e.g. the filename */
5146  );
5147 
5148 /** extracts tokens from strings - wrapper method for strtok_r() */
5149 extern
5150 char* SCIPstrtok(
5151  char* s, /**< string to parse */
5152  const char* delim, /**< delimiters for parsing */
5153  char** ptrptr /**< pointer to working char pointer - must stay the same while parsing */
5154  );
5155 
5156 /** translates the given string into a string where symbols ", ', and spaces are escaped with a \ prefix */
5157 extern
5158 void SCIPescapeString(
5159  char* t, /**< target buffer to store escaped string */
5160  int bufsize, /**< size of buffer t */
5161  const char* s /**< string to transform into escaped string */
5162  );
5163 
5164 /** safe version of snprintf */
5165 extern
5166 int SCIPsnprintf(
5167  char* t, /**< target string */
5168  int len, /**< length of the string to copy */
5169  const char* s, /**< source string */
5170  ... /**< further parameters */
5171  );
5172 
5173 /** extract the next token as a integer value if it is one; in case no value is parsed the endptr is set to @p str
5174  *
5175  * @return Returns TRUE if a value could be extracted, otherwise FALSE
5176  */
5177 extern
5179  const char* str, /**< string to search */
5180  int* value, /**< pointer to store the parsed value */
5181  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5182  );
5183 
5184 /** extract the next token as a double value if it is one; in case a value is parsed the endptr is set to @p str
5185  *
5186  * @return Returns TRUE if a value could be extracted, otherwise FALSE
5187  */
5188 extern
5190  const char* str, /**< string to search */
5191  SCIP_Real* value, /**< pointer to store the parsed value */
5192  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5193  );
5194 
5195 /** copies the first size characters between a start and end character of str into token, if no error occured endptr
5196  * will point to the position after the read part, otherwise it will point to @p str
5197  */
5198 extern
5199 void SCIPstrCopySection(
5200  const char* str, /**< string to search */
5201  char startchar, /**< character which defines the beginning */
5202  char endchar, /**< character which defines the ending */
5203  char* token, /**< string to store the copy */
5204  int size, /**< size of the token char array */
5205  char** endptr