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 sparse solution */
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  *
830  * @note The data in nodedata is copied verbatim. This possibly has to be adapted by the user.
831  */
832 extern
834  SCIP_DIGRAPH** targetdigraph, /**< pointer to store the copied directed graph */
835  SCIP_DIGRAPH* sourcedigraph /**< source directed graph */
836  );
837 
838 /** sets the sizes of the successor lists for the nodes in a directed graph and allocates memory for the lists */
839 extern
841  SCIP_DIGRAPH* digraph, /**< directed graph */
842  int* sizes /**< sizes of the successor lists */
843  );
844 
845 /** frees given directed graph structure */
846 extern
847 void SCIPdigraphFree(
848  SCIP_DIGRAPH** digraph /**< pointer to the directed graph */
849  );
850 
851 /** add (directed) arc and a related data to the directed graph structure
852  *
853  * @note if the arc is already contained, it is added a second time
854  */
855 extern
857  SCIP_DIGRAPH* digraph, /**< directed graph */
858  int startnode, /**< start node of the arc */
859  int endnode, /**< start node of the arc */
860  void* data /**< data that should be stored for the arc; or NULL */
861  );
862 
863 /** add (directed) arc to the directed graph structure, if it is not contained, yet
864  *
865  * @note if there already exists an arc from startnode to endnode, the new arc is not added,
866  * even if its data is different
867  */
868 extern
870  SCIP_DIGRAPH* digraph, /**< directed graph */
871  int startnode, /**< start node of the arc */
872  int endnode, /**< start node of the arc */
873  void* data /**< data that should be stored for the arc; or NULL */
874  );
875 
876 /** returns the number of nodes of the given digraph */
877 extern
879  SCIP_DIGRAPH* digraph /**< directed graph */
880  );
881 
882 /** returns the node data, or NULL if no data exist */
883 extern
885  SCIP_DIGRAPH* digraph, /**< directed graph */
886  int node /**< node for which the node data is returned */
887  );
888 
889 /** sets the node data */
890 extern
892  SCIP_DIGRAPH* digraph, /**< directed graph */
893  void* dataptr, /**< user node data pointer, or NULL */
894  int node /**< node for which the node data is returned */
895  );
896 
897 /** returns the total number of arcs in the given digraph */
898 extern
900  SCIP_DIGRAPH* digraph /**< directed graph */
901  );
902 
903 /** returns the number of successor nodes of the given node */
904 extern
906  SCIP_DIGRAPH* digraph, /**< directed graph */
907  int node /**< node for which the number of outgoing arcs is returned */
908  );
909 
910 /** returns the array of indices of the successor nodes; this array must not be changed from outside */
911 extern
913  SCIP_DIGRAPH* digraph, /**< directed graph */
914  int node /**< node for which the array of outgoing arcs is returned */
915  );
916 
917 /** returns the array of data corresponding to the arcs originating at the given node, or NULL if no data exist; this
918  * array must not be changed from outside
919  */
920 extern
922  SCIP_DIGRAPH* digraph, /**< directed graph */
923  int node /**< node for which the data corresponding to the outgoing arcs is returned */
924  );
925 
926 /** Compute undirected connected components on the given graph.
927  *
928  * @note For each arc, its reverse is added, so the graph does not need to be the directed representation of an
929  * undirected graph.
930  */
931 extern
933  SCIP_DIGRAPH* digraph, /**< directed graph */
934  int minsize, /**< all components with less nodes are ignored */
935  int* components, /**< array with as many slots as there are nodes in the directed graph
936  * to store for each node the component to which it belongs
937  * (components are numbered 0 to ncomponents - 1); or NULL, if components
938  * are accessed one-by-one using SCIPdigraphGetComponent() */
939  int* ncomponents /**< pointer to store the number of components; or NULL, if the
940  * number of components is accessed by SCIPdigraphGetNComponents() */
941  );
942 
943 /** Performes an (almost) topological sort on the undirected components of the given directed graph. The undirected
944  * components should be computed before using SCIPdigraphComputeUndirectedComponents().
945  *
946  * @note In general a topological sort is not unique. Note, that there might be directed cycles, that are randomly
947  * broken, which is the reason for having only almost topologically sorted arrays.
948  */
949 extern
951  SCIP_DIGRAPH* digraph /**< directed graph */
952  );
953 
954 /** returns the number of previously computed undirected components for the given directed graph */
955 extern
957  SCIP_DIGRAPH* digraph /**< directed graph */
958  );
959 
960 /** Returns the previously computed undirected component of the given number for the given directed graph.
961  * If the components were sorted using SCIPdigraphTopoSortComponents(), the component is (almost) topologically sorted.
962  */
963 extern
965  SCIP_DIGRAPH* digraph, /**< directed graph */
966  int compidx, /**< number of the component to return */
967  int** nodes, /**< pointer to store the nodes in the component; or NULL, if not needed */
968  int* nnodes /**< pointer to store the number of nodes in the component;
969  * or NULL, if not needed */
970  );
971 
972 /** frees the component information for the given directed graph */
973 extern
975  SCIP_DIGRAPH* digraph /**< directed graph */
976  );
977 
978 /** output of the given directed graph via the given message handler */
979 extern
980 void SCIPdigraphPrint(
981  SCIP_DIGRAPH* digraph, /**< directed graph */
982  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
983  FILE* file /**< output file (or NULL for standard output) */
984  );
985 
986 /** prints the given directed graph structure in GML format into the given file */
987 extern
989  SCIP_DIGRAPH* digraph, /**< directed graph */
990  FILE* file /**< file to write to */
991  );
992 
993 
994 /** output of the given directed graph via the given message handler */
995 extern
997  SCIP_DIGRAPH* digraph, /**< directed graph */
998  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
999  FILE* file /**< output file (or NULL for standard output) */
1000  );
1001 
1002 /**@} */
1003 
1004 /*
1005  * Binary search tree
1006  */
1007 
1008 /**@defgroup BinaryTree Binary Tree
1009  *
1010  *@{
1011  */
1012 
1013 /** creates a binary tree node with sorting value and user data */
1014 extern
1016  SCIP_BT* tree, /**< binary search tree */
1017  SCIP_BTNODE** node, /**< pointer to store the created search node */
1018  void* dataptr /**< user node data pointer, or NULL */
1019  );
1020 
1021 /** frees the binary node including the rooted subtree
1022  *
1023  * @note The user pointer (object) is not freed. If needed, it has to be done by the user.
1024  */
1025 extern
1026 void SCIPbtnodeFree(
1027  SCIP_BT* tree, /**< binary tree */
1028  SCIP_BTNODE** node /**< node to be freed */
1029  );
1030 
1031 /** returns the user data pointer stored in that node */
1032 extern
1033 void* SCIPbtnodeGetData(
1034  SCIP_BTNODE* node /**< node */
1035  );
1036 
1037 /** returns the parent which can be NULL if the given node is the root */
1038 extern
1040  SCIP_BTNODE* node /**< node */
1041  );
1042 
1043 /** returns left child which can be NULL if the given node is a leaf */
1044 extern
1046  SCIP_BTNODE* node /**< node */
1047  );
1048 
1049 /** returns right child which can be NULL if the given node is a leaf */
1050 extern
1052  SCIP_BTNODE* node /**< node */
1053  );
1054 
1055 /** returns the sibling of the node or NULL if does not exist */
1056 extern
1058  SCIP_BTNODE* node /**< node */
1059  );
1060 
1061 /** returns whether the node is a root node */
1062 extern
1064  SCIP_BTNODE* node /**< node */
1065  );
1066 
1067 /** returns whether the node is a leaf */
1068 extern
1070  SCIP_BTNODE* node /**< node */
1071  );
1072 
1073 /** returns TRUE if the given node is left child */
1074 extern
1076  SCIP_BTNODE* node /**< node */
1077  );
1078 
1079 /** returns TRUE if the given node is right child */
1080 extern
1082  SCIP_BTNODE* node /**< node */
1083  );
1084 
1085 #ifdef NDEBUG
1086 
1087 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1088  * speed up the algorithms.
1089  */
1090 
1091 #define SCIPbtnodeGetData(node) ((node)->dataptr)
1092 #define SCIPbtnodeGetParent(node) ((node)->parent)
1093 #define SCIPbtnodeGetLeftchild(node) ((node)->left)
1094 #define SCIPbtnodeGetRightchild(node) ((node)->right)
1095 #define SCIPbtnodeGetSibling(node) ((node)->parent == NULL ? NULL : \
1096  (node)->parent->left == (node) ? (node)->parent->right : (node)->parent->left)
1097 #define SCIPbtnodeIsRoot(node) ((node)->parent == NULL)
1098 #define SCIPbtnodeIsLeaf(node) ((node)->left == NULL && (node)->right == NULL)
1099 #define SCIPbtnodeIsLeftchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->left == (node) ? TRUE : FALSE)
1100 #define SCIPbtnodeIsRightchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->right == (node) ? TRUE : FALSE)
1101 
1102 #endif
1103 
1104 /** sets the give node data
1105  *
1106  * @note The old user pointer is not freed.
1107  */
1108 extern
1109 void SCIPbtnodeSetData(
1110  SCIP_BTNODE* node, /**< node */
1111  void* dataptr /**< node user data pointer */
1112  );
1113 
1114 /** sets parent node
1115  *
1116  * @note The old parent including the rooted subtree is not delete.
1117  */
1118 extern
1119 void SCIPbtnodeSetParent(
1120  SCIP_BTNODE* node, /**< node */
1121  SCIP_BTNODE* parent /**< new parent node, or NULL */
1122  );
1123 
1124 /** sets left child
1125  *
1126  * @note The old left child including the rooted subtree is not delete.
1127  */
1128 extern
1130  SCIP_BTNODE* node, /**< node */
1131  SCIP_BTNODE* left /**< new left child, or NULL */
1132  );
1133 
1134 /** sets right child
1135  *
1136  * @note The old right child including the rooted subtree is not delete.
1137  */
1138 extern
1140  SCIP_BTNODE* node, /**< node */
1141  SCIP_BTNODE* right /**< new right child, or NULL */
1142  );
1143 
1144 /** creates an binary tree */
1145 extern
1147  SCIP_BT** tree, /**< pointer to store the created binary tree */
1148  BMS_BLKMEM* blkmem /**< block memory used to create nodes */
1149  );
1150 
1151 /** frees binary tree
1152  *
1153  * @note The user pointers (object) of the search nodes are not freed. If needed, it has to be done by the user.
1154  */
1155 extern
1156 void SCIPbtFree(
1157  SCIP_BT** tree /**< pointer to binary tree */
1158  );
1159 
1160 /** prints the binary tree in GML format into the given file */
1161 extern
1162 void SCIPbtPrintGml(
1163  SCIP_BT* tree, /**< binary tree */
1164  FILE* file /**< file to write to */
1165  );
1166 
1167 /** returns whether the binary tree is empty (has no nodes) */
1168 extern
1170  SCIP_BT * tree /**< binary tree */
1171  );
1172 
1173 /** returns the root node of the binary tree or NULL if the binary tree is empty */
1174 extern
1176  SCIP_BT* tree /**< tree to be evaluated */
1177  );
1178 
1179 #ifdef NDEBUG
1180 
1181 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1182  * speed up the algorithms.
1183  */
1184 
1185 #define SCIPbtIsEmpty(tree) (tree->root == NULL)
1186 #define SCIPbtGetRoot(tree) (tree->root)
1187 
1188 #endif
1189 
1190 /** sets root node
1191  *
1192  * @note The old root including the rooted subtree is not delete.
1193  */
1194 extern
1195 void SCIPbtSetRoot(
1196  SCIP_BT* tree, /**< tree to be evaluated */
1197  SCIP_BTNODE* root /**< new root, or NULL */
1198  );
1199 
1200 /**@} */
1201 
1202 /**@} */
1203 
1204 /*
1205  * Sorting algorithms
1206  */
1207 
1208 /**@defgroup SortingAlgorithms Sorting Algorithms
1209  *
1210  * @{
1211  */
1212 
1213 /** default comparer for integers */
1214 extern
1215 SCIP_DECL_SORTPTRCOMP(SCIPsortCompInt);
1216 
1217 /* first all upwards-sorting methods */
1218 
1219 /** sort an indexed element set in non-decreasing order, resulting in a permutation index array */
1220 extern
1221 void SCIPsort(
1222  int* perm, /**< pointer to store the resulting permutation */
1223  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1224  void* dataptr, /**< pointer to data field that is given to the external compare method */
1225  int len /**< number of elements to be sorted (valid index range) */
1226  );
1227 
1228 /** sort an index array in non-decreasing order */
1229 extern
1230 void SCIPsortInd(
1231  int* indarray, /**< pointer to the index array to be sorted */
1232  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1233  void* dataptr, /**< pointer to data field that is given to the external compare method */
1234  int len /**< length of array */
1235  );
1236 
1237 /** sort of an array of pointers in non-decreasing order */
1238 extern
1239 void SCIPsortPtr(
1240  void** ptrarray, /**< pointer array to be sorted */
1241  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1242  int len /**< length of array */
1243  );
1244 
1245 /** sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
1246 extern
1247 void SCIPsortPtrPtr(
1248  void** ptrarray1, /**< first pointer array to be sorted */
1249  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1250  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1251  int len /**< length of arrays */
1252  );
1253 
1254 /** sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
1255 extern
1256 void SCIPsortPtrReal(
1257  void** ptrarray, /**< pointer array to be sorted */
1258  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1259  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1260  int len /**< length of arrays */
1261  );
1262 
1263 /** sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
1264 extern
1265 void SCIPsortPtrInt(
1266  void** ptrarray, /**< pointer array to be sorted */
1267  int* intarray, /**< int array to be permuted in the same way */
1268  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1269  int len /**< length of arrays */
1270  );
1271 
1272 /** sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
1273 extern
1274 void SCIPsortPtrBool(
1275  void** ptrarray, /**< pointer array to be sorted */
1276  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1277  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1278  int len /**< length of arrays */
1279  );
1280 
1281 
1282 /** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
1283 extern
1284 void SCIPsortPtrIntInt(
1285  void** ptrarray, /**< pointer array to be sorted */
1286  int* intarray1, /**< first int array to be permuted in the same way */
1287  int* intarray2, /**< second int array to be permuted in the same way */
1288  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1289  int len /**< length of arrays */
1290  );
1291 
1292 /** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
1293 extern
1294 void SCIPsortPtrRealInt(
1295  void** ptrarray, /**< pointer array to be sorted */
1296  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1297  int* intarray, /**< int array to be permuted in the same way */
1298  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1299  int len /**< length of arrays */
1300  );
1301 
1302 /** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order */
1303 extern
1304 void SCIPsortPtrPtrInt(
1305  void** ptrarray1, /**< first pointer array to be sorted */
1306  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1307  int* intarray, /**< int array to be permuted in the same way */
1308  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1309  int len /**< length of arrays */
1310  );
1311 
1312 /** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
1313 extern
1314 void SCIPsortPtrPtrReal(
1315  void** ptrarray1, /**< first pointer array to be sorted */
1316  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1317  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1318  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1319  int len /**< length of arrays */
1320  );
1321 
1322 /** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1323 extern
1325  void** ptrarray1, /**< first pointer array to be sorted */
1326  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1327  int* intarray1, /**< first int array to be permuted in the same way */
1328  int* intarray2, /**< second int array to be permuted in the same way */
1329  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1330  int len /**< length of arrays */
1331  );
1332 
1333 /** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
1334 extern
1336  void** ptrarray, /**< pointer array to be sorted */
1337  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1338  int* intarray1, /**< first int array to be permuted in the same way */
1339  int* intarray2, /**< second int array to be permuted in the same way */
1340  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1341  int len /**< length of arrays */
1342  );
1343 
1344 /** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
1345 extern
1347  void** ptrarray1, /**< first pointer array to be sorted */
1348  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1349  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1350  int* intarray, /**< int array to be permuted in the same way */
1351  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1352  int len /**< length of arrays */
1353  );
1354 
1355 /** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
1356 extern
1358  void** ptrarray1, /**< first pointer array to be sorted */
1359  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1360  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1361  int* intarray, /**< int array to be permuted in the same way */
1362  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1363  int len /**< length of arrays */
1364  );
1365 
1366 /** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
1367 extern
1369  void** ptrarray1, /**< first pointer array to be sorted */
1370  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1371  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1372  int* intarray1, /**< first int array to be permuted in the same way */
1373  int* intarray2, /**< second int array to be permuted in the same way */
1374  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1375  int len /**< length of arrays */
1376  );
1377 
1378 /** sort an array of Reals in non-decreasing order */
1379 extern
1380 void SCIPsortReal(
1381  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1382  int len /**< length of arrays */
1383  );
1384 
1385 /** sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
1386 extern
1387 void SCIPsortRealPtr(
1388  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1389  void** ptrarray, /**< pointer array to be permuted in the same way */
1390  int len /**< length of arrays */
1391  );
1392 
1393 /** sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
1394 extern
1395 void SCIPsortRealInt(
1396  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1397  int* intarray, /**< int array to be permuted in the same way */
1398  int len /**< length of arrays */
1399  );
1400 
1401 /** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order */
1402 extern
1403 void SCIPsortRealBoolPtr(
1404  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1405  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1406  void** ptrarray, /**< pointer array to be permuted in the same way */
1407  int len /**< length of arrays */
1408  );
1409 
1410 /** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
1411 extern
1412 void SCIPsortRealIntLong(
1413  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1414  int* intarray, /**< int array to be permuted in the same way */
1415  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1416  int len /**< length of arrays */
1417  );
1418 
1419 /** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
1420 extern
1421 void SCIPsortRealIntPtr(
1422  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1423  int* intarray, /**< int array to be permuted in the same way */
1424  void** ptrarray, /**< pointer array to be permuted in the same way */
1425  int len /**< length of arrays */
1426  );
1427 
1428 /** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
1429 extern
1430 void SCIPsortRealRealPtr(
1431  SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
1432  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1433  void** ptrarray, /**< pointer array to be permuted in the same way */
1434  int len /**< length of arrays */
1435  );
1436 
1437 /** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
1438 extern
1440  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1441  void** ptrarray1, /**< pointer array to be permuted in the same way */
1442  void** ptrarray2, /**< pointer array to be permuted in the same way */
1443  int* intarray, /**< int array to be sorted */
1444  int len /**< length of arrays */
1445  );
1446 
1447 /** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1448 extern
1450  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1451  void** ptrarray1, /**< pointer array to be permuted in the same way */
1452  void** ptrarray2, /**< pointer array to be permuted in the same way */
1453  int* intarray1, /**< int array to be sorted */
1454  int* intarray2, /**< int array to be sorted */
1455  int len /**< length of arrays */
1456  );
1457 
1458 /** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order */
1459 extern
1461  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1462  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1463  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1464  int* intarray, /**< int array to be permuted in the same way */
1465  int len /**< length of arrays */
1466  );
1467 
1468 /** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
1469 extern
1471  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1472  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1473  int* intarray1, /**< int array to be permuted in the same way */
1474  int* intarray2, /**< int array to be permuted in the same way */
1475  int len /**< length of arrays */
1476  );
1477 
1478 /** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
1479 extern
1481  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1482  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1483  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1484  int* intarray, /**< int array to be permuted in the same way */
1485  int len /**< length of arrays */
1486  );
1487 
1488 /** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
1489 extern
1491  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1492  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1493  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1494  void** ptrarray, /**< pointer array to be permuted in the same way */
1495  int len /**< length of arrays */
1496  );
1497 
1498 /** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
1499 extern
1501  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1502  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1503  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1504  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1505  void** ptrarray, /**< pointer array to be permuted in the same way */
1506  int len /**< length of arrays */
1507  );
1508 
1509 /** sort array of ints in non-decreasing order */
1510 extern
1511 void SCIPsortInt(
1512  int* intarray, /**< int array to be sorted */
1513  int len /**< length of arrays */
1514  );
1515 
1516 /** sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order */
1517 extern
1518 void SCIPsortIntInt(
1519  int* intarray1, /**< int array to be sorted */
1520  int* intarray2, /**< second int array to be permuted in the same way */
1521  int len /**< length of arrays */
1522  );
1523 
1524 /** sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
1525 extern
1526 void SCIPsortIntPtr(
1527  int* intarray, /**< int array to be sorted */
1528  void** ptrarray, /**< pointer array to be permuted in the same way */
1529  int len /**< length of arrays */
1530  );
1531 
1532 /** sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order */
1533 extern
1534 void SCIPsortIntReal(
1535  int* intarray, /**< int array to be sorted */
1536  SCIP_Real* realarray, /**< real array to be permuted in the same way */
1537  int len /**< length of arrays */
1538  );
1539 
1540 /** sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
1541 extern
1542 void SCIPsortIntIntInt(
1543  int* intarray1, /**< int array to be sorted */
1544  int* intarray2, /**< second int array to be permuted in the same way */
1545  int* intarray3, /**< third int array to be permuted in the same way */
1546  int len /**< length of arrays */
1547  );
1548 
1549 /** sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order */
1550 extern
1551 void SCIPsortIntIntLong(
1552  int* intarray1, /**< int array to be sorted */
1553  int* intarray2, /**< second int array to be permuted in the same way */
1554  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1555  int len /**< length of arrays */
1556  );
1557 
1558 /** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
1559 extern
1560 void SCIPsortIntIntPtr(
1561  int* intarray1, /**< int array to be sorted */
1562  int* intarray2, /**< second int array to be permuted in the same way */
1563  void** ptrarray, /**< pointer array to be permuted in the same way */
1564  int len /**< length of arrays */
1565  );
1566 
1567 /** sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order */
1568 extern
1569 void SCIPsortIntIntReal(
1570  int* intarray1, /**< int array to be sorted */
1571  int* intarray2, /**< second int array to be permuted in the same way */
1572  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1573  int len /**< length of arrays */
1574  );
1575 
1576 /** sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order */
1577 extern
1578 void SCIPsortIntPtrReal(
1579  int* intarray, /**< int array to be sorted */
1580  void** ptrarray, /**< pointer array to be permuted in the same way */
1581  SCIP_Real* realarray, /**< real array to be permuted in the same way */
1582  int len /**< length of arrays */
1583  );
1584 
1585 /** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
1586 extern
1588  int* intarray1, /**< int array to be sorted */
1589  int* intarray2, /**< int array to be permuted in the same way */
1590  int* intarray3, /**< int array to be permuted in the same way */
1591  void** ptrarray, /**< pointer array to be permuted in the same way */
1592  int len /**< length of arrays */
1593  );
1594 
1595 /** sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
1596 extern
1598  int* intarray1, /**< int array to be sorted */
1599  void** ptrarray, /**< pointer array to be permuted in the same way */
1600  int* intarray2, /**< int array to be permuted in the same way */
1601  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1602  int len /**< length of arrays */
1603  );
1604 
1605 /** sort an array of Longints in non-decreasing order */
1606 extern
1607 void SCIPsortLong(
1608  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1609  int len /**< length of arrays */
1610  );
1611 
1612 /** sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
1613 extern
1614 void SCIPsortLongPtr(
1615  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1616  void** ptrarray, /**< pointer array to be permuted in the same way */
1617  int len /**< length of arrays */
1618  );
1619 
1620 /** sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
1621 extern
1622 void SCIPsortLongPtrInt(
1623  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1624  void** ptrarray, /**< pointer array to be permuted in the same way */
1625  int* intarray, /**< int array to be permuted in the same way */
1626  int len /**< length of arrays */
1627  );
1628 
1629 /** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
1630 extern
1632  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1633  void** ptrarray, /**< pointer array to be permuted in the same way */
1634  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1635  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1636  int len /**< length of arrays */
1637  );
1638 
1639 /** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
1640 extern
1642  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1643  void** ptrarray, /**< pointer array to be permuted in the same way */
1644  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
1645  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1646  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1647  int len /**< length of arrays */
1648  );
1649 
1650 /** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
1651 extern
1653  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1654  void** ptrarray, /**< pointer array to be permuted in the same way */
1655  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
1656  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1657  int* intarray, /**< int array to be permuted in the same way */
1658  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1659  int len /**< length of arrays */
1660  );
1661 
1662 /** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
1663 extern
1665  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1666  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1667  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1668  int* intarray, /**< int array to be permuted in the same way */
1669  int len /**< length of arrays */
1670  );
1671 
1672 /** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
1673 extern
1675  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1676  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1677  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1678  int* intarray1, /**< first int array to be permuted in the same way */
1679  int* intarray2, /**< second int array to be permuted in the same way */
1680  int len /**< length of arrays */
1681  );
1682 
1683 /** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
1684 extern
1686  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1687  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1688  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1689  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1690  int* intarray, /**< int array to be sorted */
1691  int len /**< length of arrays */
1692  );
1693 
1694 /** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
1695 extern
1697  void** ptrarray, /**< pointer array to be sorted */
1698  int* intarray1, /**< first int array to be permuted in the same way */
1699  int* intarray2, /**< second int array to be permuted in the same way */
1700  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
1701  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
1702  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1703  int len /**< length of arrays */
1704  );
1705 
1706 /** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
1707 extern
1709  int* intarray1, /**< int array to be sorted */
1710  void** ptrarray, /**< pointer array to be permuted in the same way */
1711  int* intarray2, /**< second int array to be permuted in the same way */
1712  int* intarray3, /**< thrid int array to be permuted in the same way */
1713  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
1714  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
1715  int len /**< length of arrays */
1716  );
1717 
1718 /* now all downwards-sorting methods */
1719 
1720 /** sort an indexed element set in non-increasing order, resulting in a permutation index array */
1721 extern
1722 void SCIPsortDown(
1723  int* perm, /**< pointer to store the resulting permutation */
1724  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1725  void* dataptr, /**< pointer to data field that is given to the external compare method */
1726  int len /**< number of elements to be sorted (valid index range) */
1727  );
1728 
1729 /** sort an index array in non-increasing order */
1730 extern
1731 void SCIPsortDownInd(
1732  int* indarray, /**< pointer to the index array to be sorted */
1733  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1734  void* dataptr, /**< pointer to data field that is given to the external compare method */
1735  int len /**< length of array */
1736  );
1737 
1738 /** sort of an array of pointers in non-increasing order */
1739 extern
1740 void SCIPsortDownPtr(
1741  void** ptrarray, /**< pointer array to be sorted */
1742  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1743  int len /**< length of array */
1744  );
1745 
1746 /** sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
1747 extern
1748 void SCIPsortDownPtrPtr(
1749  void** ptrarray1, /**< first pointer array to be sorted */
1750  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1751  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1752  int len /**< length of arrays */
1753  );
1754 
1755 /** sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
1756 extern
1757 void SCIPsortDownPtrReal(
1758  void** ptrarray, /**< pointer array to be sorted */
1759  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1760  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1761  int len /**< length of arrays */
1762  );
1763 
1764 /** sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order */
1765 extern
1766 void SCIPsortDownPtrInt(
1767  void** ptrarray, /**< pointer array to be sorted */
1768  int* intarray, /**< int array to be permuted in the same way */
1769  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1770  int len /**< length of arrays */
1771  );
1772 
1773 /** sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
1774 extern
1775 void SCIPsortDownPtrBool(
1776  void** ptrarray, /**< pointer array to be sorted */
1777  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1778  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1779  int len /**< length of arrays */
1780  );
1781 
1782 /** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
1783 extern
1785  void** ptrarray, /**< pointer array to be sorted */
1786  int* intarray1, /**< first int array to be permuted in the same way */
1787  int* intarray2, /**< second int array to be permuted in the same way */
1788  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1789  int len /**< length of arrays */
1790  );
1791 
1792 /** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
1793 extern
1795  void** ptrarray, /**< pointer array to be sorted */
1796  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1797  int* intarray, /**< int array to be permuted in the same way */
1798  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1799  int len /**< length of arrays */
1800  );
1801 
1802 /** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order */
1803 extern
1805  void** ptrarray1, /**< first pointer array to be sorted */
1806  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1807  int* intarray, /**< int array to be permuted in the same way */
1808  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1809  int len /**< length of arrays */
1810  );
1811 
1812 /** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
1813 extern
1815  void** ptrarray1, /**< first pointer array to be sorted */
1816  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1817  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1818  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1819  int len /**< length of arrays */
1820  );
1821 
1822 /** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
1823 extern
1825  void** ptrarray1, /**< first pointer array to be sorted */
1826  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1827  int* intarray1, /**< first int array to be permuted in the same way */
1828  int* intarray2, /**< second int array to be permuted in the same way */
1829  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1830  int len /**< length of arrays */
1831  );
1832 
1833 /** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
1834 extern
1836  void** ptrarray, /**< pointer array to be sorted */
1837  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1838  int* intarray1, /**< first int array to be permuted in the same way */
1839  int* intarray2, /**< second int array to be permuted in the same way */
1840  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1841  int len /**< length of arrays */
1842  );
1843 
1844 /** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
1845 extern
1847  void** ptrarray1, /**< first pointer array to be sorted */
1848  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1849  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1850  int* intarray, /**< int array to be permuted in the same way */
1851  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1852  int len /**< length of arrays */
1853  );
1854 
1855 /** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
1856 extern
1858  void** ptrarray1, /**< first pointer array to be sorted */
1859  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1860  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1861  int* intarray, /**< int array to be permuted in the same way */
1862  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1863  int len /**< length of arrays */
1864  );
1865 
1866 /** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
1867 extern
1869  void** ptrarray1, /**< first pointer array to be sorted */
1870  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1871  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1872  int* intarray1, /**< first int array to be permuted in the same way */
1873  int* intarray2, /**< second int array to be permuted in the same way */
1874  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1875  int len /**< length of arrays */
1876  );
1877 
1878 /** sort an array of Reals in non-increasing order */
1879 extern
1880 void SCIPsortDownReal(
1881  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1882  int len /**< length of arrays */
1883  );
1884 
1885 /** sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
1886 extern
1887 void SCIPsortDownRealPtr(
1888  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1889  void** ptrarray, /**< pointer array to be permuted in the same way */
1890  int len /**< length of arrays */
1891  );
1892 
1893 /** sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order */
1894 extern
1895 void SCIPsortDownRealInt(
1896  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1897  int* intarray, /**< pointer array to be permuted in the same way */
1898  int len /**< length of arrays */
1899  );
1900 
1901 /** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order */
1902 extern
1904  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1905  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1906  void** ptrarray, /**< pointer array to be permuted in the same way */
1907  int len /**< length of arrays */
1908  );
1909 
1910 /** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
1911 extern
1913  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1914  int* intarray, /**< int array to be permuted in the same way */
1915  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1916  int len /**< length of arrays */
1917  );
1918 
1919 /** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
1920 extern
1922  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1923  int* intarray, /**< int array to be permuted in the same way */
1924  void** ptrarray, /**< pointer array to be permuted in the same way */
1925  int len /**< length of arrays */
1926  );
1927 
1928 /** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
1929 extern
1931  SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
1932  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1933  void** ptrarray, /**< pointer array to be permuted in the same way */
1934  int len /**< length of arrays */
1935  );
1936 
1937 /** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
1938 extern
1940  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1941  void** ptrarray1, /**< pointer array to be permuted in the same way */
1942  void** ptrarray2, /**< pointer array to be permuted in the same way */
1943  int* intarray, /**< int array to be sorted */
1944  int len /**< length of arrays */
1945  );
1946 
1947 /** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
1948 extern
1950  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1951  void** ptrarray1, /**< pointer array to be permuted in the same way */
1952  void** ptrarray2, /**< pointer array to be permuted in the same way */
1953  int* intarray1, /**< int array to be sorted */
1954  int* intarray2, /**< int array to be sorted */
1955  int len /**< length of arrays */
1956  );
1957 
1958 /** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
1959 extern
1961  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1962  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1963  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1964  int* intarray, /**< int array to be permuted in the same way */
1965  int len /**< length of arrays */
1966  );
1967 
1968 /** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
1969 extern
1971  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1972  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1973  int* intarray1, /**< int array to be permuted in the same way */
1974  int* intarray2, /**< int array to be permuted in the same way */
1975  int len /**< length of arrays */
1976  );
1977 
1978 
1979 /** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
1980 extern
1982  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1983  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1984  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1985  int* intarray, /**< int array to be permuted in the same way */
1986  int len /**< length of arrays */
1987  );
1988 
1989 /** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
1990 extern
1992  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1993  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1994  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1995  void** ptrarray, /**< pointer array to be permuted in the same way */
1996  int len /**< length of arrays */
1997  );
1998 
1999 /** sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
2000 extern
2002  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2003  void** ptrarray1, /**< pointer array to be permuted in the same way */
2004  void** ptrarray2, /**< pointer array to be permuted in the same way */
2005  int len /**< length of arrays */
2006  );
2007 
2008 /** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
2009 extern
2011  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2012  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2013  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2014  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2015  void** ptrarray, /**< pointer array to be permuted in the same way */
2016  int len /**< length of arrays */
2017  );
2018 
2019 /** sort array of ints in non-increasing order */
2020 extern
2021 void SCIPsortDownInt(
2022  int* intarray, /**< int array to be sorted */
2023  int len /**< length of arrays */
2024  );
2025 
2026 /** sort of two joint arrays of ints/ints, sorted by first array in non-increasing order */
2027 extern
2028 void SCIPsortDownIntInt(
2029  int* intarray1, /**< int array to be sorted */
2030  int* intarray2, /**< second int array to be permuted in the same way */
2031  int len /**< length of arrays */
2032  );
2033 
2034 /** sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order */
2035 extern
2036 void SCIPsortDownIntPtr(
2037  int* intarray, /**< int array to be sorted */
2038  void** ptrarray, /**< pointer array to be permuted in the same way */
2039  int len /**< length of arrays */
2040  );
2041 
2042 /** sort of two joint arrays of ints/reals, sorted by first array in non-increasing order */
2043 extern
2044 void SCIPsortDownIntReal(
2045  int* intarray, /**< int array to be sorted */
2046  SCIP_Real* realarray, /**< real array to be permuted in the same way */
2047  int len /**< length of arrays */
2048  );
2049 
2050 /** sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
2051 extern
2053  int* intarray1, /**< int array to be sorted */
2054  int* intarray2, /**< second int array to be permuted in the same way */
2055  int* intarray3, /**< third int array to be permuted in the same way */
2056  int len /**< length of arrays */
2057  );
2058 
2059 /** sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
2060 extern
2062  int* intarray1, /**< int array to be sorted */
2063  int* intarray2, /**< second int array to be permuted in the same way */
2064  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2065  int len /**< length of arrays */
2066  );
2067 
2068 /** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
2069 extern
2071  int* intarray1, /**< int array to be sorted */
2072  int* intarray2, /**< second int array to be permuted in the same way */
2073  void** ptrarray, /**< pointer array to be permuted in the same way */
2074  int len /**< length of arrays */
2075  );
2076 
2077 /** sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
2078 extern
2080  int* intarray1, /**< int array to be sorted */
2081  int* intarray2, /**< second int array to be permuted in the same way */
2082  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2083  int len /**< length of arrays */
2084  );
2085 
2086 /** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order */
2087 extern
2089  int* intarray1, /**< int array to be sorted */
2090  int* intarray2, /**< int array to be permuted in the same way */
2091  int* intarray3, /**< int array to be permuted in the same way */
2092  void** ptrarray, /**< pointer array to be permuted in the same way */
2093  int len /**< length of arrays */
2094  );
2095 
2096 /** sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
2097 extern
2099  int* intarray1, /**< int array to be sorted */
2100  void** ptrarray, /**< pointer array to be permuted in the same way */
2101  int* intarray2, /**< int array to be permuted in the same way */
2102  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2103  int len /**< length of arrays */
2104  );
2105 
2106 /** sort an array of Longints in non-increasing order */
2107 extern
2108 void SCIPsortDownLong(
2109  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2110  int len /**< length of arrays */
2111  );
2112 
2113 /** sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
2114 extern
2115 void SCIPsortDownLongPtr(
2116  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2117  void** ptrarray, /**< pointer array to be permuted in the same way */
2118  int len /**< length of arrays */
2119  );
2120 
2121 /** sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
2122 extern
2124  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2125  void** ptrarray, /**< pointer array to be permuted in the same way */
2126  int* intarray, /**< int array to be permuted in the same way */
2127  int len /**< length of arrays */
2128  );
2129 
2130 /** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
2131 extern
2133  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2134  void** ptrarray, /**< pointer array to be permuted in the same way */
2135  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2136  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2137  int len /**< length of arrays */
2138  );
2139 
2140 /** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
2141 extern
2143  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2144  void** ptrarray, /**< pointer array to be permuted in the same way */
2145  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
2146  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2147  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2148  int len /**< length of arrays */
2149  );
2150 
2151 /** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
2152 extern
2154  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2155  void** ptrarray, /**< pointer array to be permuted in the same way */
2156  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
2157  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2158  int* intarray, /**< int array to be permuted in the same way */
2159  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2160  int len /**< length of arrays */
2161  );
2162 
2163 /** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
2164 extern
2166  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2167  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2168  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2169  int* intarray, /**< int array to be permuted in the same way */
2170  int len /**< length of arrays */
2171  );
2172 
2173 /** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
2174 extern
2176  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2177  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2178  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2179  int* intarray1, /**< first int array to be permuted in the same way */
2180  int* intarray2, /**< second int array to be permuted in the same way */
2181  int len /**< length of arrays */
2182  );
2183 
2184 /** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
2185 extern
2187  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2188  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2189  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2190  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2191  int* intarray, /**< int array to be sorted */
2192  int len /**< length of arrays */
2193  );
2194 
2195 /** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2196 extern
2198  void** ptrarray, /**< pointer array to be sorted */
2199  int* intarray1, /**< first int array to be permuted in the same way */
2200  int* intarray2, /**< second int array to be permuted in the same way */
2201  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2202  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2203  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2204  int len /**< length of arrays */
2205  );
2206 
2207 /** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2208 extern
2210  int* intarray1, /**< int array to be sorted */
2211  void** ptrarray, /**< pointer array to be permuted in the same way */
2212  int* intarray2, /**< second int array to be permuted in the same way */
2213  int* intarray3, /**< thrid int array to be permuted in the same way */
2214  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2215  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2216  int len /**< length of arrays */
2217  );
2218 
2219 /*
2220  * Sorted vectors
2221  */
2222 
2223 /* upwards insertion */
2224 
2225 /** insert a new element into an index array in non-decreasing order */
2226 extern
2228  int* indarray, /**< pointer to the index array where an element is to be inserted */
2229  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
2230  void* dataptr, /**< pointer to data field that is given to the external compare method */
2231  int keyval, /**< key value of new element */
2232  int* len, /**< pointer to length of arrays (will be increased by 1) */
2233  int* pos /**< pointer to store the insertion position, or NULL */
2234  );
2235 
2236 /** insert a new element into an array of pointers in non-decreasing order */
2237 extern
2239  void** ptrarray, /**< pointer to the pointer array where an element is to be inserted */
2240  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2241  void* keyval, /**< key value of new element */
2242  int* len, /**< pointer to length of arrays (will be increased by 1) */
2243  int* pos /**< pointer to store the insertion position, or NULL */
2244  );
2245 
2246 /** insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order */
2247 extern
2249  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2250  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2251  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2252  void* keyval, /**< key value of new element */
2253  void* field1val, /**< additional value of new element */
2254  int* len, /**< pointer to length of arrays (will be increased by 1) */
2255  int* pos /**< pointer to store the insertion position, or NULL */
2256  );
2257 
2258 /** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
2259 extern
2261  void** ptrarray, /**< pointer array where an element is to be inserted */
2262  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2263  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2264  void* keyval, /**< key value of new element */
2265  SCIP_Real field1val, /**< additional value of new element */
2266  int* len, /**< pointer to length of arrays (will be increased by 1) */
2267  int* pos /**< pointer to store the insertion position, or NULL */
2268  );
2269 
2270 /** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
2271 extern
2273  void** ptrarray, /**< pointer array where an element is to be inserted */
2274  int* intarray, /**< int array where an element is to be inserted */
2275  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2276  void* keyval, /**< key value of new element */
2277  int field1val, /**< additional value of new element */
2278  int* len, /**< pointer to length of arrays (will be increased by 1) */
2279  int* pos /**< pointer to store the insertion position, or NULL */
2280  );
2281 
2282 /** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
2283 extern
2285  void** ptrarray, /**< pointer array where an element is to be inserted */
2286  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2287  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2288  void* keyval, /**< key value of new element */
2289  SCIP_Bool field1val, /**< additional value of new element */
2290  int* len, /**< pointer to length of arrays (will be increased by 1) */
2291  int* pos /**< pointer to store the insertion position, or NULL */
2292  );
2293 
2294 /** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
2295 extern
2297  void** ptrarray, /**< pointer array where an element is to be inserted */
2298  int* intarray1, /**< first int array where an element is to be inserted */
2299  int* intarray2, /**< second int array where an element is to be inserted */
2300  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2301  void* keyval, /**< key value of new element */
2302  int field1val, /**< additional value of new element */
2303  int field2val, /**< additional value of new element */
2304  int* len, /**< pointer to length of arrays (will be increased by 1) */
2305  int* pos /**< pointer to store the insertion position, or NULL */
2306  );
2307 
2308 /** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
2309 extern
2311  void** ptrarray, /**< pointer array where an element is to be inserted */
2312  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2313  int* intarray, /**< int array where an element is to be inserted */
2314  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2315  void* keyval, /**< key value of new element */
2316  SCIP_Real field1val, /**< additional value of new element */
2317  int field2val, /**< additional value of new element */
2318  int* len, /**< pointer to length of arrays (will be increased by 1) */
2319  int* pos /**< pointer to store the insertion position, or NULL */
2320  );
2321 
2322 /** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
2323 extern
2325  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2326  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2327  int* intarray, /**< int array where an element is to be inserted */
2328  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2329  void* keyval, /**< key value of new element */
2330  void* field1val, /**< additional value of new element */
2331  int field2val, /**< additional value of new element */
2332  int* len, /**< pointer to length of arrays (will be increased by 1) */
2333  int* pos /**< pointer to store the insertion position, or NULL */
2334  );
2335 
2336 /** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
2337 extern
2339  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2340  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2341  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2342  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2343  void* keyval, /**< key value of new element */
2344  void* field1val, /**< additional value of new element */
2345  SCIP_Real field2val, /**< additional value of new element */
2346  int* len, /**< pointer to length of arrays (will be increased by 1) */
2347  int* pos /**< pointer to store the insertion position, or NULL */
2348  );
2349 
2350 /** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
2351 extern
2353  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2354  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2355  int* intarray1, /**< first int array where an element is to be inserted */
2356  int* intarray2, /**< second int array where an element is to be inserted */
2357  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2358  void* keyval, /**< key value of new element */
2359  void* field1val, /**< additional value of new element */
2360  int field2val, /**< additional value of new element */
2361  int field3val, /**< additional value of new element */
2362  int* len, /**< pointer to length of arrays (will be increased by 1) */
2363  int* pos /**< pointer to store the insertion position, or NULL */
2364  );
2365 
2366 /** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
2367 extern
2369  void** ptrarray, /**< pointer array where an element is to be inserted */
2370  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2371  int* intarray1, /**< first int array where an element is to be inserted */
2372  int* intarray2, /**< second int array where an element is to be inserted */
2373  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2374  void* keyval, /**< key value of new element */
2375  SCIP_Real field1val, /**< additional value of new element */
2376  int field2val, /**< additional value of new element */
2377  int field3val, /**< additional value of new element */
2378  int* len, /**< pointer to length of arrays (will be increased by 1) */
2379  int* pos /**< pointer to store the insertion position, or NULL */
2380  );
2381 
2382 /** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
2383 extern
2385  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2386  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2387  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2388  int* intarray, /**< int array to be sorted */
2389  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2390  void* keyval, /**< key value of new element */
2391  void* field1val, /**< additional value of new element */
2392  SCIP_Real field2val, /**< additional value of new element */
2393  int field3val, /**< additional value of new element */
2394  int* len, /**< pointer to length of arrays (will be increased by 1) */
2395  int* pos /**< pointer to store the insertion position, or NULL */
2396  );
2397 
2398 /** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
2399 extern
2401  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2402  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2403  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2404  int* intarray, /**< int array to be sorted */
2405  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2406  void* keyval, /**< key value of new element */
2407  void* field1val, /**< additional value of new element */
2408  SCIP_Longint field2val, /**< additional value of new element */
2409  int field3val, /**< additional value of new element */
2410  int* len, /**< pointer to length of arrays (will be increased by 1) */
2411  int* pos /**< pointer to store the insertion position, or NULL */
2412  );
2413 
2414 /** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
2415 extern
2417  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2418  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2419  SCIP_Longint* longarray, /**< SCIP_Longint where an element is to be inserted */
2420  int* intarray1, /**< first int array where an element is to be inserted */
2421  int* intarray2, /**< second int array where an element is to be inserted */
2422  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2423  void* keyval, /**< key value of new element */
2424  void* field1val, /**< additional value of new element */
2425  SCIP_Longint field2val, /**< additional value of new element */
2426  int field3val, /**< additional value of new element */
2427  int field4val, /**< additional value of new element */
2428  int* len, /**< pointer to length of arrays (will be increased by 1) */
2429  int* pos /**< pointer to store the insertion position, or NULL */
2430  );
2431 
2432 /** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
2433 extern
2435  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2436  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2437  void** ptrarray, /**< pointer array to be permuted in the same way */
2438  SCIP_Real keyval, /**< key value of new element */
2439  SCIP_Bool field1val, /**< additional value of new element */
2440  void* field2val, /**< additional value of new element */
2441  int* len, /**< pointer to length of arrays (will be increased by 1) */
2442  int* pos /**< pointer to store the insertion position, or NULL */
2443  );
2444 
2445 /** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
2446 extern
2448  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2449  void** ptrarray, /**< pointer array where an element is to be inserted */
2450  SCIP_Real keyval, /**< key value of new element */
2451  void* field1val, /**< additional value of new element */
2452  int* len, /**< pointer to length of arrays (will be increased by 1) */
2453  int* pos /**< pointer to store the insertion position, or NULL */
2454  );
2455 
2456 /** insert a new element into an arrays of Reals, sorted in non-decreasing order */
2457 extern
2459  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2460  SCIP_Real keyval, /**< key value of new element */
2461  int* len, /**< pointer to length of arrays (will be increased by 1) */
2462  int* pos /**< pointer to store the insertion position, or NULL */
2463  );
2464 
2465 /** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
2466 extern
2468  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2469  int* intarray, /**< int array where an element is to be inserted */
2470  SCIP_Real keyval, /**< key value of new element */
2471  int field1val, /**< additional value of new element */
2472  int* len, /**< pointer to length of arrays (will be increased by 1) */
2473  int* pos /**< pointer to store the insertion position, or NULL */
2474  );
2475 
2476 /** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
2477 extern
2479  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2480  int* intarray, /**< int array to be permuted in the same way */
2481  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2482  SCIP_Real keyval, /**< key value of new element */
2483  int field1val, /**< additional value of new element */
2484  SCIP_Longint field2val, /**< additional value of new element */
2485  int* len, /**< pointer to length of arrays (will be increased by 1) */
2486  int* pos /**< pointer to store the insertion position, or NULL */
2487  );
2488 
2489 /** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
2490 extern
2492  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2493  int* intarray, /**< int array where an element is to be inserted */
2494  void** ptrarray, /**< pointer array where an element is to be inserted */
2495  SCIP_Real keyval, /**< key value of new element */
2496  int field1val, /**< additional value of new element */
2497  void* field2val, /**< additional value of new element */
2498  int* len, /**< pointer to length of arrays (will be increased by 1) */
2499  int* pos /**< pointer to store the insertion position, or NULL */
2500  );
2501 
2502 /** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
2503 extern
2505  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2506  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2507  void** ptrarray, /**< pointer array where an element is to be inserted */
2508  SCIP_Real keyval, /**< key value of new element */
2509  SCIP_Real field1val, /**< additional value of new element */
2510  void* field2val, /**< additional value of new element */
2511  int* len, /**< pointer to length of arrays (will be increased by 1) */
2512  int* pos /**< pointer to store the insertion position, or NULL */
2513  );
2514 
2515 /** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
2516 extern
2518  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2519  void** ptrarray1, /**< pointer array where an element is to be inserted */
2520  void** ptrarray2, /**< pointer array where an element is to be inserted */
2521  int* intarray, /**< int array where an element is to be inserted */
2522  SCIP_Real keyval, /**< key value of new element */
2523  void* field1val, /**< additional value of new element */
2524  void* field2val, /**< additional value of new element */
2525  int intval, /**< additional value of new element */
2526  int* len, /**< pointer to length of arrays (will be increased by 1) */
2527  int* pos /**< pointer to store the insertion position, or NULL */
2528  );
2529 
2530 /** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
2531 extern
2533  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2534  void** ptrarray1, /**< pointer array where an element is to be inserted */
2535  void** ptrarray2, /**< pointer array where an element is to be inserted */
2536  int* intarray1, /**< int array where an element is to be inserted */
2537  int* intarray2, /**< int array where an element is to be inserted */
2538  SCIP_Real keyval, /**< key value of new element */
2539  void* field1val, /**< additional value of new element */
2540  void* field2val, /**< additional value of new element */
2541  int intval1, /**< additional value of new element */
2542  int intval2, /**< additional value of new element */
2543  int* len, /**< pointer to length of arrays (will be increased by 1) */
2544  int* pos /**< pointer to store the insertion position, or NULL */
2545  );
2546 
2547 /** insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
2548 extern
2550  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
2551  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2552  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
2553  int* intarray, /**< int array where an element is to be inserted */
2554  SCIP_Real keyval, /**< key value of new element */
2555  SCIP_Longint field1val, /**< additional value of new element */
2556  SCIP_Real field2val, /**< additional value of new element */
2557  int field3val, /**< additional value of new element */
2558  int* len, /**< pointer to length of arrays (will be increased by 1) */
2559  int* pos /**< pointer to store the insertion position, or NULL */
2560  );
2561 
2562 /** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
2563 extern
2565  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2566  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2567  int* intarray1, /**< first int array where an element is to be inserted */
2568  int* intarray2, /**< second int array where an element is to be inserted */
2569  SCIP_Real keyval, /**< key value of new element */
2570  SCIP_Real field1val, /**< additional value of new element */
2571  int field2val, /**< additional value of new element */
2572  int field3val, /**< additional value of new element */
2573  int* len, /**< pointer to length of arrays (will be increased by 1) */
2574  int* pos /**< pointer to store the insertion position, or NULL */
2575  );
2576 
2577 /** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
2578 extern
2580  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2581  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2582  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2583  int* intarray, /**< int array where an element is to be inserted */
2584  SCIP_Real keyval, /**< key value of new element */
2585  SCIP_Real field1val, /**< additional value of new element */
2586  SCIP_Real field2val, /**< additional value of new element */
2587  int field3val, /**< additional value of new element */
2588  int* len, /**< pointer to length of arrays (will be increased by 1) */
2589  int* pos /**< pointer to store the insertion position, or NULL */
2590  );
2591 
2592 /** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
2593 extern
2595  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2596  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2597  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2598  void** ptrarray, /**< pointer array where an element is to be inserted */
2599  SCIP_Real keyval, /**< key value of new element */
2600  SCIP_Real field1val, /**< additional value of new element */
2601  SCIP_Real field2val, /**< additional value of new element */
2602  void* field3val, /**< additional value of new element */
2603  int* len, /**< pointer to length of arrays (will be increased by 1) */
2604  int* pos /**< pointer to store the insertion position, or NULL */
2605  );
2606 
2607 /** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
2608 extern
2610  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2611  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2612  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2613  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2614  void** ptrarray, /**< pointer array where an element is to be inserted */
2615  SCIP_Real keyval, /**< key value of new element */
2616  SCIP_Real field1val, /**< additional value of new element */
2617  SCIP_Real field2val, /**< additional value of new element */
2618  SCIP_Bool field3val, /**< additional value of new element */
2619  void* field4val, /**< additional value of new element */
2620  int* len, /**< pointer to length of arrays (will be increased by 1) */
2621  int* pos /**< pointer to store the insertion position, or NULL */
2622  );
2623 
2624 /** insert a new element into an array of ints in non-decreasing order */
2625 extern
2627  int* intarray, /**< int array where an element is to be inserted */
2628  int keyval, /**< key value of new element */
2629  int* len, /**< pointer to length of arrays (will be increased by 1) */
2630  int* pos /**< pointer to store the insertion position, or NULL */
2631  );
2632 
2633 /** insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order */
2634 extern
2636  int* intarray1, /**< int array where an element is to be inserted */
2637  int* intarray2, /**< second int array where an element is to be inserted */
2638  int keyval, /**< key value of new element */
2639  int field1val, /**< additional value of new element */
2640  int* len, /**< pointer to length of arrays (will be increased by 1) */
2641  int* pos /**< pointer to store the insertion position, or NULL */
2642  );
2643 
2644 /** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
2645 extern
2647  int* intarray, /**< int array where an element is to be inserted */
2648  void** ptrarray, /**< pointer array where an element is to be inserted */
2649  int keyval, /**< key value of new element */
2650  void* field1val, /**< additional value of new element */
2651  int* len, /**< pointer to length of arrays (will be increased by 1) */
2652  int* pos /**< pointer to store the insertion position, or NULL */
2653  );
2654 
2655 /** insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order */
2656 extern
2658  int* intarray, /**< int array where an element is to be inserted */
2659  SCIP_Real* realarray, /**< real array where an element is to be inserted */
2660  int keyval, /**< key value of new element */
2661  SCIP_Real field1val, /**< additional value of new element */
2662  int* len, /**< pointer to length of arrays (will be increased by 1) */
2663  int* pos /**< pointer to store the insertion position, or NULL */
2664  );
2665 
2666 /** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
2667 extern
2669  int* intarray1, /**< int array where an element is to be inserted */
2670  int* intarray2, /**< second int array where an element is to be inserted */
2671  int* intarray3, /**< third int array where an element is to be inserted */
2672  int keyval, /**< key value of new element */
2673  int field1val, /**< additional value of new element */
2674  int field2val, /**< additional value of new element */
2675  int* len, /**< pointer to length of arrays (will be increased by 1) */
2676  int* pos /**< pointer to store the insertion position, or NULL */
2677  );
2678 
2679 /** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
2680 extern
2682  int* intarray1, /**< int array where an element is to be inserted */
2683  int* intarray2, /**< second int array where an element is to be inserted */
2684  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2685  int keyval, /**< key value of new element */
2686  int field1val, /**< additional value of new element */
2687  SCIP_Longint field2val, /**< additional value of new element */
2688  int* len, /**< pointer to length of arrays (will be increased by 1) */
2689  int* pos /**< pointer to store the insertion position, or NULL */
2690  );
2691 
2692 /** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
2693 extern
2695  int* intarray1, /**< first int array where an element is to be inserted */
2696  int* intarray2, /**< second int array where an element is to be inserted */
2697  void** ptrarray, /**< pointer array where an element is to be inserted */
2698  int keyval, /**< key value of new element */
2699  int field1val, /**< additional value of new element */
2700  void* field2val, /**< additional value of new element */
2701  int* len, /**< pointer to length of arrays (will be increased by 1) */
2702  int* pos /**< pointer to store the insertion position, or NULL */
2703  );
2704 
2705 /** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
2706 extern
2708  int* intarray1, /**< first int array where an element is to be inserted */
2709  int* intarray2, /**< second int array where an element is to be inserted */
2710  SCIP_Real* realarray, /**< real array where an element is to be inserted */
2711  int keyval, /**< key value of new element */
2712  int field1val, /**< additional value of new element */
2713  SCIP_Real field2val, /**< additional value of new element */
2714  int* len, /**< pointer to length of arrays (will be increased by 1) */
2715  int* pos /**< pointer to store the insertion position, or NULL */
2716  );
2717 
2718 /** insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
2719 extern
2721  int* intarray, /**< int array where an element is to be inserted */
2722  void** ptrarray, /**< pointer array where an element is to be inserted */
2723  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2724  int keyval, /**< key value of new element */
2725  void* field1val, /**< additional value of new element */
2726  SCIP_Real field2val, /**< additional value of new element */
2727  int* len, /**< pointer to length of arrays (will be increased by 1) */
2728  int* pos /**< pointer to store the insertion position, or NULL */
2729  );
2730 
2731 /** insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
2732 extern
2734  int* intarray1, /**< first int array where an element is to be inserted */
2735  int* intarray2, /**< second int array where an element is to be inserted */
2736  int* intarray3, /**< second int array where an element is to be inserted */
2737  void** ptrarray, /**< pointer array where an element is to be inserted */
2738  int keyval, /**< key value of new element */
2739  int field1val, /**< additional value of new element */
2740  int field2val, /**< additional value of new element */
2741  void* field3val, /**< additional value of new element */
2742  int* len, /**< pointer to length of arrays (will be increased by 1) */
2743  int* pos /**< pointer to store the insertion position, or NULL */
2744  );
2745 
2746 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
2747 extern
2749  int* intarray1, /**< first int array where an element is to be inserted */
2750  void** ptrarray, /**< pointer array where an element is to be inserted */
2751  int* intarray2, /**< second int array where an element is to be inserted */
2752  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2753  int keyval, /**< key value of new element */
2754  void* field1val, /**< additional value of new element */
2755  int field2val, /**< additional value of new element */
2756  SCIP_Real field3val, /**< additional value of new element */
2757  int* len, /**< pointer to length of arrays (will be increased by 1) */
2758  int* pos /**< pointer to store the insertion position, or NULL */
2759  );
2760 
2761 /** insert a new element into an array of Longints, sorted in non-decreasing order */
2762 extern
2764  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2765  SCIP_Longint keyval, /**< key value of new element */
2766  int* len, /**< pointer to length of arrays (will be increased by 1) */
2767  int* pos /**< pointer to store the insertion position, or NULL */
2768  );
2769 
2770 /** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
2771 extern
2773  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2774  void** ptrarray, /**< pointer array where an element is to be inserted */
2775  SCIP_Longint keyval, /**< key value of new element */
2776  void* field1val, /**< additional value of new element */
2777  int* len, /**< pointer to length of arrays (will be increased by 1) */
2778  int* pos /**< pointer to store the insertion position, or NULL */
2779  );
2780 
2781 /** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
2782 extern
2784  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2785  void** ptrarray, /**< pointer array where an element is to be inserted */
2786  int* intarray, /**< int array where an element is to be inserted */
2787  SCIP_Longint keyval, /**< key value of new element */
2788  void* field1val, /**< additional value of new element */
2789  int field2val, /**< additional value of new element */
2790  int* len, /**< pointer to length of arrays (will be increased by 1) */
2791  int* pos /**< pointer to store the insertion position, or NULL */
2792  );
2793 
2794 /** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
2795 extern
2797  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2798  void** ptrarray, /**< pointer array where an element is to be inserted */
2799  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2800  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2801  SCIP_Longint keyval, /**< key value of new element */
2802  void* field1val, /**< additional value of new element */
2803  SCIP_Real field2val, /**< additional value of new element */
2804  SCIP_Bool field3val, /**< additional value of new element */
2805  int* len, /**< pointer to length of arrays (will be increased by 1) */
2806  int* pos /**< pointer to store the insertion position, or NULL */
2807  );
2808 
2809 /** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
2810 extern
2812  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2813  void** ptrarray, /**< pointer array where an element is to be inserted */
2814  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
2815  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2816  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2817  SCIP_Longint keyval, /**< key value of new element */
2818  void* field1val, /**< additional value of new element */
2819  SCIP_Real field2val, /**< additional value of new element */
2820  SCIP_Real field3val, /**< additional value of new element */
2821  SCIP_Bool field4val, /**< additional value of new element */
2822  int* len, /**< pointer to length of arrays (will be increased by 1) */
2823  int* pos /**< pointer to store the insertion position, or NULL */
2824  );
2825 
2826 /** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
2827 extern
2829  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2830  void** ptrarray, /**< pointer array where an element is to be inserted */
2831  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
2832  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2833  int* intarray, /**< int array where an element is to be inserted */
2834  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2835  SCIP_Longint keyval, /**< key value of new element */
2836  void* field1val, /**< additional value of new element */
2837  SCIP_Real field2val, /**< additional value of new element */
2838  SCIP_Real field3val, /**< additional value of new element */
2839  int field4val, /**< additional value of new element */
2840  SCIP_Bool field5val, /**< additional value of new element */
2841  int* len, /**< pointer to length of arrays (will be increased by 1) */
2842  int* pos /**< pointer to store the insertion position, or NULL */
2843  );
2844 
2845 /** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
2846 extern
2848  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2849  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2850  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2851  int* intarray, /**< int array where an element is to be inserted */
2852  SCIP_Longint keyval, /**< key value of new element */
2853  void* field1val, /**< additional value of new element */
2854  void* field2val, /**< additional value of new element */
2855  int field3val, /**< additional value of new element */
2856  int* len, /**< pointer to length of arrays (will be increased by 1) */
2857  int* pos /**< pointer to store the insertion position, or NULL */
2858  );
2859 
2860 /** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
2861 extern
2863  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2864  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2865  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2866  int* intarray1, /**< first int array where an element is to be inserted */
2867  int* intarray2, /**< second int array where an element is to be inserted */
2868  SCIP_Longint keyval, /**< key value of new element */
2869  void* field1val, /**< additional value of new element */
2870  void* field2val, /**< additional value of new element */
2871  int field3val, /**< additional value of new element */
2872  int field4val, /**< additional value of new element */
2873  int* len, /**< pointer to length of arrays (will be increased by 1) */
2874  int* pos /**< pointer to store the insertion position, or NULL */
2875  );
2876 
2877 /** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
2878 extern
2880  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2881  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2882  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2883  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2884  int* intarray, /**< int array to be sorted */
2885  SCIP_Longint keyval, /**< key value of new element */
2886  void* field1val, /**< additional value of new element */
2887  void* field2val, /**< additional value of new element */
2888  SCIP_Bool field3val, /**< additional value of new element */
2889  int field4val, /**< additional value of new element */
2890  int* len, /**< pointer to length of arrays (will be increased by 1) */
2891  int* pos /**< pointer to store the insertion position, or NULL */
2892  );
2893 
2894 /** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
2895 extern
2897  void** ptrarray, /**< pointer array to be sorted */
2898  int* intarray1, /**< first int array to be permuted in the same way */
2899  int* intarray2, /**< second int array to be permuted in the same way */
2900  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2901  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2902  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2903  void* keyval, /**< key value of new element */
2904  int field1val, /**< additional value of new element */
2905  int field2val, /**< additional value of new element */
2906  SCIP_Bool field3val, /**< additional value of new element */
2907  SCIP_Bool field4val, /**< additional value of new element */
2908  int* len, /**< pointer to length of arrays (will be increased by 1) */
2909  int* pos /**< pointer to store the insertion position, or NULL */
2910  );
2911 
2912 /** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
2913 extern
2915  int* intarray1, /**< int array to be sorted */
2916  void** ptrarray, /**< pointer array to be permuted in the same way */
2917  int* intarray2, /**< second int array to be permuted in the same way */
2918  int* intarray3, /**< thrid int array to be permuted in the same way */
2919  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2920  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2921  int keyval, /**< key value of new element */
2922  void* field1val, /**< additional value of new element */
2923  int field2val, /**< additional value of new element */
2924  int field3val, /**< additional value of new element */
2925  SCIP_Bool field4val, /**< additional value of new element */
2926  SCIP_Bool field5val, /**< additional value of new element */
2927  int* len, /**< pointer to length of arrays (will be increased by 1) */
2928  int* pos /**< pointer to store the insertion position, or NULL */
2929  );
2930 
2931 
2932 /* downwards insertion */
2933 
2934 /** insert a new element into an index array in non-increasing order */
2935 extern
2937  int* indarray, /**< pointer to the index array where an element is to be inserted */
2938  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
2939  void* dataptr, /**< pointer to data field that is given to the external compare method */
2940  int keyval, /**< key value of new element */
2941  int* len, /**< pointer to length of arrays (will be increased by 1) */
2942  int* pos /**< pointer to store the insertion position, or NULL */
2943  );
2944 
2945 /** insert a new element into an array of pointers in non-increasing order */
2946 extern
2948  void** ptrarray, /**< pointer array where an element is to be inserted */
2949  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2950  void* keyval, /**< key value of new element */
2951  int* len, /**< pointer to length of arrays (will be increased by 1) */
2952  int* pos /**< pointer to store the insertion position, or NULL */
2953  );
2954 
2955 /** insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
2956 extern
2958  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2959  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2960  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2961  void* keyval, /**< key value of new element */
2962  void* field1val, /**< additional value of new element */
2963  int* len, /**< pointer to length of arrays (will be increased by 1) */
2964  int* pos /**< pointer to store the insertion position, or NULL */
2965  );
2966 
2967 /** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
2968 extern
2970  void** ptrarray, /**< pointer array where an element is to be inserted */
2971  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2972  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2973  void* keyval, /**< key value of new element */
2974  SCIP_Real field1val, /**< additional value of new element */
2975  int* len, /**< pointer to length of arrays (will be increased by 1) */
2976  int* pos /**< pointer to store the insertion position, or NULL */
2977  );
2978 
2979 /** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order */
2980 extern
2982  void** ptrarray, /**< pointer array where an element is to be inserted */
2983  int* intarray, /**< int array where an element is to be inserted */
2984  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2985  void* keyval, /**< key value of new element */
2986  int field1val, /**< additional value of new element */
2987  int* len, /**< pointer to length of arrays (will be increased by 1) */
2988  int* pos /**< pointer to store the insertion position, or NULL */
2989  );
2990 
2991 /** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
2992 extern
2994  void** ptrarray, /**< pointer array where an element is to be inserted */
2995  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2996  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2997  void* keyval, /**< key value of new element */
2998  SCIP_Bool field1val, /**< additional value of new element */
2999  int* len, /**< pointer to length of arrays (will be increased by 1) */
3000  int* pos /**< pointer to store the insertion position, or NULL */
3001  );
3002 
3003 /** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
3004 extern
3006  void** ptrarray, /**< pointer array where an element is to be inserted */
3007  int* intarray1, /**< first int array where an element is to be inserted */
3008  int* intarray2, /**< second int array where an element is to be inserted */
3009  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3010  void* keyval, /**< key value of new element */
3011  int field1val, /**< additional value of new element */
3012  int field2val, /**< additional value of new element */
3013  int* len, /**< pointer to length of arrays (will be increased by 1) */
3014  int* pos /**< pointer to store the insertion position, or NULL */
3015  );
3016 
3017 /** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
3018 extern
3020  void** ptrarray, /**< pointer array where an element is to be inserted */
3021  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3022  int* intarray, /**< int array where an element is to be inserted */
3023  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3024  void* keyval, /**< key value of new element */
3025  SCIP_Real field1val, /**< additional value of new element */
3026  int field2val, /**< additional value of new element */
3027  int* len, /**< pointer to length of arrays (will be increased by 1) */
3028  int* pos /**< pointer to store the insertion position, or NULL */
3029  );
3030 
3031 /** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
3032 extern
3034  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3035  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3036  int* intarray, /**< int array where an element is to be inserted */
3037  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3038  void* keyval, /**< key value of new element */
3039  void* field1val, /**< additional value of new element */
3040  int field2val, /**< additional value of new element */
3041  int* len, /**< pointer to length of arrays (will be increased by 1) */
3042  int* pos /**< pointer to store the insertion position, or NULL */
3043  );
3044 
3045 /** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
3046 extern
3048  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3049  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3050  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3051  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3052  void* keyval, /**< key value of new element */
3053  void* field1val, /**< additional value of new element */
3054  SCIP_Real field2val, /**< additional value of new element */
3055  int* len, /**< pointer to length of arrays (will be increased by 1) */
3056  int* pos /**< pointer to store the insertion position, or NULL */
3057  );
3058 
3059 /** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3060 extern
3062  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3063  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3064  int* intarray1, /**< first int array where an element is to be inserted */
3065  int* intarray2, /**< second int array where an element is to be inserted */
3066  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3067  void* keyval, /**< key value of new element */
3068  void* field1val, /**< additional value of new element */
3069  int field2val, /**< additional value of new element */
3070  int field3val, /**< additional value of new element */
3071  int* len, /**< pointer to length of arrays (will be increased by 1) */
3072  int* pos /**< pointer to store the insertion position, or NULL */
3073  );
3074 
3075 /** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
3076 extern
3078  void** ptrarray, /**< pointer array where an element is to be inserted */
3079  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3080  int* intarray1, /**< first int array where an element is to be inserted */
3081  int* intarray2, /**< second int array where an element is to be inserted */
3082  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3083  void* keyval, /**< key value of new element */
3084  SCIP_Real field1val, /**< additional value of new element */
3085  int field2val, /**< additional value of new element */
3086  int field3val, /**< additional value of new element */
3087  int* len, /**< pointer to length of arrays (will be increased by 1) */
3088  int* pos /**< pointer to store the insertion position, or NULL */
3089  );
3090 
3091 /** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
3092 extern
3094  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3095  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3096  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3097  int* intarray, /**< int array where an element is to be inserted */
3098  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3099  void* keyval, /**< key value of new element */
3100  void* field1val, /**< additional value of new element */
3101  SCIP_Real field2val, /**< additional value of new element */
3102  int field3val, /**< additional value of new element */
3103  int* len, /**< pointer to length of arrays (will be increased by 1) */
3104  int* pos /**< pointer to store the insertion position, or NULL */
3105  );
3106 
3107 /** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
3108 extern
3110  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3111  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3112  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3113  int* intarray, /**< int array where an element is to be inserted */
3114  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3115  void* keyval, /**< key value of new element */
3116  void* field1val, /**< additional value of new element */
3117  SCIP_Longint field2val, /**< additional value of new element */
3118  int field3val, /**< additional value of new element */
3119  int* len, /**< pointer to length of arrays (will be increased by 1) */
3120  int* pos /**< pointer to store the insertion position, or NULL */
3121  );
3122 
3123 /** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
3124 extern
3126  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3127  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3128  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3129  int* intarray1, /**< first int array where an element is to be inserted */
3130  int* intarray2, /**< second int array where an element is to be inserted */
3131  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3132  void* keyval, /**< key value of new element */
3133  void* field1val, /**< additional value of new element */
3134  SCIP_Longint field2val, /**< additional value of new element */
3135  int field3val, /**< additional value of new element */
3136  int field4val, /**< additional value of new element */
3137  int* len, /**< pointer to length of arrays (will be increased by 1) */
3138  int* pos /**< pointer to store the insertion position, or NULL */
3139  );
3140 
3141 /** insert a new element into an array of Reals, sorted in non-increasing order */
3142 extern
3144  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3145  SCIP_Real keyval, /**< key value of new element */
3146  int* len, /**< pointer to length of arrays (will be increased by 1) */
3147  int* pos /**< pointer to store the insertion position, or NULL */
3148  );
3149 
3150 /** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
3151 extern
3153  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3154  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
3155  void** ptrarray, /**< pointer array to be permuted in the same way */
3156  SCIP_Real keyval, /**< key value of new element */
3157  SCIP_Bool field1val, /**< additional value of new element */
3158  void* field2val, /**< additional value of new element */
3159  int* len, /**< pointer to length of arrays (will be increased by 1) */
3160  int* pos /**< pointer to store the insertion position, or NULL */
3161  );
3162 
3163 /** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3164 extern
3166  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3167  void** ptrarray, /**< pointer array where an element is to be inserted */
3168  SCIP_Real keyval, /**< key value of new element */
3169  void* field1val, /**< additional value of new element */
3170  int* len, /**< pointer to length of arrays (will be increased by 1) */
3171  int* pos /**< pointer to store the insertion position, or NULL */
3172  );
3173 
3174 /** insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3175 extern
3177  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3178  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3179  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3180  SCIP_Real keyval, /**< key value of new element */
3181  void* field1val, /**< additional value of new element */
3182  void* field2val, /**< additional value of new element */
3183  int* len, /**< pointer to length of arrays (will be increased by 1) */
3184  int* pos /**< pointer to store the insertion position, or NULL */
3185  );
3186 
3187 /** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-increasing order */
3188 extern
3190  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3191  int* intarray, /**< int array where an element is to be inserted */
3192  SCIP_Real keyval, /**< key value of new element */
3193  int field1val, /**< additional value of new element */
3194  int* len, /**< pointer to length of arrays (will be increased by 1) */
3195  int* pos /**< pointer to store the insertion position, or NULL */
3196  );
3197 
3198 /** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
3199 extern
3201  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3202  int* intarray, /**< int array to be permuted in the same way */
3203  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
3204  SCIP_Real keyval, /**< key value of new element */
3205  int field1val, /**< additional value of new element */
3206  SCIP_Longint field2val, /**< additional value of new element */
3207  int* len, /**< pointer to length of arrays (will be increased by 1) */
3208  int* pos /**< pointer to store the insertion position, or NULL */
3209  );
3210 
3211 /** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
3212 extern
3214  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3215  int* intarray, /**< int array where an element is to be inserted */
3216  void** ptrarray, /**< pointer array where an element is to be inserted */
3217  SCIP_Real keyval, /**< key value of new element */
3218  int field1val, /**< additional value of new element */
3219  void* field2val, /**< additional value of new element */
3220  int* len, /**< pointer to length of arrays (will be increased by 1) */
3221  int* pos /**< pointer to store the insertion position, or NULL */
3222  );
3223 
3224 /** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
3225 extern
3227  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
3228  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3229  void** ptrarray, /**< pointer array where an element is to be inserted */
3230  SCIP_Real keyval, /**< key value of new element */
3231  SCIP_Real field1val, /**< additional value of new element */
3232  void* field2val, /**< additional value of new element */
3233  int* len, /**< pointer to length of arrays (will be increased by 1) */
3234  int* pos /**< pointer to store the insertion position, or NULL */
3235  );
3236 
3237 /** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
3238 extern
3240  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3241  void** ptrarray1, /**< pointer array where an element is to be inserted */
3242  void** ptrarray2, /**< pointer array where an element is to be inserted */
3243  int* intarray, /**< int array where an element is to be inserted */
3244  SCIP_Real keyval, /**< key value of new element */
3245  void* field1val, /**< additional value of new element */
3246  void* field2val, /**< additional value of new element */
3247  int intval, /**< additional value of new element */
3248  int* len, /**< pointer to length of arrays (will be increased by 1) */
3249  int* pos /**< pointer to store the insertion position, or NULL */
3250  );
3251 
3252 /** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3253 extern
3255  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3256  void** ptrarray1, /**< pointer array where an element is to be inserted */
3257  void** ptrarray2, /**< pointer array where an element is to be inserted */
3258  int* intarray1, /**< int array where an element is to be inserted */
3259  int* intarray2, /**< int array where an element is to be inserted */
3260  SCIP_Real keyval, /**< key value of new element */
3261  void* field1val, /**< additional value of new element */
3262  void* field2val, /**< additional value of new element */
3263  int intval1, /**< additional value of new element */
3264  int intval2, /**< additional value of new element */
3265  int* len, /**< pointer to length of arrays (will be increased by 1) */
3266  int* pos /**< pointer to store the insertion position, or NULL */
3267  );
3268 
3269 /** insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
3270 extern
3272  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3273  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3274  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3275  int* intarray, /**< int array where an element is to be inserted */
3276  SCIP_Real keyval, /**< key value of new element */
3277  SCIP_Longint field1val, /**< additional value of new element */
3278  SCIP_Real field2val, /**< additional value of new element */
3279  int field3val, /**< additional value of new element */
3280  int* len, /**< pointer to length of arrays (will be increased by 1) */
3281  int* pos /**< pointer to store the insertion position, or NULL */
3282  );
3283 
3284 /** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
3285 extern
3287  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
3288  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3289  int* intarray1, /**< first int array where an element is to be inserted */
3290  int* intarray2, /**< second int array where an element is to be inserted */
3291  SCIP_Real keyval, /**< key value of new element */
3292  SCIP_Real field1val, /**< additional value of new element */
3293  int field2val, /**< additional value of new element */
3294  int field3val, /**< additional value of new element */
3295  int* len, /**< pointer to length of arrays (will be increased by 1) */
3296  int* pos /**< pointer to store the insertion position, or NULL */
3297  );
3298 
3299 /** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
3300 extern
3302  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3303  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3304  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3305  int* intarray, /**< int array where an element is to be inserted */
3306  SCIP_Real keyval, /**< key value of new element */
3307  SCIP_Real field1val, /**< additional value of new element */
3308  SCIP_Real field2val, /**< additional value of new element */
3309  int field3val, /**< additional value of new element */
3310  int* len, /**< pointer to length of arrays (will be increased by 1) */
3311  int* pos /**< pointer to store the insertion position, or NULL */
3312  );
3313 
3314 /** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
3315 extern
3317  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3318  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3319  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3320  void** ptrarray, /**< pointer array where an element is to be inserted */
3321  SCIP_Real keyval, /**< key value of new element */
3322  SCIP_Real field1val, /**< additional value of new element */
3323  SCIP_Real field2val, /**< additional value of new element */
3324  void* field3val, /**< additional value of new element */
3325  int* len, /**< pointer to length of arrays (will be increased by 1) */
3326  int* pos /**< pointer to store the insertion position, or NULL */
3327  );
3328 
3329 /** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
3330 extern
3332  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3333  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3334  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3335  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3336  void** ptrarray, /**< pointer array where an element is to be inserted */
3337  SCIP_Real keyval, /**< key value of new element */
3338  SCIP_Real field1val, /**< additional value of new element */
3339  SCIP_Real field2val, /**< additional value of new element */
3340  SCIP_Bool field3val, /**< additional value of new element */
3341  void* field4val, /**< additional value of new element */
3342  int* len, /**< pointer to length of arrays (will be increased by 1) */
3343  int* pos /**< pointer to store the insertion position, or NULL */
3344  );
3345 
3346 /** insert a new element into an array of ints in non-increasing order */
3347 extern
3349  int* intarray, /**< int array where an element is to be inserted */
3350  int keyval, /**< key value of new element */
3351  int* len, /**< pointer to length of arrays (will be increased by 1) */
3352  int* pos /**< pointer to store the insertion position, or NULL */
3353  );
3354 
3355 /** insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order */
3356 extern
3358  int* intarray1, /**< int array where an element is to be inserted */
3359  int* intarray2, /**< second int array where an element is to be inserted */
3360  int keyval, /**< key value of new element */
3361  int field1val, /**< additional value of new element */
3362  int* len, /**< pointer to length of arrays (will be increased by 1) */
3363  int* pos /**< pointer to store the insertion position, or NULL */
3364  );
3365 
3366 /** insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order */
3367 extern
3369  int* intarray, /**< int array where an element is to be inserted */
3370  SCIP_Real* realarray, /**< real array where an element is to be inserted */
3371  int keyval, /**< key value of new element */
3372  SCIP_Real field1val, /**< additional value of new element */
3373  int* len, /**< pointer to length of arrays (will be increased by 1) */
3374  int* pos /**< pointer to store the insertion position, or NULL */
3375  );
3376 
3377 /** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
3378 extern
3380  int* intarray1, /**< int array where an element is to be inserted */
3381  int* intarray2, /**< second int array where an element is to be inserted */
3382  int* intarray3, /**< third int array where an element is to be inserted */
3383  int keyval, /**< key value of new element */
3384  int field1val, /**< additional value of new element */
3385  int field2val, /**< additional value of new element */
3386  int* len, /**< pointer to length of arrays (will be increased by 1) */
3387  int* pos /**< pointer to store the insertion position, or NULL */
3388  );
3389 
3390 /** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
3391 extern
3393  int* intarray1, /**< int array where an element is to be inserted */
3394  int* intarray2, /**< second int array where an element is to be inserted */
3395  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3396  int keyval, /**< key value of new element */
3397  int field1val, /**< additional value of new element */
3398  SCIP_Longint field2val, /**< additional value of new element */
3399  int* len, /**< pointer to length of arrays (will be increased by 1) */
3400  int* pos /**< pointer to store the insertion position, or NULL */
3401  );
3402 
3403 /** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
3404 extern
3406  int* intarray1, /**< int array where an element is to be inserted */
3407  int* intarray2, /**< second int array where an element is to be inserted */
3408  void** ptrarray, /**< pointer array where an element is to be inserted */
3409  int keyval, /**< key value of new element */
3410  int field1val, /**< additional value of new element */
3411  void* field2val, /**< additional value of new element */
3412  int* len, /**< pointer to length of arrays (will be increased by 1) */
3413  int* pos /**< pointer to store the insertion position, or NULL */
3414  );
3415 
3416 /** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
3417 extern
3419  int* intarray1, /**< int array where an element is to be inserted */
3420  int* intarray2, /**< second int array where an element is to be inserted */
3421  SCIP_Real* realarray, /**< real array where an element is to be inserted */
3422  int keyval, /**< key value of new element */
3423  int field1val, /**< additional value of new element */
3424  SCIP_Real field2val, /**< additional value of new element */
3425  int* len, /**< pointer to length of arrays (will be increased by 1) */
3426  int* pos /**< pointer to store the insertion position, or NULL */
3427  );
3428 
3429 /** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order */
3430 extern
3432  int* intarray, /**< int array where an element is to be inserted */
3433  void** ptrarray, /**< pointer array where an element is to be inserted */
3434  int keyval, /**< key value of new element */
3435  void* field1val, /**< additional value of new element */
3436  int* len, /**< pointer to length of arrays (will be increased by 1) */
3437  int* pos /**< pointer to store the insertion position, or NULL */
3438  );
3439 
3440 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
3441 extern
3443  int* intarray1, /**< int array where an element is to be inserted */
3444  int* intarray2, /**< int array where an element is to be inserted */
3445  int* intarray3, /**< int array where an element is to be inserted */
3446  void** ptrarray, /**< pointer array where an element is to be inserted */
3447  int keyval, /**< key value of new element */
3448  int field1val, /**< additional value of new element */
3449  int field2val, /**< additional value of new element */
3450  void* field3val, /**< additional value of new element */
3451  int* len, /**< pointer to length of arrays (will be increased by 1) */
3452  int* pos /**< pointer to store the insertion position, or NULL */
3453  );
3454 
3455 
3456 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
3457 extern
3459  int* intarray1, /**< int array where an element is to be inserted */
3460  void** ptrarray, /**< pointer array where an element is to be inserted */
3461  int* intarray2, /**< int array where an element is to be inserted */
3462  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3463  int keyval, /**< key value of new element */
3464  void* field1val, /**< additional value of new element */
3465  int field2val, /**< additional value of new element */
3466  SCIP_Real field3val, /**< additional value of new element */
3467  int* len, /**< pointer to length of arrays (will be increased by 1) */
3468  int* pos /**< pointer to store the insertion position, or NULL */
3469  );
3470 
3471 /** insert a new element into an array of Longints, sorted in non-increasing order */
3472 extern
3474  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3475  SCIP_Longint keyval, /**< key value of new element */
3476  int* len, /**< pointer to length of arrays (will be increased by 1) */
3477  int* pos /**< pointer to store the insertion position, or NULL */
3478  );
3479 
3480 /** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
3481 extern
3483  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3484  void** ptrarray, /**< pointer array where an element is to be inserted */
3485  SCIP_Longint keyval, /**< key value of new element */
3486  void* field1val, /**< additional value of new element */
3487  int* len, /**< pointer to length of arrays (will be increased by 1) */
3488  int* pos /**< pointer to store the insertion position, or NULL */
3489  );
3490 
3491 /** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
3492 extern
3494  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3495  void** ptrarray, /**< pointer array where an element is to be inserted */
3496  int* intarray, /**< int array where an element is to be inserted */
3497  SCIP_Longint keyval, /**< key value of new element */
3498  void* field1val, /**< additional value of new element */
3499  int field2val, /**< additional value of new element */
3500  int* len, /**< pointer to length of arrays (will be increased by 1) */
3501  int* pos /**< pointer to store the insertion position, or NULL */
3502  );
3503 
3504 /** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
3505 extern
3507  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3508  void** ptrarray, /**< pointer array where an element is to be inserted */
3509  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3510  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3511  SCIP_Longint keyval, /**< key value of new element */
3512  void* field1val, /**< additional value of new element */
3513  SCIP_Real field2val, /**< additional value of new element */
3514  SCIP_Bool field3val, /**< additional value of new element */
3515  int* len, /**< pointer to length of arrays (will be increased by 1) */
3516  int* pos /**< pointer to store the insertion position, or NULL */
3517  );
3518 
3519 /** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
3520 extern
3522  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3523  void** ptrarray, /**< pointer array where an element is to be inserted */
3524  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3525  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3526  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3527  SCIP_Longint keyval, /**< key value of new element */
3528  void* field1val, /**< additional value of new element */
3529  SCIP_Real field2val, /**< additional value of new element */
3530  SCIP_Real field3val, /**< additional value of new element */
3531  SCIP_Bool field4val, /**< additional value of new element */
3532  int* len, /**< pointer to length of arrays (will be increased by 1) */
3533  int* pos /**< pointer to store the insertion position, or NULL */
3534  );
3535 
3536 /** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
3537 extern
3539  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3540  void** ptrarray, /**< pointer array where an element is to be inserted */
3541  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3542  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3543  int* intarray, /**< int array where an element is to be inserted */
3544  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3545  SCIP_Longint keyval, /**< key value of new element */
3546  void* field1val, /**< additional value of new element */
3547  SCIP_Real field2val, /**< additional value of new element */
3548  SCIP_Real field3val, /**< additional value of new element */
3549  int field4val, /**< additional value of new element */
3550  SCIP_Bool field5val, /**< additional value of new element */
3551  int* len, /**< pointer to length of arrays (will be increased by 1) */
3552  int* pos /**< pointer to store the insertion position, or NULL */
3553  );
3554 
3555 /** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
3556 extern
3558  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3559  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3560  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3561  int* intarray, /**< int array where an element is to be inserted */
3562  SCIP_Longint keyval, /**< key value of new element */
3563  void* field1val, /**< additional value of new element */
3564  void* field2val, /**< additional value of new element */
3565  int field3val, /**< additional value of new element */
3566  int* len, /**< pointer to length of arrays (will be increased by 1) */
3567  int* pos /**< pointer to store the insertion position, or NULL */
3568  );
3569 
3570 /** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
3571 extern
3573  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3574  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3575  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3576  int* intarray1, /**< first int array where an element is to be inserted */
3577  int* intarray2, /**< second int array where an element is to be inserted */
3578  SCIP_Longint keyval, /**< key value of new element */
3579  void* field1val, /**< additional value of new element */
3580  void* field2val, /**< additional value of new element */
3581  int field3val, /**< additional value of new element */
3582  int field4val, /**< additional value of new element */
3583  int* len, /**< pointer to length of arrays (will be increased by 1) */
3584  int* pos /**< pointer to store the insertion position, or NULL */
3585  );
3586 
3587 /** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
3588 extern
3590  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3591  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3592  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3593  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3594  int* intarray, /**< int array where an element is to be inserted */
3595  SCIP_Longint keyval, /**< key value of new element */
3596  void* field1val, /**< additional value of new element */
3597  void* field2val, /**< additional value of new element */
3598  SCIP_Bool field3val, /**< additional value of new element */
3599  int field4val, /**< additional value of new element */
3600  int* len, /**< pointer to length of arrays (will be increased by 1) */
3601  int* pos /**< pointer to store the insertion position, or NULL */
3602  );
3603 
3604 /** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
3605 extern
3607  void** ptrarray, /**< pointer array to be sorted */
3608  int* intarray1, /**< first int array to be permuted in the same way */
3609  int* intarray2, /**< second int array to be permuted in the same way */
3610  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3611  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3612  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3613  void* keyval, /**< key value of new element */
3614  int field1val, /**< additional value of new element */
3615  int field2val, /**< additional value of new element */
3616  SCIP_Bool field3val, /**< additional value of new element */
3617  SCIP_Bool field4val, /**< additional value of new element */
3618  int* len, /**< pointer to length of arrays (will be increased by 1) */
3619  int* pos /**< pointer to store the insertion position, or NULL */
3620  );
3621 
3622 /** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order */
3623 extern
3625  int* intarray1, /**< int array to be sorted */
3626  void** ptrarray, /**< pointer array to be permuted in the same way */
3627  int* intarray2, /**< second int array to be permuted in the same way */
3628  int* intarray3, /**< thrid int array to be permuted in the same way */
3629  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3630  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3631  int keyval, /**< key value of new element */
3632  void* field1val, /**< additional value of new element */
3633  int field2val, /**< additional value of new element */
3634  int field3val, /**< additional value of new element */
3635  SCIP_Bool field4val, /**< additional value of new element */
3636  SCIP_Bool field5val, /**< additional value of new element */
3637  int* len, /**< pointer to length of arrays (will be increased by 1) */
3638  int* pos /**< pointer to store the insertion position, or NULL */
3639  );
3640 
3641 /* upwards position deletion */
3642 
3643 /** delete the element at the given position from an index array in non-decreasing order */
3644 extern
3646  int* indarray, /**< pointer to the index array where an element is to be deleted */
3647  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
3648  void* dataptr, /**< pointer to data field that is given to the external compare method */
3649  int pos, /**< array position of element to be deleted */
3650  int* len /**< pointer to length of arrays (will be decreased by 1) */
3651  );
3652 
3653 /** delete the element at the given position from an array of pointers in non-decreasing order */
3654 extern
3656  void** ptrarray, /**< pointer array where an element is to be deleted */
3657  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3658  int pos, /**< array position of element to be deleted */
3659  int* len /**< pointer to length of arrays (will be decreased by 1) */
3660  );
3661 
3662 /** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
3663 extern
3665  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3666  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3667  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3668  int pos, /**< array position of element to be deleted */
3669  int* len /**< pointer to length of arrays (will be decreased by 1) */
3670  );
3671 
3672 /** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
3673 extern
3675  void** ptrarray, /**< pointer array where an element is to be deleted */
3676  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3677  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3678  int pos, /**< array position of element to be deleted */
3679  int* len /**< pointer to length of arrays (will be decreased by 1) */
3680  );
3681 
3682 /** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
3683 extern
3685  void** ptrarray, /**< pointer array where an element is to be deleted */
3686  int* intarray, /**< int array where an element is to be deleted */
3687  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3688  int pos, /**< array position of element to be deleted */
3689  int* len /**< pointer to length of arrays (will be decreased by 1) */
3690  );
3691 
3692 /** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
3693 extern
3695  void** ptrarray, /**< pointer array where an element is to be inserted */
3696  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3697  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3698  int pos, /**< array position of element to be deleted */
3699  int* len /**< pointer to length of arrays (will be increased by 1) */
3700  );
3701 
3702 /** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
3703 extern
3705  void** ptrarray, /**< pointer array where an element is to be deleted */
3706  int* intarray1, /**< first int array where an element is to be deleted */
3707  int* intarray2, /**< second int array where an element is to be deleted */
3708  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3709  int pos, /**< array position of element to be deleted */
3710  int* len /**< pointer to length of arrays (will be decreased by 1) */
3711  );
3712 
3713 /** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
3714 extern
3716  void** ptrarray, /**< pointer array where an element is to be deleted */
3717  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3718  int* intarray, /**< int array where an element is to be deleted */
3719  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3720  int pos, /**< array position of element to be deleted */
3721  int* len /**< pointer to length of arrays (will be decreased by 1) */
3722  );
3723 
3724 /** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
3725 extern
3727  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3728  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3729  int* intarray, /**< int array where an element is to be deleted */
3730  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3731  int pos, /**< array position of element to be deleted */
3732  int* len /**< pointer to length of arrays (will be decreased by 1) */
3733  );
3734 
3735 /** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
3736 extern
3738  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3739  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3740  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3741  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3742  int pos, /**< array position of element to be deleted */
3743  int* len /**< pointer to length of arrays (will be decreased by 1) */
3744  );
3745 
3746 /** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
3747 extern
3749  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3750  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3751  int* intarray1, /**< first int array where an element is to be deleted */
3752  int* intarray2, /**< second array where an element is to be deleted */
3753  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3754  int pos, /**< array position of element to be deleted */
3755  int* len /**< pointer to length of arrays (will be decreased by 1) */
3756  );
3757 
3758 /** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
3759 extern
3761  void** ptrarray, /**< pointer array where an element is to be deleted */
3762  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3763  int* intarray1, /**< first int array where an element is to be deleted */
3764  int* intarray2, /**< second int array where an element is to be deleted */
3765  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3766  int pos, /**< array position of element to be deleted */
3767  int* len /**< pointer to length of arrays (will be decreased by 1) */
3768  );
3769 
3770 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
3771 extern
3773  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3774  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3775  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3776  int* intarray, /**< int array where an element is to be deleted */
3777  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3778  int pos, /**< array position of element to be deleted */
3779  int* len /**< pointer to length of arrays (will be decreased by 1) */
3780  );
3781 
3782 /** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
3783 extern
3785  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3786  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3787  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3788  int* intarray, /**< int array where an element is to be deleted */
3789  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3790  int pos, /**< array position of element to be deleted */
3791  int* len /**< pointer to length of arrays (will be decreased by 1) */
3792  );
3793 
3794 /** 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 */
3795 extern
3797  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3798  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3799  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3800  int* intarray1, /**< first int array where an element is to be deleted */
3801  int* intarray2, /**< second int array where an element is to be deleted */
3802  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3803  int pos, /**< array position of element to be deleted */
3804  int* len /**< pointer to length of arrays (will be decreased by 1) */
3805  );
3806 
3807 /** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
3808 extern
3810  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3811  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
3812  void** ptrarray, /**< pointer array to be permuted in the same way */
3813  int pos, /**< array position of element to be deleted */
3814  int* len /**< pointer to length of arrays (will be decreased by 1) */
3815  );
3816 
3817 /** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
3818 extern
3820  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3821  void** ptrarray, /**< pointer array where an element is to be deleted */
3822  int pos, /**< array position of element to be deleted */
3823  int* len /**< pointer to length of arrays (will be decreased by 1) */
3824  );
3825 
3826 /** delete the element at the given position from an arrays of Reals, sorted in non-decreasing order */
3827 extern
3829  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3830  int pos, /**< array position of element to be deleted */
3831  int* len /**< pointer to length of arrays (will be decreased by 1) */
3832  );
3833 
3834 /** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
3835 extern
3837  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3838  int* intarray, /**< int array where an element is to be deleted */
3839  int pos, /**< array position of element to be deleted */
3840  int* len /**< pointer to length of arrays (will be decreased by 1) */
3841  );
3842 
3843 /** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
3844 extern
3846  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3847  int* intarray, /**< int array where an element is to be deleted */
3848  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3849  int pos, /**< array position of element to be deleted */
3850  int* len /**< pointer to length of arrays (will be decreased by 1) */
3851  );
3852 
3853 /** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
3854 extern
3856  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
3857  int* intarray, /**< int array where an element is to be deleted */
3858  void** ptrarray, /**< pointer array where an element is to be deleted */
3859  int pos, /**< array position of element to be deleted */
3860  int* len /**< pointer to length of arrays (will be decreased by 1) */
3861  );
3862 
3863 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
3864 extern
3866  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be deleted */
3867  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
3868  void** ptrarray, /**< pointer array where an element is to be deleted */
3869  int pos, /**< array position of element to be deleted */
3870  int* len /**< pointer to length of arrays (will be decreased by 1) */
3871  );
3872 
3873 /** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
3874 extern
3876  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
3877  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3878  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3879  int* intarray, /**< int array where an element is to be deleted */
3880  int pos, /**< array position of element to be deleted */
3881  int* len /**< pointer to length of arrays (will be decreased by 1) */
3882  );
3883 
3884 /** 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 */
3885 extern
3887  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
3888  void** ptrarray1, /**< first pointer array where an element is to be deleted */
3889  void** ptrarray2, /**< second pointer array where an element is to be deleted */
3890  int* intarray1, /**< int array where an element is to be deleted */
3891  int* intarray2, /**< int array where an element is to be deleted */
3892  int pos, /**< array position of element to be deleted */
3893  int* len /**< pointer to length of arrays (will be decreased by 1) */
3894  );
3895 
3896 /** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
3897 extern
3899  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
3900  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3901  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
3902  int* intarray, /**< int array where an element is to be deleted */
3903  int pos, /**< array position of element to be deleted */
3904  int* len /**< pointer to length of arrays (will be decreased by 1) */
3905  );
3906 
3907 /** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
3908 extern
3910  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
3911  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
3912  int* intarray1, /**< int array where an element is to be deleted */
3913  int* intarray2, /**< int array where an element is to be deleted */
3914  int pos, /**< array position of element to be deleted */
3915  int* len /**< pointer to length of arrays (will be decreased by 1) */
3916  );
3917 
3918 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
3919 extern
3921  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
3922  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
3923  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
3924  int* intarray, /**< int array where an element is to be deleted */
3925  int pos, /**< array position of element to be deleted */
3926  int* len /**< pointer to length of arrays (will be decreased by 1) */
3927  );
3928 
3929 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
3930 extern
3932  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
3933  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
3934  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
3935  void** ptrarray, /**< pointer array where an element is to be deleted */
3936  int pos, /**< array position of element to be deleted */
3937  int* len /**< pointer to length of arrays (will be decreased by 1) */
3938  );
3939 
3940 /** 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 */
3941 extern
3943  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
3944  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
3945  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
3946  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
3947  void** ptrarray, /**< pointer array where an element is to be deleted */
3948  int pos, /**< array position of element to be deleted */
3949  int* len /**< pointer to length of arrays (will be decreased by 1) */
3950  );
3951 
3952 /** delete the element at the given position from an array of ints in non-decreasing order */
3953 extern
3955  int* intarray, /**< int array where an element is to be deleted */
3956  int pos, /**< array position of element to be deleted */
3957  int* len /**< pointer to length of arrays (will be decreased by 1) */
3958  );
3959 
3960 /** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order */
3961 extern
3963  int* intarray1, /**< int array where an element is to be deleted */
3964  int* intarray2, /**< second int array where an element is to be deleted */
3965  int pos, /**< array position of element to be deleted */
3966  int* len /**< pointer to length of arrays (will be decreased by 1) */
3967  );
3968 
3969 /** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order */
3970 extern
3972  int* intarray, /**< int array where an element is to be deleted */
3973  SCIP_Real* realarray, /**< real array where an element is to be deleted */
3974  int pos, /**< array position of element to be deleted */
3975  int* len /**< pointer to length of arrays (will be decreased by 1) */
3976  );
3977 
3978 /** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
3979 extern
3981  int* intarray1, /**< int array where an element is to be deleted */
3982  int* intarray2, /**< second int array where an element is to be deleted */
3983  int* intarray3, /**< third int array where an element is to be deleted */
3984  int pos, /**< array position of element to be deleted */
3985  int* len /**< pointer to length of arrays (will be decreased by 1) */
3986  );
3987 
3988 /** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
3989 extern
3991  int* intarray1, /**< int array where an element is to be deleted */
3992  int* intarray2, /**< second int array where an element is to be deleted */
3993  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
3994  int pos, /**< array position of element to be deleted */
3995  int* len /**< pointer to length of arrays (will be decreased by 1) */
3996  );
3997 
3998 /** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
3999 extern
4001  int* intarray1, /**< int array where an element is to be deleted */
4002  int* intarray2, /**< second int array where an element is to be deleted */
4003  void** ptrarray, /**< pointer array where an element is to be deleted */
4004  int pos, /**< array position of element to be deleted */
4005  int* len /**< pointer to length of arrays (will be decreased by 1) */
4006  );
4007 
4008 /** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
4009 extern
4011  int* intarray1, /**< int array where an element is to be deleted */
4012  int* intarray2, /**< second int array where an element is to be deleted */
4013  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4014  int pos, /**< array position of element to be deleted */
4015  int* len /**< pointer to length of arrays (will be decreased by 1) */
4016  );
4017 
4018 /** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
4019 extern
4021  int* intarray, /**< int array where an element is to be deleted */
4022  void** ptrarray, /**< pointer array where an element is to be deleted */
4023  int pos, /**< array position of element to be deleted */
4024  int* len /**< pointer to length of arrays (will be decreased by 1) */
4025  );
4026 
4027 /** delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
4028 extern
4030  int* intarray, /**< int array where an element is to be deleted */
4031  void** ptrarray, /**< pointer array where an element is to be deleted */
4032  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4033  int pos, /**< array position of element to be deleted */
4034  int* len /**< pointer to length of arrays (will be decreased by 1) */
4035  );
4036 
4037 /** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
4038 extern
4040  int* intarray1, /**< int array where an element is to be deleted */
4041  int* intarray2, /**< int array where an element is to be deleted */
4042  int* intarray3, /**< int array where an element is to be deleted */
4043  void** ptrarray, /**< pointer array where an element is to be deleted */
4044  int pos, /**< array position of element to be deleted */
4045  int* len /**< pointer to length of arrays (will be decreased by 1) */
4046  );
4047 
4048 
4049 /** delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
4050 extern
4052  int* intarray1, /**< int array where an element is to be deleted */
4053  void** ptrarray, /**< pointer array where an element is to be deleted */
4054  int* intarray2, /**< int array where an element is to be deleted */
4055  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4056  int pos, /**< array position of element to be deleted */
4057  int* len /**< pointer to length of arrays (will be decreased by 1) */
4058  );
4059 
4060 /** delete the element at the given position from an array of Longints, sorted by in non-decreasing order */
4061 extern
4063  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4064  int pos, /**< array position of element to be deleted */
4065  int* len /**< pointer to length of arrays (will be decreased by 1) */
4066  );
4067 
4068 /** delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
4069 extern
4071  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4072  void** ptrarray, /**< pointer array where an element is to be deleted */
4073  int pos, /**< array position of element to be deleted */
4074  int* len /**< pointer to length of arrays (will be decreased by 1) */
4075  );
4076 
4077 /** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order */
4078 extern
4080  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4081  void** ptrarray, /**< pointer array where an element is to be deleted */
4082  int* intarray, /**< int array where an element is to be deleted */
4083  int pos, /**< array position of element to be deleted */
4084  int* len /**< pointer to length of arrays (will be decreased by 1) */
4085  );
4086 
4087 /** delete the element at the given position from four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
4088 extern
4090  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4091  void** ptrarray, /**< pointer array where an element is to be deleted */
4092  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4093  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4094  int pos, /**< array position of element to be deleted */
4095  int* len /**< pointer to length of arrays (will be decreased by 1) */
4096  );
4097 
4098 /** 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 */
4099 extern
4101  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4102  void** ptrarray, /**< pointer array where an element is to be deleted */
4103  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4104  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4105  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4106  int pos, /**< array position of element to be deleted */
4107  int* len /**< pointer to length of arrays (will be decreased by 1) */
4108  );
4109 
4110 /** 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 */
4111 extern
4113  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4114  void** ptrarray, /**< pointer array where an element is to be deleted */
4115  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4116  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4117  int* intarray, /**< int array where an element is to be deleted */
4118  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4119  int pos, /**< array position of element to be deleted */
4120  int* len /**< pointer to length of arrays (will be decreased by 1) */
4121  );
4122 
4123 /** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
4124 extern
4126  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4127  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4128  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4129  int* intarray, /**< int array where an element is to be deleted */
4130  int pos, /**< array position of element to be deleted */
4131  int* len /**< pointer to length of arrays (will be decreased by 1) */
4132  );
4133 
4134 /** 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 */
4135 extern
4137  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4138  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4139  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4140  int* intarray1, /**< first int array where an element is to be deleted */
4141  int* intarray2, /**< second int array where an element is to be deleted */
4142  int pos, /**< array position of element to be deleted */
4143  int* len /**< pointer to length of arrays (will be decreased by 1) */
4144  );
4145 
4146 /** 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 */
4147 extern
4149  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4150  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4151  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4152  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4153  int* intarray, /**< int array where an element is to be deleted */
4154  int pos, /**< array position of element to be deleted */
4155  int* len /**< pointer to length of arrays (will be decreased by 1) */
4156  );
4157 
4158 /** 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 */
4159 extern
4161  void** ptrarray, /**< pointer array to be sorted */
4162  int* intarray1, /**< first int array to be permuted in the same way */
4163  int* intarray2, /**< second int array to be permuted in the same way */
4164  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4165  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4166  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4167  int pos, /**< array position of element to be deleted */
4168  int* len /**< pointer to length of arrays (will be decreased by 1) */
4169  );
4170 
4171 /** 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 */
4172 extern
4174  int* intarray1, /**< int array to be sorted */
4175  void** ptrarray, /**< pointer array to be permuted in the same way */
4176  int* intarray2, /**< second int array to be permuted in the same way */
4177  int* intarray3, /**< thrid int array to be permuted in the same way */
4178  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4179  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4180  int pos, /**< array position of element to be deleted */
4181  int* len /**< pointer to length of arrays (will be decreased by 1) */
4182  );
4183 
4184 /* downwards position deletion */
4185 
4186 /** delete the element at the given position from an index array in non-increasing order */
4187 extern
4189  int* indarray, /**< pointer to the index array where an element is to be deleted */
4190  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4191  void* dataptr, /**< pointer to data field that is given to the external compare method */
4192  int pos, /**< array position of element to be deleted */
4193  int* len /**< pointer to length of arrays (will be decreased by 1) */
4194  );
4195 
4196 /** delete the element at the given position from an array of pointers in non-increasing order */
4197 extern
4199  void** ptrarray, /**< pointer array where an element is to be deleted */
4200  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4201  int pos, /**< array position of element to be deleted */
4202  int* len /**< pointer to length of arrays (will be decreased by 1) */
4203  );
4204 
4205 /** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
4206 extern
4208  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4209  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4210  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4211  int pos, /**< array position of element to be deleted */
4212  int* len /**< pointer to length of arrays (will be decreased by 1) */
4213  );
4214 
4215 /** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
4216 extern
4218  void** ptrarray, /**< pointer array where an element is to be deleted */
4219  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4220  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4221  int pos, /**< array position of element to be deleted */
4222  int* len /**< pointer to length of arrays (will be decreased by 1) */
4223  );
4224 
4225 /** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-increasing order */
4226 extern
4228  void** ptrarray, /**< pointer array where an element is to be deleted */
4229  int* intarray, /**< int array where an element is to be deleted */
4230  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4231  int pos, /**< array position of element to be deleted */
4232  int* len /**< pointer to length of arrays (will be decreased by 1) */
4233  );
4234 
4235 /** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
4236 extern
4238  void** ptrarray, /**< pointer array where an element is to be inserted */
4239  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
4240  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4241  int pos, /**< array position of element to be deleted */
4242  int* len /**< pointer to length of arrays (will be increased by 1) */
4243  );
4244 
4245 /** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
4246 extern
4248  void** ptrarray, /**< pointer array where an element is to be deleted */
4249  int* intarray1, /**< first int array where an element is to be deleted */
4250  int* intarray2, /**< second int array where an element is to be deleted */
4251  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4252  int pos, /**< array position of element to be deleted */
4253  int* len /**< pointer to length of arrays (will be decreased by 1) */
4254  );
4255 
4256 /** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
4257 extern
4259  void** ptrarray, /**< pointer array where an element is to be deleted */
4260  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4261  int* intarray, /**< int array where an element is to be deleted */
4262  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4263  int pos, /**< array position of element to be deleted */
4264  int* len /**< pointer to length of arrays (will be decreased by 1) */
4265  );
4266 
4267 /** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
4268 extern
4270  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4271  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4272  int* intarray, /**< int array where an element is to be deleted */
4273  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4274  int pos, /**< array position of element to be deleted */
4275  int* len /**< pointer to length of arrays (will be decreased by 1) */
4276  );
4277 
4278 /** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
4279 extern
4281  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4282  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4283  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4284  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4285  int pos, /**< array position of element to be deleted */
4286  int* len /**< pointer to length of arrays (will be decreased by 1) */
4287  );
4288 
4289 /** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
4290 extern
4292  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4293  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4294  int* intarray1, /**< first int array where an element is to be deleted */
4295  int* intarray2, /**< second int array where an element is to be deleted */
4296  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4297  int pos, /**< array position of element to be deleted */
4298  int* len /**< pointer to length of arrays (will be decreased by 1) */
4299  );
4300 
4301 /** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
4302 extern
4304  void** ptrarray, /**< pointer array where an element is to be deleted */
4305  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4306  int* intarray1, /**< first int array where an element is to be deleted */
4307  int* intarray2, /**< second int array where an element is to be deleted */
4308  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4309  int pos, /**< array position of element to be deleted */
4310  int* len /**< pointer to length of arrays (will be decreased by 1) */
4311  );
4312 
4313 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
4314 extern
4316  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4317  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4318  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4319  int* intarray, /**< int array where an element is to be deleted */
4320  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4321  int pos, /**< array position of element to be deleted */
4322  int* len /**< pointer to length of arrays (will be decreased by 1) */
4323  );
4324 
4325 /** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
4326 extern
4328  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4329  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4330  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4331  int* intarray, /**< int array where an element is to be deleted */
4332  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4333  int pos, /**< array position of element to be deleted */
4334  int* len /**< pointer to length of arrays (will be decreased by 1) */
4335  );
4336 
4337 /** 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 */
4338 extern
4340  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4341  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4342  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4343  int* intarray1, /**< first int array where an element is to be deleted */
4344  int* intarray2, /**< second int array where an element is to be deleted */
4345  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4346  int pos, /**< array position of element to be deleted */
4347  int* len /**< pointer to length of arrays (will be decreased by 1) */
4348  );
4349 
4350 /** delete the element at the given position from an array of Reals, sorted in non-increasing order */
4351 extern
4353  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4354  int pos, /**< array position of element to be deleted */
4355  int* len /**< pointer to length of arrays (will be decreased by 1) */
4356  );
4357 
4358 
4359 /** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
4360 extern
4362  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
4363  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
4364  void** ptrarray, /**< pointer array to be permuted in the same way */
4365  int pos, /**< array position of element to be deleted */
4366  int* len /**< pointer to length of arrays (will be decreased by 1) */
4367  );
4368 
4369 /** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
4370 extern
4372  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4373  void** ptrarray, /**< pointer array where an element is to be deleted */
4374  int pos, /**< array position of element to be deleted */
4375  int* len /**< pointer to length of arrays (will be decreased by 1) */
4376  );
4377 
4378 /** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order */
4379 extern
4381  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4382  int* intarray, /**< pointer array where an element is to be deleted */
4383  int pos, /**< array position of element to be deleted */
4384  int* len /**< pointer to length of arrays (will be decreased by 1) */
4385  );
4386 
4387 /** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
4388 extern
4390  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4391  int* intarray, /**< int array where an element is to be deleted */
4392  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4393  int pos, /**< array position of element to be deleted */
4394  int* len /**< pointer to length of arrays (will be decreased by 1) */
4395  );
4396 
4397 /** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
4398 extern
4400  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4401  int* intarray, /**< int array where an element is to be deleted */
4402  void** ptrarray, /**< pointer array where an element is to be deleted */
4403  int pos, /**< array position of element to be deleted */
4404  int* len /**< pointer to length of arrays (will be decreased by 1) */
4405  );
4406 
4407 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
4408 extern
4410  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be deleted */
4411  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4412  void** ptrarray, /**< pointer array where an element is to be deleted */
4413  int pos, /**< array position of element to be deleted */
4414  int* len /**< pointer to length of arrays (will be decreased by 1) */
4415  );
4416 
4417 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
4418 extern
4420  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4421  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4422  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4423  int pos, /**< array position of element to be deleted */
4424  int* len /**< pointer to length of arrays (will be decreased by 1) */
4425  );
4426 
4427 /** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
4428 extern
4430  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4431  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4432  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4433  int* intarray, /**< int array where an element is to be deleted */
4434  int pos, /**< array position of element to be deleted */
4435  int* len /**< pointer to length of arrays (will be decreased by 1) */
4436  );
4437 
4438 /** 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 */
4439 extern
4441  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4442  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4443  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4444  int* intarray1, /**< int array where an element is to be deleted */
4445  int* intarray2, /**< int array where an element is to be deleted */
4446  int pos, /**< array position of element to be deleted */
4447  int* len /**< pointer to length of arrays (will be decreased by 1) */
4448  );
4449 
4450 /** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-increasing order */
4451 extern
4453  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4454  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4455  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4456  int* intarray, /**< int array where an element is to be deleted */
4457  int pos, /**< array position of element to be deleted */
4458  int* len /**< pointer to length of arrays (will be decreased by 1) */
4459  );
4460 
4461 /** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
4462 extern
4464  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4465  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4466  int* intarray1, /**< int array where an element is to be deleted */
4467  int* intarray2, /**< int array where an element is to be deleted */
4468  int pos, /**< array position of element to be deleted */
4469  int* len /**< pointer to length of arrays (will be decreased by 1) */
4470  );
4471 
4472 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
4473 extern
4475  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4476  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4477  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4478  int* intarray, /**< int array where an element is to be deleted */
4479  int pos, /**< array position of element to be deleted */
4480  int* len /**< pointer to length of arrays (will be decreased by 1) */
4481  );
4482 
4483 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
4484 extern
4486  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4487  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4488  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4489  void** ptrarray, /**< pointer array where an element is to be deleted */
4490  int pos, /**< array position of element to be deleted */
4491  int* len /**< pointer to length of arrays (will be decreased by 1) */
4492  );
4493 
4494 /** 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 */
4495 extern
4497  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4498  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4499  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4500  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4501  void** ptrarray, /**< pointer array where an element is to be deleted */
4502  int pos, /**< array position of element to be deleted */
4503  int* len /**< pointer to length of arrays (will be decreased by 1) */
4504  );
4505 
4506 /** delete the element at the given position from an array of ints in non-increasing order */
4507 extern
4509  int* intarray, /**< int array where an element is to be deleted */
4510  int pos, /**< array position of element to be deleted */
4511  int* len /**< pointer to length of arrays (will be decreased by 1) */
4512  );
4513 
4514 /** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-increasing order */
4515 extern
4517  int* intarray1, /**< int array where an element is to be deleted */
4518  int* intarray2, /**< second int array where an element is to be deleted */
4519  int pos, /**< array position of element to be deleted */
4520  int* len /**< pointer to length of arrays (will be decreased by 1) */
4521  );
4522 
4523 /** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-increasing order */
4524 extern
4526  int* intarray, /**< int array where an element is to be deleted */
4527  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4528  int pos, /**< array position of element to be deleted */
4529  int* len /**< pointer to length of arrays (will be decreased by 1) */
4530  );
4531 
4532 /** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
4533 extern
4535  int* intarray1, /**< int array where an element is to be deleted */
4536  int* intarray2, /**< second int array where an element is to be deleted */
4537  int* intarray3, /**< third int array where an element is to be deleted */
4538  int pos, /**< array position of element to be deleted */
4539  int* len /**< pointer to length of arrays (will be decreased by 1) */
4540  );
4541 
4542 /** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
4543 extern
4545  int* intarray1, /**< int array where an element is to be deleted */
4546  int* intarray2, /**< second int array where an element is to be deleted */
4547  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4548  int pos, /**< array position of element to be deleted */
4549  int* len /**< pointer to length of arrays (will be decreased by 1) */
4550  );
4551 
4552 /** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
4553 extern
4555  int* intarray1, /**< int array where an element is to be deleted */
4556  int* intarray2, /**< second int array where an element is to be deleted */
4557  void** ptrarray, /**< pointer array where an element is to be deleted */
4558  int pos, /**< array position of element to be deleted */
4559  int* len /**< pointer to length of arrays (will be decreased by 1) */
4560  );
4561 
4562 /** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
4563 extern
4565  int* intarray1, /**< int array where an element is to be deleted */
4566  int* intarray2, /**< second int array where an element is to be deleted */
4567  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4568  int pos, /**< array position of element to be deleted */
4569  int* len /**< pointer to length of arrays (will be decreased by 1) */
4570  );
4571 
4572 /** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-increasing order */
4573 extern
4575  int* intarray, /**< int array where an element is to be deleted */
4576  void** ptrarray, /**< pointer array where an element is to be deleted */
4577  int pos, /**< array position of element to be deleted */
4578  int* len /**< pointer to length of arrays (will be decreased by 1) */
4579  );
4580 
4581 
4582 /** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
4583 extern
4585  int* intarray1, /**< int array where an element is to be deleted */
4586  int* intarray2, /**< int array where an element is to be deleted */
4587  int* intarray3, /**< int array where an element is to be deleted */
4588  void** ptrarray, /**< pointer array where an element is to be deleted */
4589  int pos, /**< array position of element to be deleted */
4590  int* len /**< pointer to length of arrays (will be decreased by 1) */
4591  );
4592 
4593 /** delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
4594 extern
4596  int* intarray1, /**< int array where an element is to be deleted */
4597  void** ptrarray, /**< pointer array where an element is to be deleted */
4598  int* intarray2, /**< int array where an element is to be deleted */
4599  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4600  int pos, /**< array position of element to be deleted */
4601  int* len /**< pointer to length of arrays (will be decreased by 1) */
4602  );
4603 
4604 /** delete the element at the given position from an array of Longints, sorted in non-increasing order */
4605 extern
4607  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4608  int pos, /**< array position of element to be deleted */
4609  int* len /**< pointer to length of arrays (will be decreased by 1) */
4610  );
4611 
4612 /** delete the element at the given position from three two arrays of Long/pointer, sorted by the first array in non-increasing order */
4613 extern
4615  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4616  void** ptrarray, /**< pointer array where an element is to be deleted */
4617  int pos, /**< array position of element to be deleted */
4618  int* len /**< pointer to length of arrays (will be decreased by 1) */
4619  );
4620 
4621 /** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-increasing order */
4622 extern
4624  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4625  void** ptrarray, /**< pointer array where an element is to be deleted */
4626  int* intarray, /**< int array where an element is to be deleted */
4627  int pos, /**< array position of element to be deleted */
4628  int* len /**< pointer to length of arrays (will be decreased by 1) */
4629  );
4630 
4631 /** 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 */
4632 extern
4634  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4635  void** ptrarray, /**< pointer array where an element is to be deleted */
4636  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4637  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4638  int pos, /**< array position of element to be deleted */
4639  int* len /**< pointer to length of arrays (will be decreased by 1) */
4640  );
4641 
4642 /** 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 */
4643 extern
4645  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4646  void** ptrarray, /**< pointer array where an element is to be deleted */
4647  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4648  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4649  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4650  int pos, /**< array position of element to be deleted */
4651  int* len /**< pointer to length of arrays (will be decreased by 1) */
4652  );
4653 
4654 /** 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 */
4655 extern
4657  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4658  void** ptrarray, /**< pointer array where an element is to be deleted */
4659  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4660  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4661  int* intarray, /**< int array where an element is to be deleted */
4662  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4663  int pos, /**< array position of element to be deleted */
4664  int* len /**< pointer to length of arrays (will be decreased by 1) */
4665  );
4666 
4667 
4668 /** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
4669 extern
4671  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4672  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4673  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4674  int* intarray, /**< int array where an element is to be deleted */
4675  int pos, /**< array position of element to be deleted */
4676  int* len /**< pointer to length of arrays (will be decreased by 1) */
4677  );
4678 
4679 /** 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 */
4680 extern
4682  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4683  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4684  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4685  int* intarray1, /**< first int array where an element is to be deleted */
4686  int* intarray2, /**< second int array where an element is to be deleted */
4687  int pos, /**< array position of element to be deleted */
4688  int* len /**< pointer to length of arrays (will be decreased by 1) */
4689  );
4690 
4691 /** 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 */
4692 extern
4694  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4695  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4696  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4697  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4698  int* intarray, /**< int array where an element is to be deleted */
4699  int pos, /**< array position of element to be deleted */
4700  int* len /**< pointer to length of arrays (will be decreased by 1) */
4701  );
4702 
4703 /** 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 */
4704 extern
4706  void** ptrarray, /**< pointer array to be sorted */
4707  int* intarray1, /**< first int array to be permuted in the same way */
4708  int* intarray2, /**< second int array to be permuted in the same way */
4709  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4710  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4711  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4712  int pos, /**< array position of element to be deleted */
4713  int* len /**< pointer to length of arrays (will be decreased by 1) */
4714  );
4715 
4716 /** 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 */
4717 extern
4719  int* intarray1, /**< int array to be sorted */
4720  void** ptrarray, /**< pointer array to be permuted in the same way */
4721  int* intarray2, /**< second int array to be permuted in the same way */
4722  int* intarray3, /**< thrid int array to be permuted in the same way */
4723  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4724  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4725  int pos, /**< array position of element to be deleted */
4726  int* len /**< pointer to length of arrays (will be decreased by 1) */
4727  );
4728 
4729 
4730 /* upwards binary search */
4731 
4732 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4733  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4734  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4735  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4736  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4737  */
4738 extern
4740  int* indarray, /**< index array to be searched */
4741  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4742  void* dataptr, /**< pointer to data field that is given to the external compare method */
4743  int val, /**< value to search */
4744  int len, /**< length of array */
4745  int* pos /**< pointer to store position of element */
4746  );
4747 
4748 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4749  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4750  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4751  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4752  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4753  */
4754 extern
4756  void** ptrarray, /**< pointer array to be searched */
4757  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4758  void* val, /**< value to search */
4759  int len, /**< length of array */
4760  int* pos /**< pointer to store position of element */
4761  );
4762 
4763 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4764  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4765  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4766  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4767  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4768  */
4769 extern
4771  SCIP_Real* realarray, /**< SCIP_Real array to be searched */
4772  SCIP_Real val, /**< value to search */
4773  int len, /**< length of array */
4774  int* pos /**< pointer to store position of element */
4775  );
4776 
4777 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4778  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4779  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4780  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4781  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4782  */
4783 extern
4785  int* intarray, /**< int array to be searched */
4786  int val, /**< value to search */
4787  int len, /**< length of array */
4788  int* pos /**< pointer to store position of element */
4789  );
4790 
4791 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4792  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4793  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4794  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4795  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4796  */
4797 extern
4799  SCIP_Longint* longarray, /**< SCIP_Longint array to be searched */
4800  SCIP_Longint val, /**< value to search */
4801  int len, /**< length of array */
4802  int* pos /**< pointer to store position of element */
4803  );
4804 
4805 
4806 /* downwards binary search */
4807 
4808 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4809  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4810  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4811  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4812  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4813  */
4814 extern
4816  int* indarray, /**< index array to be searched */
4817  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4818  void* dataptr, /**< pointer to data field that is given to the external compare method */
4819  int val, /**< value to search */
4820  int len, /**< length of array */
4821  int* pos /**< pointer to store position of element */
4822  );
4823 
4824 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4825  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4826  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4827  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4828  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4829  */
4830 extern
4832  void** ptrarray, /**< pointer array to be searched */
4833  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4834  void* val, /**< value to search */
4835  int len, /**< length of array */
4836  int* pos /**< pointer to store position of element */
4837  );
4838 
4839 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4840  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4841  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4842  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4843  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4844  */
4845 extern
4847  SCIP_Real* realarray, /**< SCIP_Real array to be searched */
4848  SCIP_Real val, /**< value to search */
4849  int len, /**< length of array */
4850  int* pos /**< pointer to store position of element */
4851  );
4852 
4853 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4854  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4855  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4856  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4857  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4858  */
4859 extern
4861  int* intarray, /**< int array to be searched */
4862  int val, /**< value to search */
4863  int len, /**< length of array */
4864  int* pos /**< pointer to store position of element */
4865  );
4866 
4867 /** Finds the position at which 'val' is located in the sorted vector by binary search.
4868  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
4869  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
4870  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
4871  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
4872  */
4873 extern
4875  SCIP_Longint* longarray, /**< SCIP_Longint array to be searched */
4876  SCIP_Longint val, /**< value to search */
4877  int len, /**< length of array */
4878  int* pos /**< pointer to store position of element */
4879  );
4880 
4881 /**@} */
4882 
4883 /**@defgroup MiscellaneousMethods Miscellaneous Methods
4884  *
4885  * Below you find a list of miscellaneous methods grouped by different categories
4886  *@{
4887  */
4888 
4889 /*
4890  * Numerical methods
4891  */
4892 
4893 /**@defgroup NumericalMethods Numerical Methods
4894  *
4895  *@{
4896  */
4897 
4898 /** returns the machine epsilon: the smallest number eps > 0, for which 1.0 + eps > 1.0 */
4899 extern
4901  void
4902  );
4903 
4904 /** calculates the greatest common divisor of the two given values */
4905 extern
4907  SCIP_Longint val1, /**< first value of greatest common devisor calculation */
4908  SCIP_Longint val2 /**< second value of greatest common devisor calculation */
4909  );
4910 
4911 /** calculates the smallest common multiple of the two given values */
4912 extern
4914  SCIP_Longint val1, /**< first value of smallest common multiple calculation */
4915  SCIP_Longint val2 /**< second value of smallest common multiple calculation */
4916  );
4917 
4918 /** converts a real number into a (approximate) rational representation, and returns TRUE iff the conversion was
4919  * successful
4920  */
4921 extern
4923  SCIP_Real val, /**< real value r to convert into rational number */
4924  SCIP_Real mindelta, /**< minimal allowed difference r - q of real r and rational q = n/d */
4925  SCIP_Real maxdelta, /**< maximal allowed difference r - q of real r and rational q = n/d */
4926  SCIP_Longint maxdnom, /**< maximal denominator allowed */
4927  SCIP_Longint* nominator, /**< pointer to store the nominator n of the rational number */
4928  SCIP_Longint* denominator /**< pointer to store the denominator d of the rational number */
4929  );
4930 
4931 /** tries to find a value, such that all given values, if scaled with this value become integral in relative allowed
4932  * difference in between mindelta and maxdelta
4933  */
4934 extern
4936  SCIP_Real* vals, /**< values to scale */
4937  int nvals, /**< number of values to scale */
4938  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
4939  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
4940  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
4941  SCIP_Real maxscale, /**< maximal allowed scalar */
4942  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
4943  SCIP_Bool* success /**< stores whether returned value is valid */
4944  );
4945 
4946 /** given a (usually very small) interval, tries to find a rational number with simple denominator (i.e. a small
4947  * number, probably multiplied with powers of 10) out of this interval; returns TRUE iff a valid rational
4948  * number inside the interval was found
4949  */
4950 extern
4952  SCIP_Real lb, /**< lower bound of the interval */
4953  SCIP_Real ub, /**< upper bound of the interval */
4954  SCIP_Longint maxdnom, /**< maximal denominator allowed for resulting rational number */
4955  SCIP_Longint* nominator, /**< pointer to store the nominator n of the rational number */
4956  SCIP_Longint* denominator /**< pointer to store the denominator d of the rational number */
4957  );
4958 
4959 /** given a (usually very small) interval, selects a value inside this interval; it is tried to select a rational number
4960  * with simple denominator (i.e. a small number, probably multiplied with powers of 10);
4961  * if no valid rational number inside the interval was found, selects the central value of the interval
4962  */
4963 extern
4965  SCIP_Real lb, /**< lower bound of the interval */
4966  SCIP_Real ub, /**< upper bound of the interval */
4967  SCIP_Longint maxdnom /**< maximal denominator allowed for resulting rational number */
4968  );
4969 
4970 /* The C99 standard defines the function (or macro) isfinite.
4971  * On MacOS X, isfinite is also available.
4972  * From the BSD world, there comes a function finite.
4973  * On SunOS, finite is also available.
4974  * In the MS compiler world, there is a function _finite.
4975  * As last resort, we check whether x == x does not hold, but this works only for NaN's, not for infinities!
4976  */
4977 #if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L || defined(__APPLE__)
4978 #define SCIPisFinite isfinite
4979 #elif defined(_BSD_SOURCE) || defined(__sun)
4980 #define SCIPisFinite finite
4981 #elif defined(_MSC_VER)
4982 #define SCIPisFinite _finite
4983 #else
4984 #define SCIPisFinite(x) ((x) == (x))
4985 #endif
4986 
4987 /* In debug mode, the following methods are implemented as function calls to ensure
4988  * type validity.
4989  */
4990 
4991 /** returns the relative difference: (val1-val2)/max(|val1|,|val2|,1.0) */
4992 extern
4994  SCIP_Real val1, /**< first value to be compared */
4995  SCIP_Real val2 /**< second value to be compared */
4996  );
4997 
4998 #ifdef NDEBUG
4999 
5000 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
5001  * speed up the algorithms.
5002  */
5003 
5004 #define SCIPrelDiff(val1, val2) ( ((val1)-(val2))/(MAX3(1.0,REALABS(val1),REALABS(val2))) )
5005 
5006 #endif
5007 
5008 /**@} */
5009 
5010 
5011 /*
5012  * Random Numbers
5013  */
5014 
5015 /**@defgroup RandomNumbers Random Numbers
5016  *
5017  *@{
5018  */
5019 
5020 /** returns a random integer between minrandval and maxrandval */
5021 extern
5022 int SCIPgetRandomInt(
5023  int minrandval, /**< minimal value to return */
5024  int maxrandval, /**< maximal value to return */
5025  unsigned int* seedp /**< pointer to seed value */
5026  );
5027 
5028 /** returns a random real between minrandval and maxrandval */
5029 extern
5031  SCIP_Real minrandval, /**< minimal value to return */
5032  SCIP_Real maxrandval, /**< maximal value to return */
5033  unsigned int* seedp /**< pointer to seed value */
5034  );
5035 
5036 /**@} */
5037 
5038 
5039 /*
5040  * Additional math functions
5041  */
5042 
5043 /**@defgroup AdditionalMathFunctions Additional math functions
5044  *
5045  *@{
5046  */
5047 
5048 /** calculates a binomial coefficient n over m, choose m elements out of n, maximal value will be 33 over 16 (because
5049  * 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
5050  * big numbers or an negative value m (and m < n) and -1 will be returned
5051  */
5052 extern
5054  int n, /**< number of different elements */
5055  int m /**< number to choose out of the above */
5056  );
5057 
5058 /**@} */
5059 
5060 /*
5061  * Permutations / Shuffling
5062  */
5063 
5064 /**@defgroup PermutationsShuffling Permutations Shuffling
5065  *
5066  *@{
5067  */
5068 
5069 /** swaps two ints */
5070 extern
5071 void SCIPswapInts(
5072  int* value1, /**< pointer to first integer */
5073  int* value2 /**< pointer ti second integer */
5074  );
5075 
5076 /** swaps the addresses of two pointers */
5077 extern
5078 void SCIPswapPointers(
5079  void** pointer1, /**< first pointer */
5080  void** pointer2 /**< second pointer */
5081  );
5082 
5083 /** randomly shuffles parts of an integer array using the Fisher-Yates algorithm */
5084 extern
5085 void SCIPpermuteIntArray(
5086  int* array, /**< array to be shuffled */
5087  int begin, /**< first index that should be subject to shuffling (0 for whole array) */
5088  int end, /**< last index that should be subject to shuffling (array size for whole
5089  * array)
5090  */
5091  unsigned int* randseed /**< seed value for the random generator */
5092  );
5093 
5094 /** randomly shuffles parts of an array using the Fisher-Yates algorithm */
5095 extern
5096 void SCIPpermuteArray(
5097  void** array, /**< array to be shuffled */
5098  int begin, /**< first index that should be subject to shuffling (0 for whole array) */
5099  int end, /**< last index that should be subject to shuffling (array size for whole
5100  * array)
5101  */
5102  unsigned int* randseed /**< pointer to seed value for the random generator */
5103  );
5104 
5105 /** draws a random subset of disjoint elements from a given set of disjoint elements;
5106  * this implementation is suited for the case that nsubelems is considerably smaller then nelems
5107  */
5108 extern
5110  void** set, /**< original set, from which elements should be drawn */
5111  int nelems, /**< number of elements in original set */
5112  void** subset, /**< subset in which drawn elements should be stored */
5113  int nsubelems, /**< number of elements that should be drawn and stored */
5114  unsigned int randseed /**< seed value for random generator */
5115  );
5116 
5117 /**@} */
5118 
5119 /*
5120  * Strings
5121  */
5122 
5123 /**@defgroup StringMethods String Methods
5124  *
5125  *@{
5126  */
5127 
5128 /** copies characters from 'src' to 'dest', copying is stopped when either the 'stop' character is reached or after
5129  * 'cnt' characters have been copied, whichever comes first.
5130  *
5131  * @note undefined behaviuor on overlapping arrays
5132  */
5133 extern
5134 int SCIPmemccpy(
5135  char* dest, /**< destination pointer to copy to */
5136  const char* src, /**< source pointer to copy to */
5137  char stop, /**< character when found stop copying */
5138  unsigned int cnt /**< maximal number of characters to copy too */
5139  );
5140 
5141 /** prints an error message containing of the given string followed by a string describing the current system error;
5142  * prefers to use the strerror_r method, which is threadsafe; on systems where this method does not exist,
5143  * NO_STRERROR_R should be defined (see INSTALL), in this case, srerror is used which is not guaranteed to be
5144  * threadsafe (on SUN-systems, it actually is)
5145  */
5146 extern
5147 void SCIPprintSysError(
5148  const char* message /**< first part of the error message, e.g. the filename */
5149  );
5150 
5151 /** extracts tokens from strings - wrapper method for strtok_r() */
5152 extern
5153 char* SCIPstrtok(
5154  char* s, /**< string to parse */
5155  const char* delim, /**< delimiters for parsing */
5156  char** ptrptr /**< pointer to working char pointer - must stay the same while parsing */
5157  );
5158 
5159 /** translates the given string into a string where symbols ", ', and spaces are escaped with a \ prefix */
5160 extern
5161 void SCIPescapeString(
5162  char* t, /**< target buffer to store escaped string */
5163  int bufsize, /**< size of buffer t */
5164  const char* s /**< string to transform into escaped string */
5165  );
5166 
5167 /** safe version of snprintf */
5168 extern
5169 int SCIPsnprintf(
5170  char* t, /**< target string */
5171  int len, /**< length of the string to copy */
5172  const char* s, /**< source string */
5173  ... /**< further parameters */
5174  );
5175 
5176 /** 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
5177  *
5178  * @return Returns TRUE if a value could be extracted, otherwise FALSE
5179  */
5180 extern
5182  const char* str, /**< string to search */
5183  int* value, /**< pointer to store the parsed value */
5184  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5185  );
5186 
5187 /** 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
5188  *
5189  * @return Returns TRUE if a value could be extracted, otherwise FALSE
5190  */
5191 extern
5193  const char* str, /**< string to search */
5194  SCIP_Real* value, /**< pointer to store the parsed value */
5195  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5196  );
5197 
5198 /** copies the first size characters between a start and end character of str into token, if no error occured endptr
5199  * will point to the position after the read part, otherwise it will point to @p str
5200  */
5201 extern
5202 void