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-2015 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  * methods for statistical tests
57  */
58 
59 /**@defgroup STATISTICALTESTS Methods for statistical tests
60  *
61  * @{
62  */
63 
64 /** get critical value of a Student-T distribution for a given number of degrees of freedom at a confidence level */
65 extern
67  SCIP_CONFIDENCELEVEL clevel, /**< (one-sided) confidence level */
68  int df /**< degrees of freedom */
69  );
70 
71 /** compute a t-value for the hypothesis that x and y are from the same population; Assuming that
72  * x and y represent normally distributed random samples with equal variance, the returned value
73  * comes from a Student-T distribution with countx + county - 2 degrees of freedom; this
74  * value can be compared with a critical value (see also SCIPstudentTGetCriticalValue()) at
75  * a predefined confidence level for checking if x and y significantly differ in location
76  */
77 extern
79  SCIP_Real meanx, /**< the mean of the first distribution */
80  SCIP_Real meany, /**< the mean of the second distribution */
81  SCIP_Real variancex, /**< the variance of the x-distribution */
82  SCIP_Real variancey, /**< the variance of the y-distribution */
83  SCIP_Real countx, /**< number of samples of x */
84  SCIP_Real county /**< number of samples of y */
85  );
86 
87 /** returns the value of the Gauss error function evaluated at a given point */
88 extern
90  SCIP_Real x /**< value to evaluate */
91  );
92 
93 /** get critical value of a standard normal distribution at a given confidence level */
94 extern
96  SCIP_CONFIDENCELEVEL clevel /**< (one-sided) confidence level */
97  );
98 
99 /** calculates the cumulative distribution P(-infinity <= x <= value) that a normally distributed
100  * random variable x takes a value between -infinity and parameter \p value.
101  *
102  * The distribution is given by the respective mean and deviation. This implementation
103  * uses the error function erf().
104  */
105 extern
107  SCIP_Real mean, /**< the mean value of the distribution */
108  SCIP_Real variance, /**< the square of the deviation of the distribution */
109  SCIP_Real value /**< the upper limit of the calculated distribution integral */
110  );
111 
112 /**@} */
113 
114 /*
115  * GML graphical printing methods
116  * For a detailed format decription see http://docs.yworks.com/yfiles/doc/developers-guide/gml.html
117  */
118 
119 /**@defgroup GMLgraph GML graphical printing
120  *
121  * @{
122  */
123 
124 
125 /** writes a node section to the given graph file */
126 extern
127 void SCIPgmlWriteNode(
128  FILE* file, /**< file to write to */
129  unsigned int id, /**< id of the node */
130  const char* label, /**< label of the node */
131  const char* nodetype, /**< type of the node, or NULL */
132  const char* fillcolor, /**< color of the node's interior, or NULL */
133  const char* bordercolor /**< color of the node's border, or NULL */
134  );
135 
136 /** writes a node section including weight to the given graph file */
137 extern
139  FILE* file, /**< file to write to */
140  unsigned int id, /**< id of the node */
141  const char* label, /**< label of the node */
142  const char* nodetype, /**< type of the node, or NULL */
143  const char* fillcolor, /**< color of the node's interior, or NULL */
144  const char* bordercolor, /**< color of the node's border, or NULL */
145  SCIP_Real weight /**< weight of node */
146  );
147 
148 /** writes an edge section to the given graph file */
149 extern
150 void SCIPgmlWriteEdge(
151  FILE* file, /**< file to write to */
152  unsigned int source, /**< source node id of the node */
153  unsigned int target, /**< target node id of the edge */
154  const char* label, /**< label of the edge, or NULL */
155  const char* color /**< color of the edge, or NULL */
156  );
157 
158 /** writes an arc section to the given graph file */
159 extern
160 void SCIPgmlWriteArc(
161  FILE* file, /**< file to write to */
162  unsigned int source, /**< source node id of the node */
163  unsigned int target, /**< target node id of the edge */
164  const char* label, /**< label of the edge, or NULL */
165  const char* color /**< color of the edge, or NULL */
166  );
167 
168 /** writes the starting line to a GML graph file, does not open a file */
169 extern
171  FILE* file, /**< file to write to */
172  SCIP_Bool directed /**< is the graph directed */
173  );
174 
175 /** writes the ending lines to a GML graph file, does not close a file */
176 extern
178  FILE* file /**< file to close */
179  );
180 
181 /**@} */
182 
183 
184 /** @defgroup DataStructures Data Structures
185  *
186  * Below you find a list of available data structures
187  *
188  * @{
189  */
190 
191 
192 /*
193  * Sparse solution
194  */
195 
196 /**@defgroup SparseSol Sparse solution
197  *
198  * @{
199  */
200 
201 /** creates a sparse solution */
202 extern
204  SCIP_SPARSESOL** sparsesol, /**< pointer to store the created sparse solution */
205  SCIP_VAR** vars, /**< variables in the sparse solution, must not contain continuous variables */
206  int nvars, /**< number of variables to store, size of the lower and upper bound arrays */
207  SCIP_Bool cleared /**< should the lower and upper bound arrays be cleared (entries set to 0) */
208  );
209 
210 /** frees sparse solution */
211 extern
212 void SCIPsparseSolFree(
213  SCIP_SPARSESOL** sparsesol /**< pointer to a sparse solution */
214  );
215 
216 /** returns the variables in the given sparse solution */
217 extern
219  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
220  );
221 
222 /** returns the number of variables in the given sparse solution */
223 extern
225  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
226  );
227 
228 /** returns the the lower bound array for all variables for a given sparse solution */
229 extern
231  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
232  );
233 
234 /** returns the the upper bound array for all variables for a given sparse solution */
235 extern
237  SCIP_SPARSESOL* sparsesol /**< a sparse solution */
238  );
239 
240 /** constructs the first solution of sparse solution (all variables are set to their lower bound value */
241 extern
243  SCIP_SPARSESOL* sparsesol, /**< sparse solutions */
244  SCIP_Longint* sol, /**< array to store the first solution */
245  int nvars /**< number of variables */
246  );
247 
248 /** constructs the next solution of the sparse solution and return whether there was one more or not */
249 extern
251  SCIP_SPARSESOL* sparsesol, /**< sparse solutions */
252  SCIP_Longint* sol, /**< current solution array which get changed to the next solution */
253  int nvars /**< number of variables */
254  );
255 
256 /**@} */
257 
258 
259 /*
260  * Queue
261  */
262 
263 /**@defgroup Queue Queue
264  *
265  * @{
266  */
267 
268 
269 /** creates a (circular) queue, best used if the size will be fixed or will not be increased that much */
270 extern
272  SCIP_QUEUE** queue, /**< pointer to the new queue */
273  int initsize, /**< initial number of available element slots */
274  SCIP_Real sizefac /**< memory growing factor applied, if more element slots are needed */
275  );
276 
277 
278 /** frees queue, but not the data elements themselves */
279 extern
280 void SCIPqueueFree(
281  SCIP_QUEUE** queue /**< pointer to a queue */
282  );
283 
284 /** clears the queue, but doesn't free the data elements themselves */
285 extern
286 void SCIPqueueClear(
287  SCIP_QUEUE* queue /**< queue */
288  );
289 
290 /** inserts element at the end of the queue */
291 extern
293  SCIP_QUEUE* queue, /**< queue */
294  void* elem /**< element to be inserted */
295  );
296 
297 /** removes and returns the first element of the queue */
298 extern
299 void* SCIPqueueRemove(
300  SCIP_QUEUE* queue /**< queue */
301  );
302 
303 /** returns the first element of the queue without removing it */
304 extern
305 void* SCIPqueueFirst(
306  SCIP_QUEUE* queue /**< queue */
307  );
308 
309 /** returns whether the queue is empty */
310 extern
312  SCIP_QUEUE* queue /**< queue */
313  );
314 
315 /** returns the number of elements in the queue */
316 extern
317 int SCIPqueueNElems(
318  SCIP_QUEUE* queue /**< queue */
319  );
320 
321 /**@} */
322 
323 /*
324  * Priority Queue
325  */
326 
327 /**@defgroup PriorityQueue Priority Queue
328  *
329  * @{
330  */
331 
332 /** creates priority queue */
333 extern
335  SCIP_PQUEUE** pqueue, /**< pointer to a priority queue */
336  int initsize, /**< initial number of available element slots */
337  SCIP_Real sizefac, /**< memory growing factor applied, if more element slots are needed */
338  SCIP_DECL_SORTPTRCOMP((*ptrcomp)) /**< data element comparator */
339  );
340 
341 /** frees priority queue, but not the data elements themselves */
342 extern
343 void SCIPpqueueFree(
344  SCIP_PQUEUE** pqueue /**< pointer to a priority queue */
345  );
346 
347 /** clears the priority queue, but doesn't free the data elements themselves */
348 extern
349 void SCIPpqueueClear(
350  SCIP_PQUEUE* pqueue /**< priority queue */
351  );
352 
353 /** inserts element into priority queue */
354 extern
356  SCIP_PQUEUE* pqueue, /**< priority queue */
357  void* elem /**< element to be inserted */
358  );
359 
360 /** removes and returns best element from the priority queue */
361 extern
362 void* SCIPpqueueRemove(
363  SCIP_PQUEUE* pqueue /**< priority queue */
364  );
365 
366 /** returns the best element of the queue without removing it */
367 extern
368 void* SCIPpqueueFirst(
369  SCIP_PQUEUE* pqueue /**< priority queue */
370  );
371 
372 /** returns the number of elements in the queue */
373 extern
374 int SCIPpqueueNElems(
375  SCIP_PQUEUE* pqueue /**< priority queue */
376  );
377 
378 /** returns the elements of the queue; changing the returned array may destroy the queue's ordering! */
379 extern
380 void** SCIPpqueueElems(
381  SCIP_PQUEUE* pqueue /**< priority queue */
382  );
383 
384 /**@} */
385 
386 
387 /*
388  * Hash Table
389  */
390 
391 /**@defgroup HashTable Hash Table
392  *
393  *@{
394  */
395 
396 /** returns a reasonable hash table size (a prime number) that is at least as large as the specified value */
397 extern
399  int minsize /**< minimal size of the hash table */
400  );
401 
402 /** creates a hash table */
403 extern
405  SCIP_HASHTABLE** hashtable, /**< pointer to store the created hash table */
406  BMS_BLKMEM* blkmem, /**< block memory used to store hash table entries */
407  int tablesize, /**< size of the hash table */
408  SCIP_DECL_HASHGETKEY((*hashgetkey)), /**< gets the key of the given element */
409  SCIP_DECL_HASHKEYEQ ((*hashkeyeq)), /**< returns TRUE iff both keys are equal */
410  SCIP_DECL_HASHKEYVAL((*hashkeyval)), /**< returns the hash value of the key */
411  void* userptr /**< user pointer */
412  );
413 
414 /** frees the hash table */
415 extern
416 void SCIPhashtableFree(
417  SCIP_HASHTABLE** hashtable /**< pointer to the hash table */
418  );
419 
420 /** removes all elements of the hash table
421  *
422  * @note From a performance point of view you should not fill and clear a hash table too often since the clearing can
423  * be expensive. Clearing is done by looping over all buckets and removing the hash table lists one-by-one.
424  *
425  * @deprecated Please use SCIPhashtableRemoveAll()
426  */
427 extern
428 void SCIPhashtableClear(
429  SCIP_HASHTABLE* hashtable /**< hash table */
430  );
431 
432 /** inserts element in hash table (multiple inserts of same element possible)
433  *
434  * @note A pointer to a hashtablelist returned by SCIPhashtableRetrieveNext() might get invalid when adding an element
435  * to the hash table, due to dynamic resizing.
436  */
437 extern
439  SCIP_HASHTABLE* hashtable, /**< hash table */
440  void* element /**< element to insert into the table */
441  );
442 
443 /** inserts element in hash table (multiple insertion of same element is checked and results in an error)
444  *
445  * @note A pointer to a hashtablelist returned by SCIPhashtableRetrieveNext() might get invalid when adding a new
446  * element to the hash table, due to dynamic resizing.
447  */
448 extern
450  SCIP_HASHTABLE* hashtable, /**< hash table */
451  void* element /**< element to insert into the table */
452  );
453 
454 /** retrieve element with key from hash table, returns NULL if not existing */
455 extern
457  SCIP_HASHTABLE* hashtable, /**< hash table */
458  void* key /**< key to retrieve */
459  );
460 
461 /** retrieve element with key from hash table, returns NULL if not existing
462  * can be used to retrieve all entries with the same key (one-by-one)
463  *
464  * @note The returned hashtablelist pointer might get invalid when adding a new element to the hash table.
465  */
466 extern
468  SCIP_HASHTABLE* hashtable, /**< hash table */
469  SCIP_HASHTABLELIST** hashtablelist, /**< input: entry in hash table list from which to start searching, or NULL
470  * output: entry in hash table list corresponding to element after
471  * retrieved one, or NULL */
472  void* key /**< key to retrieve */
473  );
474 
475 /** returns whether the given element exists in the table */
476 extern
478  SCIP_HASHTABLE* hashtable, /**< hash table */
479  void* element /**< element to search in the table */
480  );
481 
482 /** removes element from the hash table, if it exists */
483 extern
485  SCIP_HASHTABLE* hashtable, /**< hash table */
486  void* element /**< element to remove from the table */
487  );
488 
489 /** removes all elements of the hash table
490  *
491  * @note From a performance point of view you should not fill and clear a hash table too often since the clearing can
492  * be expensive. Clearing is done by looping over all buckets and removing the hash table lists one-by-one.
493  */
494 extern
496  SCIP_HASHTABLE* hashtable /**< hash table */
497  );
498 
499 /** returns number of hash table elements */
500 extern
502  SCIP_HASHTABLE* hashtable /**< hash table */
503  );
504 
505 /** returns the load of the given hash table in percentage */
506 extern
508  SCIP_HASHTABLE* hashtable /**< hash table */
509  );
510 
511 /** prints statistics about hash table usage */
512 extern
514  SCIP_HASHTABLE* hashtable, /**< hash table */
515  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
516  );
517 
518 /** standard hash key comparator for string keys */
519 extern
520 SCIP_DECL_HASHKEYEQ(SCIPhashKeyEqString);
521 
522 /** standard hashing function for string keys */
523 extern
524 SCIP_DECL_HASHKEYVAL(SCIPhashKeyValString);
525 
526 /** gets the element as the key */
527 extern
528 SCIP_DECL_HASHGETKEY(SCIPhashGetKeyStandard);
529 
530 /** returns TRUE iff both keys(pointer) are equal */
531 extern
532 SCIP_DECL_HASHKEYEQ(SCIPhashKeyEqPtr);
533 
534 /** returns the hash value of the key */
535 extern
536 SCIP_DECL_HASHKEYVAL(SCIPhashKeyValPtr);
537 
538 /**@} */
539 
540 
541 /*
542  * Hash Map
543  */
544 
545 /**@defgroup HashMap Hash Map
546  *
547  *@{
548  */
549 
550 /** creates a hash map mapping pointers to pointers */
551 extern
553  SCIP_HASHMAP** hashmap, /**< pointer to store the created hash map */
554  BMS_BLKMEM* blkmem, /**< block memory used to store hash map entries */
555  int mapsize /**< size of the hash map */
556  );
557 
558 /** frees the hash map */
559 extern
560 void SCIPhashmapFree(
561  SCIP_HASHMAP** hashmap /**< pointer to the hash map */
562  );
563 
564 /** inserts new origin->image pair in hash map (must not be called for already existing origins!) */
565 extern
567  SCIP_HASHMAP* hashmap, /**< hash map */
568  void* origin, /**< origin to set image for */
569  void* image /**< new image for origin */
570  );
571 
572 /** retrieves image of given origin from the hash map, or NULL if no image exists */
573 extern
574 void* SCIPhashmapGetImage(
575  SCIP_HASHMAP* hashmap, /**< hash map */
576  void* origin /**< origin to retrieve image for */
577  );
578 
579 /** sets image for given origin in the hash map, either by modifying existing origin->image pair or by appending a
580  * new origin->image pair
581  */
582 extern
584  SCIP_HASHMAP* hashmap, /**< hash map */
585  void* origin, /**< origin to set image for */
586  void* image /**< new image for origin */
587  );
588 
589 /** checks whether an image to the given origin exists in the hash map */
590 extern
592  SCIP_HASHMAP* hashmap, /**< hash map */
593  void* origin /**< origin to search for */
594  );
595 
596 /** removes origin->image pair from the hash map, if it exists */
597 extern
599  SCIP_HASHMAP* hashmap, /**< hash map */
600  void* origin /**< origin to remove from the list */
601  );
602 
603 /** prints statistics about hash map usage */
604 extern
606  SCIP_HASHMAP* hashmap, /**< hash map */
607  SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
608  );
609 
610 /** indicates whether a hash map has no entries */
611 extern
613  SCIP_HASHMAP* hashmap /**< hash map */
614 );
615 
616 /** gives the number of entries in a hash map */
617 extern
619  SCIP_HASHMAP* hashmap /**< hash map */
620 );
621 
622 /** gives the number of lists (buckets) in a hash map */
623 extern
625  SCIP_HASHMAP* hashmap /**< hash map */
626 );
627 
628 /** gives a specific list (bucket) in a hash map */
629 extern
631  SCIP_HASHMAP* hashmap, /**< hash map */
632  int listindex /**< index of hash map list */
633 );
634 
635 /** gives the number of entries in a list of a hash map */
636 extern
638  SCIP_HASHMAPLIST* hashmaplist /**< hash map list, can be NULL */
639 );
640 
641 /** retrieves origin of given entry in a hash map */
642 extern
644  SCIP_HASHMAPLIST* hashmaplist /**< hash map list */
645 );
646 
647 /** retrieves image of given entry in a hash map */
648 extern
650  SCIP_HASHMAPLIST* hashmaplist /**< hash map list */
651 );
652 
653 /** retrieves next entry from given entry in a hash map list, or NULL if at end of list. */
654 extern
656  SCIP_HASHMAPLIST* hashmaplist /**< hash map list */
657 );
658 
659 /** removes all entries in a hash map. */
660 extern
662  SCIP_HASHMAP* hashmap /**< hash map */
663 );
664 
665 /**@} */
666 
667 
668 
669 /*
670  * Activity
671  */
672 
673 /**@defgroup ResourceActivity Resource activity
674  *
675  *@{
676  */
677 
678 /** create a resource activity */
679 extern
681  SCIP_RESOURCEACTIVITY** activity, /**< pointer to store the resource activity */
682  SCIP_VAR* var, /**< start time variable of the activity */
683  int duration, /**< duration of the activity */
684  int demand /**< demand of the activity */
685  );
686 
687 /** frees a resource activity */
688 extern
689 void SCIPactivityFree(
690  SCIP_RESOURCEACTIVITY** activity /**< pointer to the resource activity */
691  );
692 
693 #ifndef NDEBUG
694 
695 /** returns the start time variable of the resource activity */
696 extern
698  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
699  );
700 
701 /** returns the duration of the resource activity */
702 extern
704  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
705  );
706 
707 /** returns the demand of the resource activity */
708 extern
710  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
711  );
712 
713 /** returns the energy of the resource activity */
714 extern
716  SCIP_RESOURCEACTIVITY* activity /**< resource activity */
717  );
718 
719 #else
720 
721 #define SCIPactivityGetVar(activity) ((activity)->var)
722 #define SCIPactivityGetDuration(activity) ((activity)->duration)
723 #define SCIPactivityGetDemand(activity) ((activity)->demand)
724 #define SCIPactivityGetEnergy(activity) ((activity)->duration * (activity)->demand)
725 
726 #endif
727 
728 /**@} */
729 
730 
731 /*
732  * Resource Profile
733  */
734 
735 /**@defgroup ResourceProfile Resource Profile
736  *
737  *@{
738  */
739 
740 /** creates resource profile */
741 extern
743  SCIP_PROFILE** profile, /**< pointer to store the resource profile */
744  int capacity /**< resource capacity */
745  );
746 
747 /** frees given resource profile */
748 extern
749 void SCIPprofileFree(
750  SCIP_PROFILE** profile /**< pointer to the resource profile */
751  );
752 
753 /** output of the given resource profile */
754 extern
755 void SCIPprofilePrint(
756  SCIP_PROFILE* profile, /**< resource profile to output */
757  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
758  FILE* file /**< output file (or NULL for standard output) */
759  );
760 
761 /** returns the capacity of the resource profile */
762 extern
764  SCIP_PROFILE* profile /**< resource profile to use */
765  );
766 
767 /** returns the number time points of the resource profile */
768 extern
770  SCIP_PROFILE* profile /**< resource profile to use */
771  );
772 
773 /** returns the time points of the resource profile */
774 extern
776  SCIP_PROFILE* profile /**< resource profile to use */
777  );
778 
779 /** returns the loads of the resource profile */
780 extern
782  SCIP_PROFILE* profile /**< resource profile to use */
783  );
784 
785 /** returns the time point for given position of the resource profile */
786 extern
788  SCIP_PROFILE* profile, /**< resource profile to use */
789  int pos /**< position */
790  );
791 
792 /** returns the loads of the resource profile at the given position */
793 extern
795  SCIP_PROFILE* profile, /**< resource profile */
796  int pos /**< position */
797  );
798 
799 /** returns if the given time point exists in the resource profile and stores the position of the given time point if it
800  * exists; otherwise the position of the next smaller existing time point is stored
801  */
802 extern
804  SCIP_PROFILE* profile, /**< resource profile to search */
805  int timepoint, /**< time point to search for */
806  int* pos /**< pointer to store the position */
807  );
808 
809 /** insert a core into resource profile; if the core is non-empty the resource profile will be updated otherwise nothing
810  * happens
811  */
812 extern
814  SCIP_PROFILE* profile, /**< resource profile to use */
815  int left, /**< left side of the core */
816  int right, /**< right side of the core */
817  int height, /**< height of the core */
818  int* pos, /**< pointer to store the first position were it gets infeasible */
819  SCIP_Bool* infeasible /**< pointer to store if the core does not fit due to capacity */
820  );
821 
822 /** subtracts the height from the resource profile during core time */
823 extern
825  SCIP_PROFILE* profile, /**< resource profile to use */
826  int left, /**< left side of the core */
827  int right, /**< right side of the core */
828  int height /**< height of the core */
829  );
830 
831 /** return the earliest possible starting point within the time interval [lb,ub] for a given core (given by its height
832  * and duration)
833  */
834 extern
836  SCIP_PROFILE* profile, /**< resource profile to use */
837  int est, /**< earliest starting time of the given core */
838  int lst, /**< latest starting time of the given core */
839  int duration, /**< duration of the core */
840  int height, /**< height of the core */
841  SCIP_Bool* infeasible /**< pointer store if the corer cannot be inserted */
842  );
843 
844 /** return the latest possible starting point within the time interval [lb,ub] for a given core (given by its height and
845  * duration)
846  */
847 extern
849  SCIP_PROFILE* profile, /**< resource profile to use */
850  int lb, /**< earliest possible start point */
851  int ub, /**< latest possible start point */
852  int duration, /**< duration of the core */
853  int height, /**< height of the core */
854  SCIP_Bool* infeasible /**< pointer store if the core cannot be inserted */
855  );
856 
857 /**@} */
858 
859 /*
860  * Directed graph
861  */
862 
863 /**@defgroup DirectedGraph Directed Graph
864  *
865  *@{
866  */
867 
868 /** creates directed graph structure */
869 extern
871  SCIP_DIGRAPH** digraph, /**< pointer to store the created directed graph */
872  int nnodes /**< number of nodes */
873  );
874 
875 /** resize directed graph structure */
876 extern
878  SCIP_DIGRAPH* digraph, /**< directed graph */
879  int nnodes /**< new number of nodes */
880  );
881 
882 /** copies directed graph structure
883  *
884  * @note The data in nodedata is copied verbatim. This possibly has to be adapted by the user.
885  */
886 extern
888  SCIP_DIGRAPH** targetdigraph, /**< pointer to store the copied directed graph */
889  SCIP_DIGRAPH* sourcedigraph /**< source directed graph */
890  );
891 
892 /** sets the sizes of the successor lists for the nodes in a directed graph and allocates memory for the lists */
893 extern
895  SCIP_DIGRAPH* digraph, /**< directed graph */
896  int* sizes /**< sizes of the successor lists */
897  );
898 
899 /** frees given directed graph structure */
900 extern
901 void SCIPdigraphFree(
902  SCIP_DIGRAPH** digraph /**< pointer to the directed graph */
903  );
904 
905 /** add (directed) arc and a related data to the directed graph structure
906  *
907  * @note if the arc is already contained, it is added a second time
908  */
909 extern
911  SCIP_DIGRAPH* digraph, /**< directed graph */
912  int startnode, /**< start node of the arc */
913  int endnode, /**< start node of the arc */
914  void* data /**< data that should be stored for the arc; or NULL */
915  );
916 
917 /** add (directed) arc to the directed graph structure, if it is not contained, yet
918  *
919  * @note if there already exists an arc from startnode to endnode, the new arc is not added,
920  * even if its data is different
921  */
922 extern
924  SCIP_DIGRAPH* digraph, /**< directed graph */
925  int startnode, /**< start node of the arc */
926  int endnode, /**< start node of the arc */
927  void* data /**< data that should be stored for the arc; or NULL */
928  );
929 
930 /** sets the number of successors to a given value */
931 extern
933  SCIP_DIGRAPH* digraph, /**< directed graph */
934  int node, /**< node for which the number of successors has to be changed */
935  int nsuccessors /**< new number of successors */
936  );
937 
938 /** returns the number of nodes of the given digraph */
939 extern
941  SCIP_DIGRAPH* digraph /**< directed graph */
942  );
943 
944 /** returns the node data, or NULL if no data exist */
945 extern
947  SCIP_DIGRAPH* digraph, /**< directed graph */
948  int node /**< node for which the node data is returned */
949  );
950 
951 /** sets the node data */
952 extern
954  SCIP_DIGRAPH* digraph, /**< directed graph */
955  void* dataptr, /**< user node data pointer, or NULL */
956  int node /**< node for which the node data is returned */
957  );
958 
959 /** returns the total number of arcs in the given digraph */
960 extern
962  SCIP_DIGRAPH* digraph /**< directed graph */
963  );
964 
965 /** returns the number of successor nodes of the given node */
966 extern
968  SCIP_DIGRAPH* digraph, /**< directed graph */
969  int node /**< node for which the number of outgoing arcs is returned */
970  );
971 
972 /** returns the array of indices of the successor nodes; this array must not be changed from outside */
973 extern
975  SCIP_DIGRAPH* digraph, /**< directed graph */
976  int node /**< node for which the array of outgoing arcs is returned */
977  );
978 
979 /** returns the array of data corresponding to the arcs originating at the given node, or NULL if no data exist; this
980  * array must not be changed from outside
981  */
982 extern
984  SCIP_DIGRAPH* digraph, /**< directed graph */
985  int node /**< node for which the data corresponding to the outgoing arcs is returned */
986  );
987 
988 /** Compute undirected connected components on the given graph.
989  *
990  * @note For each arc, its reverse is added, so the graph does not need to be the directed representation of an
991  * undirected graph.
992  */
993 extern
995  SCIP_DIGRAPH* digraph, /**< directed graph */
996  int minsize, /**< all components with less nodes are ignored */
997  int* components, /**< array with as many slots as there are nodes in the directed graph
998  * to store for each node the component to which it belongs
999  * (components are numbered 0 to ncomponents - 1); or NULL, if components
1000  * are accessed one-by-one using SCIPdigraphGetComponent() */
1001  int* ncomponents /**< pointer to store the number of components; or NULL, if the
1002  * number of components is accessed by SCIPdigraphGetNComponents() */
1003  );
1004 
1005 /** Computes all strongly connected components of an undirected connected component with Tarjan's Algorithm.
1006  * The resulting strongly connected components are sorted topologically (starting from the end of the
1007  * strongcomponents array).
1008  *
1009  * @note In general a topological sort of the strongly connected components is not unique.
1010  */
1011 extern
1013  SCIP_DIGRAPH* digraph, /**< directed graph */
1014  int compidx, /**< number of the undirected connected component */
1015  int* strongcomponents, /**< array to store the strongly connected components
1016  * (length >= size of the component) */
1017  int* strongcompstartidx, /**< array to store the start indices of the strongly connected
1018  * components (length >= size of the component) */
1019  int* nstrongcomponents /**< pointer to store the number of strongly connected
1020  * components */
1021  );
1022 
1023 /** Performes an (almost) topological sort on the undirected components of the given directed graph. The undirected
1024  * components should be computed before using SCIPdigraphComputeUndirectedComponents().
1025  *
1026  * @note In general a topological sort is not unique. Note, that there might be directed cycles, that are randomly
1027  * broken, which is the reason for having only almost topologically sorted arrays.
1028  */
1029 extern
1031  SCIP_DIGRAPH* digraph /**< directed graph */
1032  );
1033 
1034 /** returns the number of previously computed undirected components for the given directed graph */
1035 extern
1037  SCIP_DIGRAPH* digraph /**< directed graph */
1038  );
1039 
1040 /** Returns the previously computed undirected component of the given number for the given directed graph.
1041  * If the components were sorted using SCIPdigraphTopoSortComponents(), the component is (almost) topologically sorted.
1042  */
1043 extern
1045  SCIP_DIGRAPH* digraph, /**< directed graph */
1046  int compidx, /**< number of the component to return */
1047  int** nodes, /**< pointer to store the nodes in the component; or NULL, if not needed */
1048  int* nnodes /**< pointer to store the number of nodes in the component;
1049  * or NULL, if not needed */
1050  );
1051 
1052 /** frees the component information for the given directed graph */
1053 extern
1055  SCIP_DIGRAPH* digraph /**< directed graph */
1056  );
1057 
1058 /** output of the given directed graph via the given message handler */
1059 extern
1060 void SCIPdigraphPrint(
1061  SCIP_DIGRAPH* digraph, /**< directed graph */
1062  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1063  FILE* file /**< output file (or NULL for standard output) */
1064  );
1065 
1066 /** prints the given directed graph structure in GML format into the given file */
1067 extern
1068 void SCIPdigraphPrintGml(
1069  SCIP_DIGRAPH* digraph, /**< directed graph */
1070  FILE* file /**< file to write to */
1071  );
1072 
1073 
1074 /** output of the given directed graph via the given message handler */
1075 extern
1077  SCIP_DIGRAPH* digraph, /**< directed graph */
1078  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1079  FILE* file /**< output file (or NULL for standard output) */
1080  );
1081 
1082 /**@} */
1083 
1084 /*
1085  * Binary search tree
1086  */
1087 
1088 /**@defgroup BinaryTree Binary Tree
1089  *
1090  *@{
1091  */
1092 
1093 /** creates a binary tree node with sorting value and user data */
1094 extern
1096  SCIP_BT* tree, /**< binary search tree */
1097  SCIP_BTNODE** node, /**< pointer to store the created search node */
1098  void* dataptr /**< user node data pointer, or NULL */
1099  );
1100 
1101 /** frees the binary node including the rooted subtree
1102  *
1103  * @note The user pointer (object) is not freed. If needed, it has to be done by the user.
1104  */
1105 extern
1106 void SCIPbtnodeFree(
1107  SCIP_BT* tree, /**< binary tree */
1108  SCIP_BTNODE** node /**< node to be freed */
1109  );
1110 
1111 /** returns the user data pointer stored in that node */
1112 extern
1113 void* SCIPbtnodeGetData(
1114  SCIP_BTNODE* node /**< node */
1115  );
1116 
1117 /** returns the parent which can be NULL if the given node is the root */
1118 extern
1120  SCIP_BTNODE* node /**< node */
1121  );
1122 
1123 /** returns left child which can be NULL if the given node is a leaf */
1124 extern
1126  SCIP_BTNODE* node /**< node */
1127  );
1128 
1129 /** returns right child which can be NULL if the given node is a leaf */
1130 extern
1132  SCIP_BTNODE* node /**< node */
1133  );
1134 
1135 /** returns the sibling of the node or NULL if does not exist */
1136 extern
1138  SCIP_BTNODE* node /**< node */
1139  );
1140 
1141 /** returns whether the node is a root node */
1142 extern
1144  SCIP_BTNODE* node /**< node */
1145  );
1146 
1147 /** returns whether the node is a leaf */
1148 extern
1150  SCIP_BTNODE* node /**< node */
1151  );
1152 
1153 /** returns TRUE if the given node is left child */
1154 extern
1156  SCIP_BTNODE* node /**< node */
1157  );
1158 
1159 /** returns TRUE if the given node is right child */
1160 extern
1162  SCIP_BTNODE* node /**< node */
1163  );
1164 
1165 #ifdef NDEBUG
1166 
1167 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1168  * speed up the algorithms.
1169  */
1170 
1171 #define SCIPbtnodeGetData(node) ((node)->dataptr)
1172 #define SCIPbtnodeGetParent(node) ((node)->parent)
1173 #define SCIPbtnodeGetLeftchild(node) ((node)->left)
1174 #define SCIPbtnodeGetRightchild(node) ((node)->right)
1175 #define SCIPbtnodeGetSibling(node) ((node)->parent == NULL ? NULL : \
1176  (node)->parent->left == (node) ? (node)->parent->right : (node)->parent->left)
1177 #define SCIPbtnodeIsRoot(node) ((node)->parent == NULL)
1178 #define SCIPbtnodeIsLeaf(node) ((node)->left == NULL && (node)->right == NULL)
1179 #define SCIPbtnodeIsLeftchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->left == (node) ? TRUE : FALSE)
1180 #define SCIPbtnodeIsRightchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->right == (node) ? TRUE : FALSE)
1181 
1182 #endif
1183 
1184 /** sets the give node data
1185  *
1186  * @note The old user pointer is not freed.
1187  */
1188 extern
1189 void SCIPbtnodeSetData(
1190  SCIP_BTNODE* node, /**< node */
1191  void* dataptr /**< node user data pointer */
1192  );
1193 
1194 /** sets parent node
1195  *
1196  * @note The old parent including the rooted subtree is not delete.
1197  */
1198 extern
1199 void SCIPbtnodeSetParent(
1200  SCIP_BTNODE* node, /**< node */
1201  SCIP_BTNODE* parent /**< new parent node, or NULL */
1202  );
1203 
1204 /** sets left child
1205  *
1206  * @note The old left child including the rooted subtree is not delete.
1207  */
1208 extern
1210  SCIP_BTNODE* node, /**< node */
1211  SCIP_BTNODE* left /**< new left child, or NULL */
1212  );
1213 
1214 /** sets right child
1215  *
1216  * @note The old right child including the rooted subtree is not delete.
1217  */
1218 extern
1220  SCIP_BTNODE* node, /**< node */
1221  SCIP_BTNODE* right /**< new right child, or NULL */
1222  );
1223 
1224 /** creates an binary tree */
1225 extern
1227  SCIP_BT** tree, /**< pointer to store the created binary tree */
1228  BMS_BLKMEM* blkmem /**< block memory used to create nodes */
1229  );
1230 
1231 /** frees binary tree
1232  *
1233  * @note The user pointers (object) of the search nodes are not freed. If needed, it has to be done by the user.
1234  */
1235 extern
1236 void SCIPbtFree(
1237  SCIP_BT** tree /**< pointer to binary tree */
1238  );
1239 
1240 /** prints the binary tree in GML format into the given file */
1241 extern
1242 void SCIPbtPrintGml(
1243  SCIP_BT* tree, /**< binary tree */
1244  FILE* file /**< file to write to */
1245  );
1246 
1247 /** returns whether the binary tree is empty (has no nodes) */
1248 extern
1250  SCIP_BT * tree /**< binary tree */
1251  );
1252 
1253 /** returns the root node of the binary tree or NULL if the binary tree is empty */
1254 extern
1256  SCIP_BT* tree /**< tree to be evaluated */
1257  );
1258 
1259 #ifdef NDEBUG
1260 
1261 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1262  * speed up the algorithms.
1263  */
1264 
1265 #define SCIPbtIsEmpty(tree) (tree->root == NULL)
1266 #define SCIPbtGetRoot(tree) (tree->root)
1267 
1268 #endif
1269 
1270 /** sets root node
1271  *
1272  * @note The old root including the rooted subtree is not delete.
1273  */
1274 extern
1275 void SCIPbtSetRoot(
1276  SCIP_BT* tree, /**< tree to be evaluated */
1277  SCIP_BTNODE* root /**< new root, or NULL */
1278  );
1279 
1280 /**@} */
1281 
1282 /**@} */
1283 
1284 /*
1285  * Sorting algorithms
1286  */
1287 
1288 /**@defgroup SortingAlgorithms Sorting Algorithms
1289  *
1290  * @{
1291  */
1292 
1293 /** default comparer for integers */
1294 extern
1295 SCIP_DECL_SORTPTRCOMP(SCIPsortCompInt);
1296 
1297 /* first all upwards-sorting methods */
1298 
1299 /** sort an indexed element set in non-decreasing order, resulting in a permutation index array */
1300 extern
1301 void SCIPsort(
1302  int* perm, /**< pointer to store the resulting permutation */
1303  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1304  void* dataptr, /**< pointer to data field that is given to the external compare method */
1305  int len /**< number of elements to be sorted (valid index range) */
1306  );
1307 
1308 /** sort an index array in non-decreasing order */
1309 extern
1310 void SCIPsortInd(
1311  int* indarray, /**< pointer to the index array to be sorted */
1312  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1313  void* dataptr, /**< pointer to data field that is given to the external compare method */
1314  int len /**< length of array */
1315  );
1316 
1317 /** sort of an array of pointers in non-decreasing order */
1318 extern
1319 void SCIPsortPtr(
1320  void** ptrarray, /**< pointer array to be sorted */
1321  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1322  int len /**< length of array */
1323  );
1324 
1325 /** sort of two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
1326 extern
1327 void SCIPsortPtrPtr(
1328  void** ptrarray1, /**< first pointer array to be sorted */
1329  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1330  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1331  int len /**< length of arrays */
1332  );
1333 
1334 /** sort of two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
1335 extern
1336 void SCIPsortPtrReal(
1337  void** ptrarray, /**< pointer array to be sorted */
1338  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1339  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1340  int len /**< length of arrays */
1341  );
1342 
1343 /** sort of two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
1344 extern
1345 void SCIPsortPtrInt(
1346  void** ptrarray, /**< pointer array to be sorted */
1347  int* intarray, /**< int array to be permuted in the same way */
1348  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1349  int len /**< length of arrays */
1350  );
1351 
1352 /** sort of two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
1353 extern
1354 void SCIPsortPtrBool(
1355  void** ptrarray, /**< pointer array to be sorted */
1356  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1357  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1358  int len /**< length of arrays */
1359  );
1360 
1361 
1362 /** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
1363 extern
1364 void SCIPsortPtrIntInt(
1365  void** ptrarray, /**< pointer array to be sorted */
1366  int* intarray1, /**< first int array to be permuted in the same way */
1367  int* intarray2, /**< second int array to be permuted in the same way */
1368  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1369  int len /**< length of arrays */
1370  );
1371 
1372 /** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
1373 extern
1374 void SCIPsortPtrRealInt(
1375  void** ptrarray, /**< pointer array to be sorted */
1376  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1377  int* intarray, /**< int array to be permuted in the same way */
1378  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1379  int len /**< length of arrays */
1380  );
1381 
1382 /** sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order */
1383 extern
1384 void SCIPsortPtrRealBool(
1385  void** ptrarray, /**< pointer array to be sorted */
1386  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1387  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1388  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1389  int len /**< length of arrays */
1390  );
1391 
1392 /** sort of three joint arrays of pointers/Reals/Reals, sorted by first array in non-decreasing order */
1393 extern
1394 void SCIPsortPtrRealReal(
1395  void** ptrarray, /**< pointer array to be sorted */
1396  SCIP_Real* realarray1, /**< first SCIP_Real array to be permuted in the same way */
1397  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1398  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1399  int len /**< length of arrays */
1400  );
1401 
1402 /** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-decreasing order */
1403 extern
1404 void SCIPsortPtrPtrInt(
1405  void** ptrarray1, /**< first pointer array to be sorted */
1406  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1407  int* intarray, /**< int array to be permuted in the same way */
1408  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1409  int len /**< length of arrays */
1410  );
1411 
1412 /** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
1413 extern
1414 void SCIPsortPtrPtrReal(
1415  void** ptrarray1, /**< first pointer array to be sorted */
1416  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1417  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1418  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1419  int len /**< length of arrays */
1420  );
1421 
1422 /** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1423 extern
1425  void** ptrarray1, /**< first pointer array to be sorted */
1426  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1427  int* intarray1, /**< first int array to be permuted in the same way */
1428  int* intarray2, /**< second int array to be permuted in the same way */
1429  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1430  int len /**< length of arrays */
1431  );
1432 
1433 /** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
1434 extern
1436  void** ptrarray, /**< pointer array to be sorted */
1437  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1438  int* intarray1, /**< first int array to be permuted in the same way */
1439  int* intarray2, /**< second int array to be permuted in the same way */
1440  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1441  int len /**< length of arrays */
1442  );
1443 
1444 /** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
1445 extern
1447  void** ptrarray1, /**< first pointer array to be sorted */
1448  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1449  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1450  int* intarray, /**< int array to be permuted in the same way */
1451  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1452  int len /**< length of arrays */
1453  );
1454 
1455 /** sort of four joint arrays of pointer/pointer/Reals/Bools, sorted by first array in non-decreasing order */
1456 extern
1458  void** ptrarray1, /**< first pointer array to be sorted */
1459  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1460  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1461  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1462  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1463  int len /**< length of arrays */
1464  );
1465 
1466 /** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
1467 extern
1469  void** ptrarray1, /**< first pointer array to be sorted */
1470  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1471  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1472  int* intarray, /**< int array to be permuted in the same way */
1473  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1474  int len /**< length of arrays */
1475  );
1476 
1477 /** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
1478 extern
1480  void** ptrarray1, /**< first pointer array to be sorted */
1481  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1482  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1483  int* intarray1, /**< first int array to be permuted in the same way */
1484  int* intarray2, /**< second int array to be permuted in the same way */
1485  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1486  int len /**< length of arrays */
1487  );
1488 
1489 /** sort an array of Reals in non-decreasing order */
1490 extern
1491 void SCIPsortReal(
1492  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1493  int len /**< length of arrays */
1494  );
1495 
1496 /** sort of two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
1497 extern
1498 void SCIPsortRealPtr(
1499  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1500  void** ptrarray, /**< pointer array to be permuted in the same way */
1501  int len /**< length of arrays */
1502  );
1503 
1504 /** sort of two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
1505 extern
1506 void SCIPsortRealInt(
1507  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1508  int* intarray, /**< int array to be permuted in the same way */
1509  int len /**< length of arrays */
1510  );
1511 
1512 /** sort of three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order */
1513 extern
1514 void SCIPsortRealIntInt(
1515  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1516  int* intarray1, /**< int array to be permuted in the same way */
1517  int* intarray2, /**< int array to be permuted in the same way */
1518  int len /**< length of arrays */
1519  );
1520 
1521 /** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-decreasing order */
1522 extern
1523 void SCIPsortRealBoolPtr(
1524  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1525  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1526  void** ptrarray, /**< pointer array to be permuted in the same way */
1527  int len /**< length of arrays */
1528  );
1529 
1530 /** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
1531 extern
1532 void SCIPsortRealIntLong(
1533  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1534  int* intarray, /**< int array to be permuted in the same way */
1535  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1536  int len /**< length of arrays */
1537  );
1538 
1539 /** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
1540 extern
1541 void SCIPsortRealIntPtr(
1542  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1543  int* intarray, /**< int array to be permuted in the same way */
1544  void** ptrarray, /**< pointer array to be permuted in the same way */
1545  int len /**< length of arrays */
1546  );
1547 
1548 /** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
1549 extern
1550 void SCIPsortRealRealPtr(
1551  SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
1552  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1553  void** ptrarray, /**< pointer array to be permuted in the same way */
1554  int len /**< length of arrays */
1555  );
1556 
1557 /** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
1558 extern
1560  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1561  void** ptrarray1, /**< pointer array to be permuted in the same way */
1562  void** ptrarray2, /**< pointer array to be permuted in the same way */
1563  int* intarray, /**< int array to be sorted */
1564  int len /**< length of arrays */
1565  );
1566 
1567 /** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
1568 extern
1570  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
1571  void** ptrarray1, /**< pointer array to be permuted in the same way */
1572  void** ptrarray2, /**< pointer array to be permuted in the same way */
1573  int* intarray1, /**< int array to be sorted */
1574  int* intarray2, /**< int array to be sorted */
1575  int len /**< length of arrays */
1576  );
1577 
1578 /** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-decreasing order */
1579 extern
1581  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1582  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1583  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1584  int* intarray, /**< int array to be permuted in the same way */
1585  int len /**< length of arrays */
1586  );
1587 
1588 /** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
1589 extern
1591  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1592  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1593  int* intarray1, /**< int array to be permuted in the same way */
1594  int* intarray2, /**< int array to be permuted in the same way */
1595  int len /**< length of arrays */
1596  );
1597 
1598 /** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
1599 extern
1601  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1602  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1603  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1604  int* intarray, /**< int array to be permuted in the same way */
1605  int len /**< length of arrays */
1606  );
1607 
1608 /** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
1609 extern
1611  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1612  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1613  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1614  void** ptrarray, /**< pointer array to be permuted in the same way */
1615  int len /**< length of arrays */
1616  );
1617 
1618 /** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
1619 extern
1621  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1622  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1623  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1624  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1625  void** ptrarray, /**< pointer array to be permuted in the same way */
1626  int len /**< length of arrays */
1627  );
1628 
1629 /** sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order */
1630 extern
1632  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
1633  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
1634  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
1635  SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
1636  SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
1637  void** ptrarray, /**< pointer array to be permuted in the same way */
1638  int len /**< length of arrays */
1639  );
1640 
1641 /** sort array of ints in non-decreasing order */
1642 extern
1643 void SCIPsortInt(
1644  int* intarray, /**< int array to be sorted */
1645  int len /**< length of arrays */
1646  );
1647 
1648 /** sort of two joint arrays of ints/ints, sorted by first array in non-decreasing order */
1649 extern
1650 void SCIPsortIntInt(
1651  int* intarray1, /**< int array to be sorted */
1652  int* intarray2, /**< second int array to be permuted in the same way */
1653  int len /**< length of arrays */
1654  );
1655 
1656 /** sort of two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
1657 extern
1658 void SCIPsortIntPtr(
1659  int* intarray, /**< int array to be sorted */
1660  void** ptrarray, /**< pointer array to be permuted in the same way */
1661  int len /**< length of arrays */
1662  );
1663 
1664 /** sort of two joint arrays of ints/reals, sorted by first array in non-decreasing order */
1665 extern
1666 void SCIPsortIntReal(
1667  int* intarray, /**< int array to be sorted */
1668  SCIP_Real* realarray, /**< real array to be permuted in the same way */
1669  int len /**< length of arrays */
1670  );
1671 
1672 /** sort of three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
1673 extern
1674 void SCIPsortIntIntInt(
1675  int* intarray1, /**< int array to be sorted */
1676  int* intarray2, /**< second int array to be permuted in the same way */
1677  int* intarray3, /**< third int array to be permuted in the same way */
1678  int len /**< length of arrays */
1679  );
1680 
1681 /** sort of three joint arrays of ints/ints/Longints, sorted by first array in non-decreasing order */
1682 extern
1683 void SCIPsortIntIntLong(
1684  int* intarray1, /**< int array to be sorted */
1685  int* intarray2, /**< second int array to be permuted in the same way */
1686  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
1687  int len /**< length of arrays */
1688  );
1689 
1690 /** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
1691 extern
1692 void SCIPsortIntIntPtr(
1693  int* intarray1, /**< int array to be sorted */
1694  int* intarray2, /**< second int array to be permuted in the same way */
1695  void** ptrarray, /**< pointer array to be permuted in the same way */
1696  int len /**< length of arrays */
1697  );
1698 
1699 /** sort of three joint arrays of ints/ints/reals, sorted by first array in non-decreasing order */
1700 extern
1701 void SCIPsortIntIntReal(
1702  int* intarray1, /**< int array to be sorted */
1703  int* intarray2, /**< second int array to be permuted in the same way */
1704  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1705  int len /**< length of arrays */
1706  );
1707 
1708 /** sort of three joint arrays of ints/pointers/reals, sorted by first array in non-decreasing order */
1709 extern
1710 void SCIPsortIntPtrReal(
1711  int* intarray, /**< int array to be sorted */
1712  void** ptrarray, /**< pointer array to be permuted in the same way */
1713  SCIP_Real* realarray, /**< real array to be permuted in the same way */
1714  int len /**< length of arrays */
1715  );
1716 
1717 /** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
1718 extern
1720  int* intarray1, /**< int array to be sorted */
1721  int* intarray2, /**< int array to be permuted in the same way */
1722  int* intarray3, /**< int array to be permuted in the same way */
1723  void** ptrarray, /**< pointer array to be permuted in the same way */
1724  int len /**< length of arrays */
1725  );
1726 
1727 /** sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
1728 extern
1730  int* intarray1, /**< int array to be sorted */
1731  int* intarray2, /**< int array to be permuted in the same way */
1732  int* intarray3, /**< int array to be permuted in the same way */
1733  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1734  int len /**< length of arrays */
1735  );
1736 
1737 /** sort of four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order */
1738 extern
1740  int* intarray1, /**< int array to be sorted */
1741  void** ptrarray, /**< pointer array to be permuted in the same way */
1742  int* intarray2, /**< int array to be permuted in the same way */
1743  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1744  int len /**< length of arrays */
1745  );
1746 
1747 /** sort an array of Longints in non-decreasing order */
1748 extern
1749 void SCIPsortLong(
1750  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1751  int len /**< length of arrays */
1752  );
1753 
1754 /** sort of two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
1755 extern
1756 void SCIPsortLongPtr(
1757  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1758  void** ptrarray, /**< pointer array to be permuted in the same way */
1759  int len /**< length of arrays */
1760  );
1761 
1762 /** sort of three arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
1763 extern
1764 void SCIPsortLongPtrInt(
1765  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1766  void** ptrarray, /**< pointer array to be permuted in the same way */
1767  int* intarray, /**< int array to be permuted in the same way */
1768  int len /**< length of arrays */
1769  );
1770 
1771 /** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
1772 extern
1774  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1775  void** ptrarray, /**< pointer array to be permuted in the same way */
1776  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1777  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1778  int len /**< length of arrays */
1779  );
1780 
1781 /** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
1782 extern
1784  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1785  void** ptrarray, /**< pointer array to be permuted in the same way */
1786  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
1787  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1788  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1789  int len /**< length of arrays */
1790  );
1791 
1792 /** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
1793 extern
1795  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1796  void** ptrarray, /**< pointer array to be permuted in the same way */
1797  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
1798  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
1799  int* intarray, /**< int array to be permuted in the same way */
1800  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1801  int len /**< length of arrays */
1802  );
1803 
1804 /** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
1805 extern
1807  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1808  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1809  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1810  int* intarray, /**< int array to be permuted in the same way */
1811  int len /**< length of arrays */
1812  );
1813 
1814 /** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
1815 extern
1817  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1818  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1819  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1820  int* intarray1, /**< first int array to be permuted in the same way */
1821  int* intarray2, /**< second int array to be permuted in the same way */
1822  int len /**< length of arrays */
1823  );
1824 
1825 /** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
1826 extern
1828  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
1829  void** ptrarray1, /**< first pointer array to be permuted in the same way */
1830  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1831  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1832  int* intarray, /**< int array to be sorted */
1833  int len /**< length of arrays */
1834  );
1835 
1836 /** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
1837 extern
1839  void** ptrarray, /**< pointer array to be sorted */
1840  int* intarray1, /**< first int array to be permuted in the same way */
1841  int* intarray2, /**< second int array to be permuted in the same way */
1842  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
1843  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
1844  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1845  int len /**< length of arrays */
1846  );
1847 
1848 /** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
1849 extern
1851  int* intarray1, /**< int array to be sorted */
1852  void** ptrarray, /**< pointer array to be permuted in the same way */
1853  int* intarray2, /**< second int array to be permuted in the same way */
1854  int* intarray3, /**< thrid int array to be permuted in the same way */
1855  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
1856  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
1857  int len /**< length of arrays */
1858  );
1859 
1860 /* now all downwards-sorting methods */
1861 
1862 /** sort an indexed element set in non-increasing order, resulting in a permutation index array */
1863 extern
1864 void SCIPsortDown(
1865  int* perm, /**< pointer to store the resulting permutation */
1866  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1867  void* dataptr, /**< pointer to data field that is given to the external compare method */
1868  int len /**< number of elements to be sorted (valid index range) */
1869  );
1870 
1871 /** sort an index array in non-increasing order */
1872 extern
1873 void SCIPsortDownInd(
1874  int* indarray, /**< pointer to the index array to be sorted */
1875  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
1876  void* dataptr, /**< pointer to data field that is given to the external compare method */
1877  int len /**< length of array */
1878  );
1879 
1880 /** sort of an array of pointers in non-increasing order */
1881 extern
1882 void SCIPsortDownPtr(
1883  void** ptrarray, /**< pointer array to be sorted */
1884  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1885  int len /**< length of array */
1886  );
1887 
1888 /** sort of two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
1889 extern
1890 void SCIPsortDownPtrPtr(
1891  void** ptrarray1, /**< first pointer array to be sorted */
1892  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1893  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1894  int len /**< length of arrays */
1895  );
1896 
1897 /** sort of two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
1898 extern
1899 void SCIPsortDownPtrReal(
1900  void** ptrarray, /**< pointer array to be sorted */
1901  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1902  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1903  int len /**< length of arrays */
1904  );
1905 
1906 /** sort of two joint arrays of pointers/ints, sorted by first array in non-increasing order */
1907 extern
1908 void SCIPsortDownPtrInt(
1909  void** ptrarray, /**< pointer array to be sorted */
1910  int* intarray, /**< int array to be permuted in the same way */
1911  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1912  int len /**< length of arrays */
1913  );
1914 
1915 /** sort of two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
1916 extern
1917 void SCIPsortDownPtrBool(
1918  void** ptrarray, /**< pointer array to be sorted */
1919  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1920  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1921  int len /**< length of arrays */
1922  );
1923 
1924 /** sort of three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
1925 extern
1927  void** ptrarray, /**< pointer array to be sorted */
1928  int* intarray1, /**< first int array to be permuted in the same way */
1929  int* intarray2, /**< second int array to be permuted in the same way */
1930  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1931  int len /**< length of arrays */
1932  );
1933 
1934 /** sort of three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
1935 extern
1937  void** ptrarray, /**< pointer array to be sorted */
1938  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1939  int* intarray, /**< int array to be permuted in the same way */
1940  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1941  int len /**< length of arrays */
1942  );
1943 
1944 /** sort of three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order */
1945 extern
1947  void** ptrarray, /**< pointer array to be sorted */
1948  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1949  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
1950  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1951  int len /**< length of arrays */
1952  );
1953 
1954 /** sort of three joint arrays of pointers/pointers/ints, sorted by first array in non-increasing order */
1955 extern
1957  void** ptrarray1, /**< first pointer array to be sorted */
1958  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1959  int* intarray, /**< int array to be permuted in the same way */
1960  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1961  int len /**< length of arrays */
1962  );
1963 
1964 /** sort of three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
1965 extern
1967  void** ptrarray1, /**< first pointer array to be sorted */
1968  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1969  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1970  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1971  int len /**< length of arrays */
1972  );
1973 
1974 /** sort of four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
1975 extern
1977  void** ptrarray1, /**< first pointer array to be sorted */
1978  void** ptrarray2, /**< second pointer array to be permuted in the same way */
1979  int* intarray1, /**< first int array to be permuted in the same way */
1980  int* intarray2, /**< second int array to be permuted in the same way */
1981  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1982  int len /**< length of arrays */
1983  );
1984 
1985 /** sort of four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
1986 extern
1988  void** ptrarray, /**< pointer array to be sorted */
1989  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
1990  int* intarray1, /**< first int array to be permuted in the same way */
1991  int* intarray2, /**< second int array to be permuted in the same way */
1992  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
1993  int len /**< length of arrays */
1994  );
1995 
1996 /** sort of four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
1997 extern
1999  void** ptrarray1, /**< first pointer array to be sorted */
2000  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2001  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2002  int* intarray, /**< int array to be permuted in the same way */
2003  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2004  int len /**< length of arrays */
2005  );
2006 
2007 /** sort of four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order */
2008 extern
2010  void** ptrarray1, /**< first pointer array to be sorted */
2011  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2012  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2013  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2014  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2015  int len /**< length of arrays */
2016  );
2017 
2018 /** sort of four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
2019 extern
2021  void** ptrarray1, /**< first pointer array to be sorted */
2022  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2023  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2024  int* intarray, /**< int array to be permuted in the same way */
2025  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2026  int len /**< length of arrays */
2027  );
2028 
2029 /** sort of five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
2030 extern
2032  void** ptrarray1, /**< first pointer array to be sorted */
2033  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2034  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2035  int* intarray1, /**< first int array to be permuted in the same way */
2036  int* intarray2, /**< second int array to be permuted in the same way */
2037  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2038  int len /**< length of arrays */
2039  );
2040 
2041 /** sort an array of Reals in non-increasing order */
2042 extern
2043 void SCIPsortDownReal(
2044  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2045  int len /**< length of arrays */
2046  );
2047 
2048 /** sort of two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
2049 extern
2050 void SCIPsortDownRealPtr(
2051  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2052  void** ptrarray, /**< pointer array to be permuted in the same way */
2053  int len /**< length of arrays */
2054  );
2055 
2056 /** sort of two joint arrays of Reals/ints, sorted by first array in non-increasing order */
2057 extern
2058 void SCIPsortDownRealInt(
2059  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2060  int* intarray, /**< pointer array to be permuted in the same way */
2061  int len /**< length of arrays */
2062  );
2063 
2064 /** sort of three joint arrays of Reals/Bools/Pointer, sorted by first array in non-increasing order */
2065 extern
2067  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2068  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2069  void** ptrarray, /**< pointer array to be permuted in the same way */
2070  int len /**< length of arrays */
2071  );
2072 
2073 /** sort of three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
2074 extern
2076  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2077  int* intarray, /**< int array to be permuted in the same way */
2078  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2079  int len /**< length of arrays */
2080  );
2081 
2082 /** sort of three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
2083 extern
2085  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2086  int* intarray, /**< int array to be permuted in the same way */
2087  void** ptrarray, /**< pointer array to be permuted in the same way */
2088  int len /**< length of arrays */
2089  );
2090 
2091 /** sort of three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
2092 extern
2094  SCIP_Real* realarray1, /**< first SCIP_Real array to be sorted */
2095  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2096  void** ptrarray, /**< pointer array to be permuted in the same way */
2097  int len /**< length of arrays */
2098  );
2099 
2100 /** sort of four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
2101 extern
2103  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2104  void** ptrarray1, /**< pointer array to be permuted in the same way */
2105  void** ptrarray2, /**< pointer array to be permuted in the same way */
2106  int* intarray, /**< int array to be sorted */
2107  int len /**< length of arrays */
2108  );
2109 
2110 /** sort of five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
2111 extern
2113  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2114  void** ptrarray1, /**< pointer array to be permuted in the same way */
2115  void** ptrarray2, /**< pointer array to be permuted in the same way */
2116  int* intarray1, /**< int array to be sorted */
2117  int* intarray2, /**< int array to be sorted */
2118  int len /**< length of arrays */
2119  );
2120 
2121 /** sort of four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
2122 extern
2124  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2125  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2126  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2127  int* intarray, /**< int array to be permuted in the same way */
2128  int len /**< length of arrays */
2129  );
2130 
2131 /** sort of four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
2132 extern
2134  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2135  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2136  int* intarray1, /**< int array to be permuted in the same way */
2137  int* intarray2, /**< int array to be permuted in the same way */
2138  int len /**< length of arrays */
2139  );
2140 
2141 
2142 /** sort of four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
2143 extern
2145  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2146  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2147  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2148  int* intarray, /**< int array to be permuted in the same way */
2149  int len /**< length of arrays */
2150  );
2151 
2152 /** sort of four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
2153 extern
2155  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2156  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2157  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2158  void** ptrarray, /**< pointer array to be permuted in the same way */
2159  int len /**< length of arrays */
2160  );
2161 
2162 /** sort of three joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
2163 extern
2165  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2166  void** ptrarray1, /**< pointer array to be permuted in the same way */
2167  void** ptrarray2, /**< pointer array to be permuted in the same way */
2168  int len /**< length of arrays */
2169  );
2170 
2171 /** sort of five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
2172 extern
2174  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2175  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2176  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2177  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2178  void** ptrarray, /**< pointer array to be permuted in the same way */
2179  int len /**< length of arrays */
2180  );
2181 
2182 /** sort of six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order */
2183 extern
2185  SCIP_Real* realarray1, /**< SCIP_Real array to be sorted */
2186  SCIP_Real* realarray2, /**< SCIP_Real array to be permuted in the same way */
2187  SCIP_Real* realarray3, /**< SCIP_Real array to be permuted in the same way */
2188  SCIP_Bool* boolarray1, /**< SCIP_Bool array to be permuted in the same way */
2189  SCIP_Bool* boolarray2, /**< SCIP_Bool array to be permuted in the same way */
2190  void** ptrarray, /**< pointer array to be permuted in the same way */
2191  int len /**< length of arrays */
2192  );
2193 
2194 /** sort array of ints in non-increasing order */
2195 extern
2196 void SCIPsortDownInt(
2197  int* intarray, /**< int array to be sorted */
2198  int len /**< length of arrays */
2199  );
2200 
2201 /** sort of two joint arrays of ints/ints, sorted by first array in non-increasing order */
2202 extern
2203 void SCIPsortDownIntInt(
2204  int* intarray1, /**< int array to be sorted */
2205  int* intarray2, /**< second int array to be permuted in the same way */
2206  int len /**< length of arrays */
2207  );
2208 
2209 /** sort of two joint arrays of ints/pointers, sorted by first array in non-increasing order */
2210 extern
2211 void SCIPsortDownIntPtr(
2212  int* intarray, /**< int array to be sorted */
2213  void** ptrarray, /**< pointer array to be permuted in the same way */
2214  int len /**< length of arrays */
2215  );
2216 
2217 /** sort of two joint arrays of ints/reals, sorted by first array in non-increasing order */
2218 extern
2219 void SCIPsortDownIntReal(
2220  int* intarray, /**< int array to be sorted */
2221  SCIP_Real* realarray, /**< real array to be permuted in the same way */
2222  int len /**< length of arrays */
2223  );
2224 
2225 /** sort of three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
2226 extern
2228  int* intarray1, /**< int array to be sorted */
2229  int* intarray2, /**< second int array to be permuted in the same way */
2230  int* intarray3, /**< third int array to be permuted in the same way */
2231  int len /**< length of arrays */
2232  );
2233 
2234 /** sort of three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
2235 extern
2237  int* intarray1, /**< int array to be sorted */
2238  int* intarray2, /**< second int array to be permuted in the same way */
2239  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2240  int len /**< length of arrays */
2241  );
2242 
2243 /** sort of three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
2244 extern
2246  int* intarray1, /**< int array to be sorted */
2247  int* intarray2, /**< second int array to be permuted in the same way */
2248  void** ptrarray, /**< pointer array to be permuted in the same way */
2249  int len /**< length of arrays */
2250  );
2251 
2252 /** sort of three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
2253 extern
2255  int* intarray1, /**< int array to be sorted */
2256  int* intarray2, /**< second int array to be permuted in the same way */
2257  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2258  int len /**< length of arrays */
2259  );
2260 
2261 /** sort of four joint arrays of ints/ints/ints/pointers, sorted by first array in non-increasing order */
2262 extern
2264  int* intarray1, /**< int array to be sorted */
2265  int* intarray2, /**< int array to be permuted in the same way */
2266  int* intarray3, /**< int array to be permuted in the same way */
2267  void** ptrarray, /**< pointer array to be permuted in the same way */
2268  int len /**< length of arrays */
2269  );
2270 
2271 /** sort of four joint arrays of ints/ints/ints/reals, sorted by first array in non-increasing order */
2272 extern
2274  int* intarray1, /**< int array to be sorted */
2275  int* intarray2, /**< int array to be permuted in the same way */
2276  int* intarray3, /**< int array to be permuted in the same way */
2277  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2278  int len /**< length of arrays */
2279  );
2280 
2281 /** sort of four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
2282 extern
2284  int* intarray1, /**< int array to be sorted */
2285  void** ptrarray, /**< pointer array to be permuted in the same way */
2286  int* intarray2, /**< int array to be permuted in the same way */
2287  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2288  int len /**< length of arrays */
2289  );
2290 
2291 /** sort an array of Longints in non-increasing order */
2292 extern
2293 void SCIPsortDownLong(
2294  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2295  int len /**< length of arrays */
2296  );
2297 
2298 /** sort of two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
2299 extern
2300 void SCIPsortDownLongPtr(
2301  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2302  void** ptrarray, /**< pointer array to be permuted in the same way */
2303  int len /**< length of arrays */
2304  );
2305 
2306 /** sort of three arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
2307 extern
2309  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2310  void** ptrarray, /**< pointer array to be permuted in the same way */
2311  int* intarray, /**< int array to be permuted in the same way */
2312  int len /**< length of arrays */
2313  );
2314 
2315 /** sort of four arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
2316 extern
2318  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2319  void** ptrarray, /**< pointer array to be permuted in the same way */
2320  SCIP_Real* realarray, /**< SCIP_Real array to be permuted in the same way */
2321  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2322  int len /**< length of arrays */
2323  );
2324 
2325 /** sort of five arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
2326 extern
2328  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2329  void** ptrarray, /**< pointer array to be permuted in the same way */
2330  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
2331  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2332  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2333  int len /**< length of arrays */
2334  );
2335 
2336 /** sort of six arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
2337 extern
2339  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2340  void** ptrarray, /**< pointer array to be permuted in the same way */
2341  SCIP_Real* realarray, /**< first SCIP_Real array to be permuted in the same way */
2342  SCIP_Real* realarray2, /**< second SCIP_Real array to be permuted in the same way */
2343  int* intarray, /**< int array to be permuted in the same way */
2344  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2345  int len /**< length of arrays */
2346  );
2347 
2348 /** sort of four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
2349 extern
2351  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2352  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2353  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2354  int* intarray, /**< int array to be permuted in the same way */
2355  int len /**< length of arrays */
2356  );
2357 
2358 /** sort of five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
2359 extern
2361  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2362  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2363  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2364  int* intarray1, /**< first int array to be permuted in the same way */
2365  int* intarray2, /**< second int array to be permuted in the same way */
2366  int len /**< length of arrays */
2367  );
2368 
2369 /** sort of five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
2370 extern
2372  SCIP_Longint* longarray, /**< SCIP_Longint array to be sorted */
2373  void** ptrarray1, /**< first pointer array to be permuted in the same way */
2374  void** ptrarray2, /**< second pointer array to be permuted in the same way */
2375  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2376  int* intarray, /**< int array to be sorted */
2377  int len /**< length of arrays */
2378  );
2379 
2380 /** sort of five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2381 extern
2383  void** ptrarray, /**< pointer array to be sorted */
2384  int* intarray1, /**< first int array to be permuted in the same way */
2385  int* intarray2, /**< second int array to be permuted in the same way */
2386  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2387  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2388  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2389  int len /**< length of arrays */
2390  );
2391 
2392 /** sort of six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
2393 extern
2395  int* intarray1, /**< int array to be sorted */
2396  void** ptrarray, /**< pointer array to be permuted in the same way */
2397  int* intarray2, /**< second int array to be permuted in the same way */
2398  int* intarray3, /**< thrid int array to be permuted in the same way */
2399  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
2400  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
2401  int len /**< length of arrays */
2402  );
2403 
2404 /*
2405  * Sorted vectors
2406  */
2407 
2408 /* upwards insertion */
2409 
2410 /** insert a new element into an index array in non-decreasing order */
2411 extern
2413  int* indarray, /**< pointer to the index array where an element is to be inserted */
2414  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
2415  void* dataptr, /**< pointer to data field that is given to the external compare method */
2416  int keyval, /**< key value of new element */
2417  int* len, /**< pointer to length of arrays (will be increased by 1) */
2418  int* pos /**< pointer to store the insertion position, or NULL */
2419  );
2420 
2421 /** insert a new element into an array of pointers in non-decreasing order */
2422 extern
2424  void** ptrarray, /**< pointer to the pointer array where an element is to be inserted */
2425  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2426  void* keyval, /**< key value of new element */
2427  int* len, /**< pointer to length of arrays (will be increased by 1) */
2428  int* pos /**< pointer to store the insertion position, or NULL */
2429  );
2430 
2431 /** insert a new element into two joint arrays of pointers/pointers sorted by first array in non-decreasing order */
2432 extern
2434  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2435  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2436  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2437  void* keyval, /**< key value of new element */
2438  void* field1val, /**< additional value of new element */
2439  int* len, /**< pointer to length of arrays (will be increased by 1) */
2440  int* pos /**< pointer to store the insertion position, or NULL */
2441  );
2442 
2443 /** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
2444 extern
2446  void** ptrarray, /**< pointer array where an element is to be inserted */
2447  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2448  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2449  void* keyval, /**< key value of new element */
2450  SCIP_Real field1val, /**< additional value of new element */
2451  int* len, /**< pointer to length of arrays (will be increased by 1) */
2452  int* pos /**< pointer to store the insertion position, or NULL */
2453  );
2454 
2455 /** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
2456 extern
2458  void** ptrarray, /**< pointer array where an element is to be inserted */
2459  int* intarray, /**< int array where an element is to be inserted */
2460  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2461  void* keyval, /**< key value of new element */
2462  int field1val, /**< additional value of new element */
2463  int* len, /**< pointer to length of arrays (will be increased by 1) */
2464  int* pos /**< pointer to store the insertion position, or NULL */
2465  );
2466 
2467 /** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
2468 extern
2470  void** ptrarray, /**< pointer array where an element is to be inserted */
2471  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2472  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2473  void* keyval, /**< key value of new element */
2474  SCIP_Bool field1val, /**< additional value of new element */
2475  int* len, /**< pointer to length of arrays (will be increased by 1) */
2476  int* pos /**< pointer to store the insertion position, or NULL */
2477  );
2478 
2479 /** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
2480 extern
2482  void** ptrarray, /**< pointer array where an element is to be inserted */
2483  int* intarray1, /**< first int array where an element is to be inserted */
2484  int* intarray2, /**< second int array where an element is to be inserted */
2485  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2486  void* keyval, /**< key value of new element */
2487  int field1val, /**< additional value of new element */
2488  int field2val, /**< additional value of new element */
2489  int* len, /**< pointer to length of arrays (will be increased by 1) */
2490  int* pos /**< pointer to store the insertion position, or NULL */
2491  );
2492 
2493 /** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
2494 extern
2496  void** ptrarray, /**< pointer array where an element is to be inserted */
2497  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2498  int* intarray, /**< int array where an element is to be inserted */
2499  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2500  void* keyval, /**< key value of new element */
2501  SCIP_Real field1val, /**< additional value of new element */
2502  int field2val, /**< additional value of new element */
2503  int* len, /**< pointer to length of arrays (will be increased by 1) */
2504  int* pos /**< pointer to store the insertion position, or NULL */
2505  );
2506 
2507 /** insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order */
2508 extern
2510  void** ptrarray, /**< pointer array where an element is to be inserted */
2511  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2512  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2513  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2514  void* keyval, /**< key value of new element */
2515  SCIP_Real field1val, /**< additional value of new element */
2516  SCIP_Bool field2val, /**< additional value of new element */
2517  int* len, /**< pointer to length of arrays (will be increased by 1) */
2518  int* pos /**< pointer to store the insertion position, or NULL */
2519  );
2520 
2521 /** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
2522 extern
2524  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2525  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2526  int* intarray, /**< int array where an element is to be inserted */
2527  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2528  void* keyval, /**< key value of new element */
2529  void* field1val, /**< additional value of new element */
2530  int field2val, /**< additional value of new element */
2531  int* len, /**< pointer to length of arrays (will be increased by 1) */
2532  int* pos /**< pointer to store the insertion position, or NULL */
2533  );
2534 
2535 /** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
2536 extern
2538  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2539  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2540  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2541  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2542  void* keyval, /**< key value of new element */
2543  void* field1val, /**< additional value of new element */
2544  SCIP_Real field2val, /**< additional value of new element */
2545  int* len, /**< pointer to length of arrays (will be increased by 1) */
2546  int* pos /**< pointer to store the insertion position, or NULL */
2547  );
2548 
2549 /** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
2550 extern
2552  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2553  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2554  int* intarray1, /**< first int array where an element is to be inserted */
2555  int* intarray2, /**< second int array where an element is to be inserted */
2556  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2557  void* keyval, /**< key value of new element */
2558  void* field1val, /**< additional value of new element */
2559  int field2val, /**< additional value of new element */
2560  int field3val, /**< additional value of new element */
2561  int* len, /**< pointer to length of arrays (will be increased by 1) */
2562  int* pos /**< pointer to store the insertion position, or NULL */
2563  );
2564 
2565 /** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
2566 extern
2568  void** ptrarray, /**< pointer array where an element is to be inserted */
2569  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2570  int* intarray1, /**< first int array where an element is to be inserted */
2571  int* intarray2, /**< second int array where an element is to be inserted */
2572  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2573  void* keyval, /**< key value of new element */
2574  SCIP_Real field1val, /**< additional value of new element */
2575  int field2val, /**< additional value of new element */
2576  int field3val, /**< additional value of new element */
2577  int* len, /**< pointer to length of arrays (will be increased by 1) */
2578  int* pos /**< pointer to store the insertion position, or NULL */
2579  );
2580 
2581 /** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
2582 extern
2584  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2585  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2586  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2587  int* intarray, /**< int array where an element is to be inserted */
2588  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2589  void* keyval, /**< key value of new element */
2590  void* field1val, /**< additional value of new element */
2591  SCIP_Real field2val, /**< additional value of new element */
2592  int field3val, /**< additional value of new element */
2593  int* len, /**< pointer to length of arrays (will be increased by 1) */
2594  int* pos /**< pointer to store the insertion position, or NULL */
2595  );
2596 
2597 /** insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order */
2598 extern
2600  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2601  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2602  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2603  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2604  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2605  void* keyval, /**< key value of new element */
2606  void* field1val, /**< additional value of new element */
2607  SCIP_Real field2val, /**< additional value of new element */
2608  SCIP_Bool field3val, /**< additional value of new element */
2609  int* len, /**< pointer to length of arrays (will be increased by 1) */
2610  int* pos /**< pointer to store the insertion position, or NULL */
2611  );
2612 
2613 /** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
2614 extern
2616  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2617  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2618  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2619  int* intarray, /**< int array to be sorted */
2620  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2621  void* keyval, /**< key value of new element */
2622  void* field1val, /**< additional value of new element */
2623  SCIP_Longint field2val, /**< additional value of new element */
2624  int field3val, /**< additional value of new element */
2625  int* len, /**< pointer to length of arrays (will be increased by 1) */
2626  int* pos /**< pointer to store the insertion position, or NULL */
2627  );
2628 
2629 /** insert a new element into five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-decreasing order */
2630 extern
2632  void** ptrarray1, /**< first pointer array where an element is to be inserted */
2633  void** ptrarray2, /**< second pointer array where an element is to be inserted */
2634  SCIP_Longint* longarray, /**< SCIP_Longint where an element is to be inserted */
2635  int* intarray1, /**< first int array where an element is to be inserted */
2636  int* intarray2, /**< second int array where an element is to be inserted */
2637  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
2638  void* keyval, /**< key value of new element */
2639  void* field1val, /**< additional value of new element */
2640  SCIP_Longint field2val, /**< additional value of new element */
2641  int field3val, /**< additional value of new element */
2642  int field4val, /**< additional value of new element */
2643  int* len, /**< pointer to length of arrays (will be increased by 1) */
2644  int* pos /**< pointer to store the insertion position, or NULL */
2645  );
2646 
2647 /** insert a new element into three joint arrays of Reals/ints/ints, sorted by first array in non-decreasing order */
2648 extern
2650  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2651  int* intarray1, /**< first int array where an element is to be inserted */
2652  int* intarray2, /**< second int array where an element is to be inserted */
2653  SCIP_Real keyval, /**< key value of new element */
2654  int field2val, /**< additional value of new element */
2655  int field3val, /**< additional value of new element */
2656  int* len, /**< pointer to length of arrays (will be increased by 1) */
2657  int* pos /**< pointer to store the insertion position, or NULL */
2658  );
2659 
2660 /** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
2661 extern
2663  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2664  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
2665  void** ptrarray, /**< pointer array to be permuted in the same way */
2666  SCIP_Real keyval, /**< key value of new element */
2667  SCIP_Bool field1val, /**< additional value of new element */
2668  void* field2val, /**< additional value of new element */
2669  int* len, /**< pointer to length of arrays (will be increased by 1) */
2670  int* pos /**< pointer to store the insertion position, or NULL */
2671  );
2672 
2673 /** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
2674 extern
2676  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2677  void** ptrarray, /**< pointer array where an element is to be inserted */
2678  SCIP_Real keyval, /**< key value of new element */
2679  void* field1val, /**< additional value of new element */
2680  int* len, /**< pointer to length of arrays (will be increased by 1) */
2681  int* pos /**< pointer to store the insertion position, or NULL */
2682  );
2683 
2684 /** insert a new element into an arrays of Reals, sorted in non-decreasing order */
2685 extern
2687  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2688  SCIP_Real keyval, /**< key value of new element */
2689  int* len, /**< pointer to length of arrays (will be increased by 1) */
2690  int* pos /**< pointer to store the insertion position, or NULL */
2691  );
2692 
2693 /** insert a new element into two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
2694 extern
2696  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2697  int* intarray, /**< int array where an element is to be inserted */
2698  SCIP_Real keyval, /**< key value of new element */
2699  int field1val, /**< additional value of new element */
2700  int* len, /**< pointer to length of arrays (will be increased by 1) */
2701  int* pos /**< pointer to store the insertion position, or NULL */
2702  );
2703 
2704 /** insert a new element into three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
2705 extern
2707  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
2708  int* intarray, /**< int array to be permuted in the same way */
2709  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
2710  SCIP_Real keyval, /**< key value of new element */
2711  int field1val, /**< additional value of new element */
2712  SCIP_Longint field2val, /**< additional value of new element */
2713  int* len, /**< pointer to length of arrays (will be increased by 1) */
2714  int* pos /**< pointer to store the insertion position, or NULL */
2715  );
2716 
2717 /** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
2718 extern
2720  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
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 keyval, /**< key value of new element */
2724  int field1val, /**< additional value of new element */
2725  void* field2val, /**< additional value of new element */
2726  int* len, /**< pointer to length of arrays (will be increased by 1) */
2727  int* pos /**< pointer to store the insertion position, or NULL */
2728  );
2729 
2730 /** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
2731 extern
2733  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2734  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2735  void** ptrarray, /**< pointer array where an element is to be inserted */
2736  SCIP_Real keyval, /**< key value of new element */
2737  SCIP_Real field1val, /**< additional value of new element */
2738  void* field2val, /**< additional value of new element */
2739  int* len, /**< pointer to length of arrays (will be increased by 1) */
2740  int* pos /**< pointer to store the insertion position, or NULL */
2741  );
2742 
2743 /** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
2744 extern
2746  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2747  void** ptrarray1, /**< pointer array where an element is to be inserted */
2748  void** ptrarray2, /**< pointer array where an element is to be inserted */
2749  int* intarray, /**< int array where an element is to be inserted */
2750  SCIP_Real keyval, /**< key value of new element */
2751  void* field1val, /**< additional value of new element */
2752  void* field2val, /**< additional value of new element */
2753  int intval, /**< additional value of new element */
2754  int* len, /**< pointer to length of arrays (will be increased by 1) */
2755  int* pos /**< pointer to store the insertion position, or NULL */
2756  );
2757 
2758 /** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
2759 extern
2761  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2762  void** ptrarray1, /**< pointer array where an element is to be inserted */
2763  void** ptrarray2, /**< pointer array where an element is to be inserted */
2764  int* intarray1, /**< int array where an element is to be inserted */
2765  int* intarray2, /**< int array where an element is to be inserted */
2766  SCIP_Real keyval, /**< key value of new element */
2767  void* field1val, /**< additional value of new element */
2768  void* field2val, /**< additional value of new element */
2769  int intval1, /**< additional value of new element */
2770  int intval2, /**< additional value of new element */
2771  int* len, /**< pointer to length of arrays (will be increased by 1) */
2772  int* pos /**< pointer to store the insertion position, or NULL */
2773  );
2774 
2775 /** insert a new element into four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
2776 extern
2778  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
2779  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2780  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
2781  int* intarray, /**< int array where an element is to be inserted */
2782  SCIP_Real keyval, /**< key value of new element */
2783  SCIP_Longint field1val, /**< additional value of new element */
2784  SCIP_Real field2val, /**< additional value of new element */
2785  int field3val, /**< additional value of new element */
2786  int* len, /**< pointer to length of arrays (will be increased by 1) */
2787  int* pos /**< pointer to store the insertion position, or NULL */
2788  );
2789 
2790 /** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
2791 extern
2793  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2794  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2795  int* intarray1, /**< first int array where an element is to be inserted */
2796  int* intarray2, /**< second int array where an element is to be inserted */
2797  SCIP_Real keyval, /**< key value of new element */
2798  SCIP_Real field1val, /**< additional value of new element */
2799  int field2val, /**< additional value of new element */
2800  int field3val, /**< additional value of new element */
2801  int* len, /**< pointer to length of arrays (will be increased by 1) */
2802  int* pos /**< pointer to store the insertion position, or NULL */
2803  );
2804 
2805 /** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
2806 extern
2808  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2809  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2810  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2811  int* intarray, /**< int array where an element is to be inserted */
2812  SCIP_Real keyval, /**< key value of new element */
2813  SCIP_Real field1val, /**< additional value of new element */
2814  SCIP_Real field2val, /**< additional value of new element */
2815  int field3val, /**< additional value of new element */
2816  int* len, /**< pointer to length of arrays (will be increased by 1) */
2817  int* pos /**< pointer to store the insertion position, or NULL */
2818  );
2819 
2820 /** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
2821 extern
2823  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2824  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2825  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2826  void** ptrarray, /**< pointer array where an element is to be inserted */
2827  SCIP_Real keyval, /**< key value of new element */
2828  SCIP_Real field1val, /**< additional value of new element */
2829  SCIP_Real field2val, /**< additional value of new element */
2830  void* field3val, /**< additional value of new element */
2831  int* len, /**< pointer to length of arrays (will be increased by 1) */
2832  int* pos /**< pointer to store the insertion position, or NULL */
2833  );
2834 
2835 /** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-decreasing order */
2836 extern
2838  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2839  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2840  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2841  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
2842  void** ptrarray, /**< pointer array where an element is to be inserted */
2843  SCIP_Real keyval, /**< key value of new element */
2844  SCIP_Real field1val, /**< additional value of new element */
2845  SCIP_Real field2val, /**< additional value of new element */
2846  SCIP_Bool field3val, /**< additional value of new element */
2847  void* field4val, /**< additional value of new element */
2848  int* len, /**< pointer to length of arrays (will be increased by 1) */
2849  int* pos /**< pointer to store the insertion position, or NULL */
2850  );
2851 
2852 /** insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order */
2853 extern
2855  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
2856  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
2857  SCIP_Real* realarray3, /**< third SCIP_Real array where an element is to be inserted */
2858  SCIP_Bool* boolarray1, /**< SCIP_Bool array where an element is to be inserted */
2859  SCIP_Bool* boolarray2, /**< SCIP_Bool array where an element is to be inserted */
2860  void** ptrarray, /**< pointer array where an element is to be inserted */
2861  SCIP_Real keyval, /**< key value of new element */
2862  SCIP_Real field1val, /**< additional value of new element */
2863  SCIP_Real field2val, /**< additional value of new element */
2864  SCIP_Bool field3val, /**< additional value of new element */
2865  SCIP_Bool field4val, /**< additional value of new element */
2866  void* field5val, /**< additional value of new element */
2867  int* len, /**< pointer to length of arrays (will be increased by 1) */
2868  int* pos /**< pointer to store the insertion position, or NULL */
2869  );
2870 
2871 /** insert a new element into an array of ints in non-decreasing order */
2872 extern
2874  int* intarray, /**< int array where an element is to be inserted */
2875  int keyval, /**< key value of new element */
2876  int* len, /**< pointer to length of arrays (will be increased by 1) */
2877  int* pos /**< pointer to store the insertion position, or NULL */
2878  );
2879 
2880 /** insert a new element into two joint arrays of ints/ints, sorted by first array in non-decreasing order */
2881 extern
2883  int* intarray1, /**< int array where an element is to be inserted */
2884  int* intarray2, /**< second int array where an element is to be inserted */
2885  int keyval, /**< key value of new element */
2886  int field1val, /**< additional value of new element */
2887  int* len, /**< pointer to length of arrays (will be increased by 1) */
2888  int* pos /**< pointer to store the insertion position, or NULL */
2889  );
2890 
2891 /** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
2892 extern
2894  int* intarray, /**< int array where an element is to be inserted */
2895  void** ptrarray, /**< pointer array where an element is to be inserted */
2896  int keyval, /**< key value of new element */
2897  void* field1val, /**< additional value of new element */
2898  int* len, /**< pointer to length of arrays (will be increased by 1) */
2899  int* pos /**< pointer to store the insertion position, or NULL */
2900  );
2901 
2902 /** insert a new element into two joint arrays of ints/reals, sorted by first array in non-decreasing order */
2903 extern
2905  int* intarray, /**< int array where an element is to be inserted */
2906  SCIP_Real* realarray, /**< real array where an element is to be inserted */
2907  int keyval, /**< key value of new element */
2908  SCIP_Real field1val, /**< additional value of new element */
2909  int* len, /**< pointer to length of arrays (will be increased by 1) */
2910  int* pos /**< pointer to store the insertion position, or NULL */
2911  );
2912 
2913 /** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
2914 extern
2916  int* intarray1, /**< int array where an element is to be inserted */
2917  int* intarray2, /**< second int array where an element is to be inserted */
2918  int* intarray3, /**< third int array where an element is to be inserted */
2919  int keyval, /**< key value of new element */
2920  int field1val, /**< additional value of new element */
2921  int field2val, /**< additional value of new element */
2922  int* len, /**< pointer to length of arrays (will be increased by 1) */
2923  int* pos /**< pointer to store the insertion position, or NULL */
2924  );
2925 
2926 /** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
2927 extern
2929  int* intarray1, /**< int array where an element is to be inserted */
2930  int* intarray2, /**< second int array where an element is to be inserted */
2931  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
2932  int keyval, /**< key value of new element */
2933  int field1val, /**< additional value of new element */
2934  SCIP_Longint field2val, /**< additional value of new element */
2935  int* len, /**< pointer to length of arrays (will be increased by 1) */
2936  int* pos /**< pointer to store the insertion position, or NULL */
2937  );
2938 
2939 /** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
2940 extern
2942  int* intarray1, /**< first int array where an element is to be inserted */
2943  int* intarray2, /**< second int array where an element is to be inserted */
2944  void** ptrarray, /**< pointer array where an element is to be inserted */
2945  int keyval, /**< key value of new element */
2946  int field1val, /**< additional value of new element */
2947  void* field2val, /**< additional value of new element */
2948  int* len, /**< pointer to length of arrays (will be increased by 1) */
2949  int* pos /**< pointer to store the insertion position, or NULL */
2950  );
2951 
2952 /** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
2953 extern
2955  int* intarray1, /**< first int array where an element is to be inserted */
2956  int* intarray2, /**< second int array where an element is to be inserted */
2957  SCIP_Real* realarray, /**< real array where an element is to be inserted */
2958  int keyval, /**< key value of new element */
2959  int field1val, /**< additional value of new element */
2960  SCIP_Real field2val, /**< additional value of new element */
2961  int* len, /**< pointer to length of arrays (will be increased by 1) */
2962  int* pos /**< pointer to store the insertion position, or NULL */
2963  );
2964 
2965 /** insert a new element into three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
2966 extern
2968  int* intarray, /**< int array where an element is to be inserted */
2969  void** ptrarray, /**< pointer array where an element is to be inserted */
2970  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
2971  int keyval, /**< key value of new element */
2972  void* field1val, /**< additional value of new element */
2973  SCIP_Real field2val, /**< additional value of new element */
2974  int* len, /**< pointer to length of arrays (will be increased by 1) */
2975  int* pos /**< pointer to store the insertion position, or NULL */
2976  );
2977 
2978 /** insert a new element into four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
2979 extern
2981  int* intarray1, /**< first int array where an element is to be inserted */
2982  int* intarray2, /**< second int array where an element is to be inserted */
2983  int* intarray3, /**< second int array where an element is to be inserted */
2984  void** ptrarray, /**< pointer array where an element is to be inserted */
2985  int keyval, /**< key value of new element */
2986  int field1val, /**< additional value of new element */
2987  int field2val, /**< additional value of new element */
2988  void* field3val, /**< additional value of new element */
2989  int* len, /**< pointer to length of arrays (will be increased by 1) */
2990  int* pos /**< pointer to store the insertion position, or NULL */
2991  );
2992 
2993 /** insert a new element into four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
2994 extern
2996  int* intarray1, /**< first int array where an element is to be inserted */
2997  int* intarray2, /**< second int array where an element is to be inserted */
2998  int* intarray3, /**< second int array where an element is to be inserted */
2999  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3000  int keyval, /**< key value of new element */
3001  int field1val, /**< additional value of new element */
3002  int field2val, /**< additional value of new element */
3003  SCIP_Real field3val, /**< additional value of new element */
3004  int* len, /**< pointer to length of arrays (will be increased by 1) */
3005  int* pos /**< pointer to store the insertion position, or NULL */
3006  );
3007 
3008 /** insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order */
3009 extern
3011  int* intarray1, /**< first int array where an element is to be inserted */
3012  void** ptrarray, /**< pointer array where an element is to be inserted */
3013  int* intarray2, /**< second int array where an element is to be inserted */
3014  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3015  int keyval, /**< key value of new element */
3016  void* field1val, /**< additional value of new element */
3017  int field2val, /**< additional value of new element */
3018  SCIP_Real field3val, /**< additional value of new element */
3019  int* len, /**< pointer to length of arrays (will be increased by 1) */
3020  int* pos /**< pointer to store the insertion position, or NULL */
3021  );
3022 
3023 /** insert a new element into an array of Longints, sorted in non-decreasing order */
3024 extern
3026  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3027  SCIP_Longint keyval, /**< key value of new element */
3028  int* len, /**< pointer to length of arrays (will be increased by 1) */
3029  int* pos /**< pointer to store the insertion position, or NULL */
3030  );
3031 
3032 /** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
3033 extern
3035  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3036  void** ptrarray, /**< pointer array where an element is to be inserted */
3037  SCIP_Longint keyval, /**< key value of new element */
3038  void* field1val, /**< additional value of new element */
3039  int* len, /**< pointer to length of arrays (will be increased by 1) */
3040  int* pos /**< pointer to store the insertion position, or NULL */
3041  );
3042 
3043 /** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-decreasing order */
3044 extern
3046  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3047  void** ptrarray, /**< pointer array where an element is to be inserted */
3048  int* intarray, /**< int array where an element is to be inserted */
3049  SCIP_Longint keyval, /**< key value of new element */
3050  void* field1val, /**< additional value of new element */
3051  int field2val, /**< additional value of new element */
3052  int* len, /**< pointer to length of arrays (will be increased by 1) */
3053  int* pos /**< pointer to store the insertion position, or NULL */
3054  );
3055 
3056 /** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-decreasing order */
3057 extern
3059  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3060  void** ptrarray, /**< pointer array where an element is to be inserted */
3061  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3062  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3063  SCIP_Longint keyval, /**< key value of new element */
3064  void* field1val, /**< additional value of new element */
3065  SCIP_Real field2val, /**< additional value of new element */
3066  SCIP_Bool field3val, /**< additional value of new element */
3067  int* len, /**< pointer to length of arrays (will be increased by 1) */
3068  int* pos /**< pointer to store the insertion position, or NULL */
3069  );
3070 
3071 /** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-decreasing order */
3072 extern
3074  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3075  void** ptrarray, /**< pointer array where an element is to be inserted */
3076  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3077  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3078  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3079  SCIP_Longint keyval, /**< key value of new element */
3080  void* field1val, /**< additional value of new element */
3081  SCIP_Real field2val, /**< additional value of new element */
3082  SCIP_Real field3val, /**< additional value of new element */
3083  SCIP_Bool field4val, /**< additional value of new element */
3084  int* len, /**< pointer to length of arrays (will be increased by 1) */
3085  int* pos /**< pointer to store the insertion position, or NULL */
3086  );
3087 
3088 /** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-decreasing order */
3089 extern
3091  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3092  void** ptrarray, /**< pointer array where an element is to be inserted */
3093  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3094  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3095  int* intarray, /**< int array where an element is to be inserted */
3096  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3097  SCIP_Longint keyval, /**< key value of new element */
3098  void* field1val, /**< additional value of new element */
3099  SCIP_Real field2val, /**< additional value of new element */
3100  SCIP_Real field3val, /**< additional value of new element */
3101  int field4val, /**< additional value of new element */
3102  SCIP_Bool field5val, /**< 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 Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
3108 extern
3110  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3111  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3112  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3113  int* intarray, /**< int array where an element is to be inserted */
3114  SCIP_Longint keyval, /**< key value of new element */
3115  void* field1val, /**< additional value of new element */
3116  void* field2val, /**< additional value of new element */
3117  int field3val, /**< additional value of new element */
3118  int* len, /**< pointer to length of arrays (will be increased by 1) */
3119  int* pos /**< pointer to store the insertion position, or NULL */
3120  );
3121 
3122 /** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
3123 extern
3125  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
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  int* intarray1, /**< first int array where an element is to be inserted */
3129  int* intarray2, /**< second int array where an element is to be inserted */
3130  SCIP_Longint keyval, /**< key value of new element */
3131  void* field1val, /**< additional value of new element */
3132  void* field2val, /**< additional value of new element */
3133  int field3val, /**< additional value of new element */
3134  int field4val, /**< additional value of new element */
3135  int* len, /**< pointer to length of arrays (will be increased by 1) */
3136  int* pos /**< pointer to store the insertion position, or NULL */
3137  );
3138 
3139 /** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-decreasing order */
3140 extern
3142  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3143  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3144  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3145  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3146  int* intarray, /**< int array to be sorted */
3147  SCIP_Longint keyval, /**< key value of new element */
3148  void* field1val, /**< additional value of new element */
3149  void* field2val, /**< additional value of new element */
3150  SCIP_Bool field3val, /**< additional value of new element */
3151  int field4val, /**< additional value of new element */
3152  int* len, /**< pointer to length of arrays (will be increased by 1) */
3153  int* pos /**< pointer to store the insertion position, or NULL */
3154  );
3155 
3156 /** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
3157 extern
3159  void** ptrarray, /**< pointer array to be sorted */
3160  int* intarray1, /**< first int array to be permuted in the same way */
3161  int* intarray2, /**< second int array to be permuted in the same way */
3162  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3163  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3164  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3165  void* keyval, /**< key value of new element */
3166  int field1val, /**< additional value of new element */
3167  int field2val, /**< additional value of new element */
3168  SCIP_Bool field3val, /**< additional value of new element */
3169  SCIP_Bool field4val, /**< 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 six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-decreasing order */
3175 extern
3177  int* intarray1, /**< int array to be sorted */
3178  void** ptrarray, /**< pointer array to be permuted in the same way */
3179  int* intarray2, /**< second int array to be permuted in the same way */
3180  int* intarray3, /**< thrid int array to be permuted in the same way */
3181  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3182  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3183  int keyval, /**< key value of new element */
3184  void* field1val, /**< additional value of new element */
3185  int field2val, /**< additional value of new element */
3186  int field3val, /**< additional value of new element */
3187  SCIP_Bool field4val, /**< additional value of new element */
3188  SCIP_Bool field5val, /**< additional value of new element */
3189  int* len, /**< pointer to length of arrays (will be increased by 1) */
3190  int* pos /**< pointer to store the insertion position, or NULL */
3191  );
3192 
3193 
3194 /* downwards insertion */
3195 
3196 /** insert a new element into an index array in non-increasing order */
3197 extern
3199  int* indarray, /**< pointer to the index array where an element is to be inserted */
3200  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
3201  void* dataptr, /**< pointer to data field that is given to the external compare method */
3202  int keyval, /**< key value of new element */
3203  int* len, /**< pointer to length of arrays (will be increased by 1) */
3204  int* pos /**< pointer to store the insertion position, or NULL */
3205  );
3206 
3207 /** insert a new element into an array of pointers in non-increasing order */
3208 extern
3210  void** ptrarray, /**< pointer array where an element is to be inserted */
3211  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3212  void* keyval, /**< key value of new element */
3213  int* len, /**< pointer to length of arrays (will be increased by 1) */
3214  int* pos /**< pointer to store the insertion position, or NULL */
3215  );
3216 
3217 /** insert a new element into two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
3218 extern
3220  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3221  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3222  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3223  void* keyval, /**< key value of new element */
3224  void* field1val, /**< additional value of new element */
3225  int* len, /**< pointer to length of arrays (will be increased by 1) */
3226  int* pos /**< pointer to store the insertion position, or NULL */
3227  );
3228 
3229 /** insert a new element into two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
3230 extern
3232  void** ptrarray, /**< pointer array where an element is to be inserted */
3233  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3234  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3235  void* keyval, /**< key value of new element */
3236  SCIP_Real field1val, /**< additional value of new element */
3237  int* len, /**< pointer to length of arrays (will be increased by 1) */
3238  int* pos /**< pointer to store the insertion position, or NULL */
3239  );
3240 
3241 /** insert a new element into two joint arrays of pointers/ints, sorted by first array in non-increasing order */
3242 extern
3244  void** ptrarray, /**< pointer array where an element is to be inserted */
3245  int* intarray, /**< int array where an element is to be inserted */
3246  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3247  void* keyval, /**< key value of new element */
3248  int field1val, /**< additional value of new element */
3249  int* len, /**< pointer to length of arrays (will be increased by 1) */
3250  int* pos /**< pointer to store the insertion position, or NULL */
3251  );
3252 
3253 /** insert a new element into two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
3254 extern
3256  void** ptrarray, /**< pointer array where an element is to be inserted */
3257  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3258  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3259  void* keyval, /**< key value of new element */
3260  SCIP_Bool field1val, /**< additional value of new element */
3261  int* len, /**< pointer to length of arrays (will be increased by 1) */
3262  int* pos /**< pointer to store the insertion position, or NULL */
3263  );
3264 
3265 /** insert a new element into three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
3266 extern
3268  void** ptrarray, /**< pointer array where an element is to be inserted */
3269  int* intarray1, /**< first int array where an element is to be inserted */
3270  int* intarray2, /**< second int array where an element is to be inserted */
3271  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3272  void* keyval, /**< key value of new element */
3273  int field1val, /**< additional value of new element */
3274  int field2val, /**< additional value of new element */
3275  int* len, /**< pointer to length of arrays (will be increased by 1) */
3276  int* pos /**< pointer to store the insertion position, or NULL */
3277  );
3278 
3279 /** insert a new element into three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
3280 extern
3282  void** ptrarray, /**< pointer array where an element is to be inserted */
3283  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3284  int* intarray, /**< int array where an element is to be inserted */
3285  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3286  void* keyval, /**< key value of new element */
3287  SCIP_Real field1val, /**< additional value of new element */
3288  int field2val, /**< additional value of new element */
3289  int* len, /**< pointer to length of arrays (will be increased by 1) */
3290  int* pos /**< pointer to store the insertion position, or NULL */
3291  );
3292 
3293 /** insert a new element into three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order */
3294 extern
3296  void** ptrarray, /**< pointer array where an element is to be inserted */
3297  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3298  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3299  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3300  void* keyval, /**< key value of new element */
3301  SCIP_Real field1val, /**< additional value of new element */
3302  SCIP_Bool field2val, /**< additional value of new element */
3303  int* len, /**< pointer to length of arrays (will be increased by 1) */
3304  int* pos /**< pointer to store the insertion position, or NULL */
3305  );
3306 
3307 /** insert a new element into three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
3308 extern
3310  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3311  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3312  int* intarray, /**< int array where an element is to be inserted */
3313  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3314  void* keyval, /**< key value of new element */
3315  void* field1val, /**< additional value of new element */
3316  int field2val, /**< additional value of new element */
3317  int* len, /**< pointer to length of arrays (will be increased by 1) */
3318  int* pos /**< pointer to store the insertion position, or NULL */
3319  );
3320 
3321 /** insert a new element into three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
3322 extern
3324  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3325  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3326  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3327  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3328  void* keyval, /**< key value of new element */
3329  void* field1val, /**< additional value of new element */
3330  SCIP_Real field2val, /**< additional value of new element */
3331  int* len, /**< pointer to length of arrays (will be increased by 1) */
3332  int* pos /**< pointer to store the insertion position, or NULL */
3333  );
3334 
3335 /** insert a new element into four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3336 extern
3338  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3339  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3340  int* intarray1, /**< first int array where an element is to be inserted */
3341  int* intarray2, /**< second int array where an element is to be inserted */
3342  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3343  void* keyval, /**< key value of new element */
3344  void* field1val, /**< additional value of new element */
3345  int field2val, /**< additional value of new element */
3346  int field3val, /**< additional value of new element */
3347  int* len, /**< pointer to length of arrays (will be increased by 1) */
3348  int* pos /**< pointer to store the insertion position, or NULL */
3349  );
3350 
3351 /** insert a new element into four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
3352 extern
3354  void** ptrarray, /**< pointer array where an element is to be inserted */
3355  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3356  int* intarray1, /**< first int array where an element is to be inserted */
3357  int* intarray2, /**< second int array where an element is to be inserted */
3358  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3359  void* keyval, /**< key value of new element */
3360  SCIP_Real field1val, /**< additional value of new element */
3361  int field2val, /**< additional value of new element */
3362  int field3val, /**< additional value of new element */
3363  int* len, /**< pointer to length of arrays (will be increased by 1) */
3364  int* pos /**< pointer to store the insertion position, or NULL */
3365  );
3366 
3367 /** insert a new element into four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
3368 extern
3370  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3371  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3372  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3373  int* intarray, /**< int array where an element is to be inserted */
3374  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3375  void* keyval, /**< key value of new element */
3376  void* field1val, /**< additional value of new element */
3377  SCIP_Real field2val, /**< additional value of new element */
3378  int field3val, /**< additional value of new element */
3379  int* len, /**< pointer to length of arrays (will be increased by 1) */
3380  int* pos /**< pointer to store the insertion position, or NULL */
3381  );
3382 
3383 /** insert a new element into four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order */
3384 extern
3386  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3387  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3388  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3389  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3390  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3391  void* keyval, /**< key value of new element */
3392  void* field1val, /**< additional value of new element */
3393  SCIP_Real field2val, /**< additional value of new element */
3394  SCIP_Bool field3val, /**< additional value of new element */
3395  int* len, /**< pointer to length of arrays (will be increased by 1) */
3396  int* pos /**< pointer to store the insertion position, or NULL */
3397  );
3398 
3399 
3400 /** insert a new element into four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
3401 extern
3403  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3404  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3405  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3406  int* intarray, /**< int array where an element is to be inserted */
3407  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3408  void* keyval, /**< key value of new element */
3409  void* field1val, /**< additional value of new element */
3410  SCIP_Longint field2val, /**< additional value of new element */
3411  int field3val, /**< 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 five joint arrays of pointer/pointer/Longs/ints/ints, sorted by first array in non-increasing order */
3417 extern
3419  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3420  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3421  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3422  int* intarray1, /**< first int array where an element is to be inserted */
3423  int* intarray2, /**< second int array where an element is to be inserted */
3424  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3425  void* keyval, /**< key value of new element */
3426  void* field1val, /**< additional value of new element */
3427  SCIP_Longint field2val, /**< additional value of new element */
3428  int field3val, /**< additional value of new element */
3429  int field4val, /**< additional value of new element */
3430  int* len, /**< pointer to length of arrays (will be increased by 1) */
3431  int* pos /**< pointer to store the insertion position, or NULL */
3432  );
3433 
3434 /** insert a new element into an array of Reals, sorted in non-increasing order */
3435 extern
3437  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3438  SCIP_Real keyval, /**< key value of new element */
3439  int* len, /**< pointer to length of arrays (will be increased by 1) */
3440  int* pos /**< pointer to store the insertion position, or NULL */
3441  );
3442 
3443 /** insert a new element into three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
3444 extern
3446  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3447  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
3448  void** ptrarray, /**< pointer array to be permuted in the same way */
3449  SCIP_Real keyval, /**< key value of new element */
3450  SCIP_Bool field1val, /**< additional value of new element */
3451  void* field2val, /**< additional value of new element */
3452  int* len, /**< pointer to length of arrays (will be increased by 1) */
3453  int* pos /**< pointer to store the insertion position, or NULL */
3454  );
3455 
3456 /** insert a new element into two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3457 extern
3459  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3460  void** ptrarray, /**< pointer array where an element is to be inserted */
3461  SCIP_Real keyval, /**< key value of new element */
3462  void* field1val, /**< additional value of new element */
3463  int* len, /**< pointer to length of arrays (will be increased by 1) */
3464  int* pos /**< pointer to store the insertion position, or NULL */
3465  );
3466 
3467 /** insert a new element into three joint arrays of Reals/pointers, sorted by first array in non-increasing order */
3468 extern
3470  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3471  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3472  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3473  SCIP_Real keyval, /**< key value of new element */
3474  void* field1val, /**< additional value of new element */
3475  void* field2val, /**< additional 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 Reals/ints, sorted by first array in non-increasing order */
3481 extern
3483  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3484  int* intarray, /**< int array where an element is to be inserted */
3485  SCIP_Real keyval, /**< key value of new element */
3486  int 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 Reals/ints/ints, sorted by first array in non-increasing order */
3492 extern
3494  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3495  int* intarray1, /**< int array where an element is to be inserted */
3496  int* intarray2, /**< int array where an element is to be inserted */
3497  SCIP_Real keyval, /**< key value of new element */
3498  int 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 three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
3505 extern
3507  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
3508  int* intarray, /**< int array to be permuted in the same way */
3509  SCIP_Longint* longarray, /**< SCIP_Longint array to be permuted in the same way */
3510  SCIP_Real keyval, /**< key value of new element */
3511  int field1val, /**< additional value of new element */
3512  SCIP_Longint field2val, /**< additional value of new element */
3513  int* len, /**< pointer to length of arrays (will be increased by 1) */
3514  int* pos /**< pointer to store the insertion position, or NULL */
3515  );
3516 
3517 /** insert a new element into three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
3518 extern
3520  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3521  int* intarray, /**< int array where an element is to be inserted */
3522  void** ptrarray, /**< pointer array where an element is to be inserted */
3523  SCIP_Real keyval, /**< key value of new element */
3524  int field1val, /**< additional value of new element */
3525  void* field2val, /**< additional value of new element */
3526  int* len, /**< pointer to length of arrays (will be increased by 1) */
3527  int* pos /**< pointer to store the insertion position, or NULL */
3528  );
3529 
3530 /** insert a new element into three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
3531 extern
3533  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
3534  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3535  void** ptrarray, /**< pointer array where an element is to be inserted */
3536  SCIP_Real keyval, /**< key value of new element */
3537  SCIP_Real field1val, /**< additional value of new element */
3538  void* field2val, /**< additional value of new element */
3539  int* len, /**< pointer to length of arrays (will be increased by 1) */
3540  int* pos /**< pointer to store the insertion position, or NULL */
3541  );
3542 
3543 /** insert a new element into four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
3544 extern
3546  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3547  void** ptrarray1, /**< pointer array where an element is to be inserted */
3548  void** ptrarray2, /**< pointer array where an element is to be inserted */
3549  int* intarray, /**< int array where an element is to be inserted */
3550  SCIP_Real keyval, /**< key value of new element */
3551  void* field1val, /**< additional value of new element */
3552  void* field2val, /**< additional value of new element */
3553  int intval, /**< additional value of new element */
3554  int* len, /**< pointer to length of arrays (will be increased by 1) */
3555  int* pos /**< pointer to store the insertion position, or NULL */
3556  );
3557 
3558 /** insert a new element into five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-increasing order */
3559 extern
3561  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3562  void** ptrarray1, /**< pointer array where an element is to be inserted */
3563  void** ptrarray2, /**< pointer array where an element is to be inserted */
3564  int* intarray1, /**< int array where an element is to be inserted */
3565  int* intarray2, /**< int array where an element is to be inserted */
3566  SCIP_Real keyval, /**< key value of new element */
3567  void* field1val, /**< additional value of new element */
3568  void* field2val, /**< additional value of new element */
3569  int intval1, /**< additional value of new element */
3570  int intval2, /**< additional value of new element */
3571  int* len, /**< pointer to length of arrays (will be increased by 1) */
3572  int* pos /**< pointer to store the insertion position, or NULL */
3573  );
3574 
3575 /** insert a new element into four joint arrays of Reals/Longs/Reals/ints, sorted by first array in non-increasing order */
3576 extern
3578  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3579  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3580  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3581  int* intarray, /**< int array where an element is to be inserted */
3582  SCIP_Real keyval, /**< key value of new element */
3583  SCIP_Longint field1val, /**< additional value of new element */
3584  SCIP_Real field2val, /**< additional value of new element */
3585  int field3val, /**< additional value of new element */
3586  int* len, /**< pointer to length of arrays (will be increased by 1) */
3587  int* pos /**< pointer to store the insertion position, or NULL */
3588  );
3589 
3590 /** insert a new element into four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
3591 extern
3593  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be inserted */
3594  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3595  int* intarray1, /**< first int array where an element is to be inserted */
3596  int* intarray2, /**< second int array where an element is to be inserted */
3597  SCIP_Real keyval, /**< key value of new element */
3598  SCIP_Real field1val, /**< additional value of new element */
3599  int field2val, /**< additional value of new element */
3600  int field3val, /**< additional value of new element */
3601  int* len, /**< pointer to length of arrays (will be increased by 1) */
3602  int* pos /**< pointer to store the insertion position, or NULL */
3603  );
3604 
3605 /** insert a new element into four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
3606 extern
3608  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3609  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3610  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3611  int* intarray, /**< int array where an element is to be inserted */
3612  SCIP_Real keyval, /**< key value of new element */
3613  SCIP_Real field1val, /**< additional value of new element */
3614  SCIP_Real field2val, /**< additional value of new element */
3615  int field3val, /**< additional value of new element */
3616  int* len, /**< pointer to length of arrays (will be increased by 1) */
3617  int* pos /**< pointer to store the insertion position, or NULL */
3618  );
3619 
3620 /** insert a new element into four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
3621 extern
3623  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3624  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3625  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3626  void** ptrarray, /**< pointer array where an element is to be inserted */
3627  SCIP_Real keyval, /**< key value of new element */
3628  SCIP_Real field1val, /**< additional value of new element */
3629  SCIP_Real field2val, /**< additional value of new element */
3630  void* field3val, /**< additional value of new element */
3631  int* len, /**< pointer to length of arrays (will be increased by 1) */
3632  int* pos /**< pointer to store the insertion position, or NULL */
3633  );
3634 
3635 /** insert a new element into five joint arrays of Reals/Reals/Reals/Bools/pointers, sorted by first array in non-increasing order */
3636 extern
3638  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3639  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3640  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3641  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3642  void** ptrarray, /**< pointer array where an element is to be inserted */
3643  SCIP_Real keyval, /**< key value of new element */
3644  SCIP_Real field1val, /**< additional value of new element */
3645  SCIP_Real field2val, /**< additional value of new element */
3646  SCIP_Bool field3val, /**< additional value of new element */
3647  void* field4val, /**< additional value of new element */
3648  int* len, /**< pointer to length of arrays (will be increased by 1) */
3649  int* pos /**< pointer to store the insertion position, or NULL */
3650  );
3651 
3652 /** insert a new element into six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order */
3653 extern
3655  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be inserted */
3656  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be inserted */
3657  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be inserted */
3658  SCIP_Bool* boolarray1, /**< SCIP_Bool array where an element is to be inserted */
3659  SCIP_Bool* boolarray2, /**< SCIP_Bool array where an element is to be inserted */
3660  void** ptrarray, /**< pointer array where an element is to be inserted */
3661  SCIP_Real keyval, /**< key value of new element */
3662  SCIP_Real field1val, /**< additional value of new element */
3663  SCIP_Real field2val, /**< additional value of new element */
3664  SCIP_Bool field3val, /**< additional value of new element */
3665  SCIP_Bool field4val, /**< additional value of new element */
3666  void* field5val, /**< additional value of new element */
3667  int* len, /**< pointer to length of arrays (will be increased by 1) */
3668  int* pos /**< pointer to store the insertion position, or NULL */
3669  );
3670 
3671 /** insert a new element into an array of ints in non-increasing order */
3672 extern
3674  int* intarray, /**< int array where an element is to be inserted */
3675  int keyval, /**< key value of new element */
3676  int* len, /**< pointer to length of arrays (will be increased by 1) */
3677  int* pos /**< pointer to store the insertion position, or NULL */
3678  );
3679 
3680 /** insert a new element into two joint arrays of ints/ints, sorted by first array in non-increasing order */
3681 extern
3683  int* intarray1, /**< int array where an element is to be inserted */
3684  int* intarray2, /**< second int array where an element is to be inserted */
3685  int keyval, /**< key value of new element */
3686  int field1val, /**< additional value of new element */
3687  int* len, /**< pointer to length of arrays (will be increased by 1) */
3688  int* pos /**< pointer to store the insertion position, or NULL */
3689  );
3690 
3691 /** insert a new element into two joint arrays of ints/reals, sorted by first array in non-increasing order */
3692 extern
3694  int* intarray, /**< int array where an element is to be inserted */
3695  SCIP_Real* realarray, /**< real array where an element is to be inserted */
3696  int keyval, /**< key value of new element */
3697  SCIP_Real field1val, /**< additional value of new element */
3698  int* len, /**< pointer to length of arrays (will be increased by 1) */
3699  int* pos /**< pointer to store the insertion position, or NULL */
3700  );
3701 
3702 /** insert a new element into three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
3703 extern
3705  int* intarray1, /**< int array where an element is to be inserted */
3706  int* intarray2, /**< second int array where an element is to be inserted */
3707  int* intarray3, /**< third int array where an element is to be inserted */
3708  int keyval, /**< key value of new element */
3709  int field1val, /**< additional value of new element */
3710  int field2val, /**< additional value of new element */
3711  int* len, /**< pointer to length of arrays (will be increased by 1) */
3712  int* pos /**< pointer to store the insertion position, or NULL */
3713  );
3714 
3715 /** insert a new element into three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
3716 extern
3718  int* intarray1, /**< int array where an element is to be inserted */
3719  int* intarray2, /**< second int array where an element is to be inserted */
3720  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3721  int keyval, /**< key value of new element */
3722  int field1val, /**< additional value of new element */
3723  SCIP_Longint field2val, /**< additional value of new element */
3724  int* len, /**< pointer to length of arrays (will be increased by 1) */
3725  int* pos /**< pointer to store the insertion position, or NULL */
3726  );
3727 
3728 /** insert a new element into three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
3729 extern
3731  int* intarray1, /**< int array where an element is to be inserted */
3732  int* intarray2, /**< second int array where an element is to be inserted */
3733  void** ptrarray, /**< pointer array where an element is to be inserted */
3734  int keyval, /**< key value of new element */
3735  int field1val, /**< additional value of new element */
3736  void* field2val, /**< additional value of new element */
3737  int* len, /**< pointer to length of arrays (will be increased by 1) */
3738  int* pos /**< pointer to store the insertion position, or NULL */
3739  );
3740 
3741 /** insert a new element into three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
3742 extern
3744  int* intarray1, /**< int array where an element is to be inserted */
3745  int* intarray2, /**< second int array where an element is to be inserted */
3746  SCIP_Real* realarray, /**< real array where an element is to be inserted */
3747  int keyval, /**< key value of new element */
3748  int field1val, /**< additional value of new element */
3749  SCIP_Real field2val, /**< additional value of new element */
3750  int* len, /**< pointer to length of arrays (will be increased by 1) */
3751  int* pos /**< pointer to store the insertion position, or NULL */
3752  );
3753 
3754 /** insert a new element into two joint arrays of ints/pointers, sorted by first array in non-increasing order */
3755 extern
3757  int* intarray, /**< int array where an element is to be inserted */
3758  void** ptrarray, /**< pointer array where an element is to be inserted */
3759  int keyval, /**< key value of new element */
3760  void* field1val, /**< additional value of new element */
3761  int* len, /**< pointer to length of arrays (will be increased by 1) */
3762  int* pos /**< pointer to store the insertion position, or NULL */
3763  );
3764 
3765 /** insert a new element into four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-increasing order */
3766 extern
3768  int* intarray1, /**< int array where an element is to be inserted */
3769  int* intarray2, /**< int array where an element is to be inserted */
3770  int* intarray3, /**< int array where an element is to be inserted */
3771  void** ptrarray, /**< pointer array where an element is to be inserted */
3772  int keyval, /**< key value of new element */
3773  int field1val, /**< additional value of new element */
3774  int field2val, /**< additional value of new element */
3775  void* field3val, /**< additional value of new element */
3776  int* len, /**< pointer to length of arrays (will be increased by 1) */
3777  int* pos /**< pointer to store the insertion position, or NULL */
3778  );
3779 
3780 /** insert a new element into four joint arrays of ints/int/ints/reals, sorted by first array in non-increasing order */
3781 extern
3783  int* intarray1, /**< int array where an element is to be inserted */
3784  int* intarray2, /**< int array where an element is to be inserted */
3785  int* intarray3, /**< int array where an element is to be inserted */
3786  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3787  int keyval, /**< key value of new element */
3788  int field1val, /**< additional value of new element */
3789  int field2val, /**< additional value of new element */
3790  SCIP_Real field3val, /**< additional value of new element */
3791  int* len, /**< pointer to length of arrays (will be increased by 1) */
3792  int* pos /**< pointer to store the insertion position, or NULL */
3793  );
3794 
3795 /** insert a new element into four joint arrays of ints/pointers/ints/reals, sorted by first array in non-increasing order */
3796 extern
3798  int* intarray1, /**< int array where an element is to be inserted */
3799  void** ptrarray, /**< pointer array where an element is to be inserted */
3800  int* intarray2, /**< int array where an element is to be inserted */
3801  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3802  int keyval, /**< key value of new element */
3803  void* field1val, /**< additional value of new element */
3804  int field2val, /**< additional value of new element */
3805  SCIP_Real field3val, /**< additional value of new element */
3806  int* len, /**< pointer to length of arrays (will be increased by 1) */
3807  int* pos /**< pointer to store the insertion position, or NULL */
3808  );
3809 
3810 /** insert a new element into an array of Longints, sorted in non-increasing order */
3811 extern
3813  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3814  SCIP_Longint keyval, /**< key value of new element */
3815  int* len, /**< pointer to length of arrays (will be increased by 1) */
3816  int* pos /**< pointer to store the insertion position, or NULL */
3817  );
3818 
3819 /** insert a new element into two joint arrays of Long/pointer, sorted by the first array in non-increasing order */
3820 extern
3822  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3823  void** ptrarray, /**< pointer array where an element is to be inserted */
3824  SCIP_Longint keyval, /**< key value of new element */
3825  void* field1val, /**< additional value of new element */
3826  int* len, /**< pointer to length of arrays (will be increased by 1) */
3827  int* pos /**< pointer to store the insertion position, or NULL */
3828  );
3829 
3830 /** insert a new element into three joint arrays of Long/pointer/ints, sorted by the first array in non-increasing order */
3831 extern
3833  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3834  void** ptrarray, /**< pointer array where an element is to be inserted */
3835  int* intarray, /**< int array where an element is to be inserted */
3836  SCIP_Longint keyval, /**< key value of new element */
3837  void* field1val, /**< additional value of new element */
3838  int field2val, /**< additional value of new element */
3839  int* len, /**< pointer to length of arrays (will be increased by 1) */
3840  int* pos /**< pointer to store the insertion position, or NULL */
3841  );
3842 
3843 /** insert a new element into four joint arrays of Long/pointer/Real/Bool, sorted by the first array in non-increasing order */
3844 extern
3846  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3847  void** ptrarray, /**< pointer array where an element is to be inserted */
3848  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be inserted */
3849  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3850  SCIP_Longint keyval, /**< key value of new element */
3851  void* field1val, /**< additional value of new element */
3852  SCIP_Real field2val, /**< additional value of new element */
3853  SCIP_Bool field3val, /**< additional value of new element */
3854  int* len, /**< pointer to length of arrays (will be increased by 1) */
3855  int* pos /**< pointer to store the insertion position, or NULL */
3856  );
3857 
3858 /** insert a new element into five joint arrays of Long/pointer/Real/Real/Bool, sorted by the first array in non-increasing order */
3859 extern
3861  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3862  void** ptrarray, /**< pointer array where an element is to be inserted */
3863  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3864  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3865  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3866  SCIP_Longint keyval, /**< key value of new element */
3867  void* field1val, /**< additional value of new element */
3868  SCIP_Real field2val, /**< additional value of new element */
3869  SCIP_Real field3val, /**< additional value of new element */
3870  SCIP_Bool field4val, /**< additional value of new element */
3871  int* len, /**< pointer to length of arrays (will be increased by 1) */
3872  int* pos /**< pointer to store the insertion position, or NULL */
3873  );
3874 
3875 /** insert a new element into six joint arrays of Long/pointer/Real/Real/int/Bool, sorted by the first array in non-increasing order */
3876 extern
3878  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3879  void** ptrarray, /**< pointer array where an element is to be inserted */
3880  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be inserted */
3881  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be inserted */
3882  int* intarray, /**< int array where an element is to be inserted */
3883  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3884  SCIP_Longint keyval, /**< key value of new element */
3885  void* field1val, /**< additional value of new element */
3886  SCIP_Real field2val, /**< additional value of new element */
3887  SCIP_Real field3val, /**< additional value of new element */
3888  int field4val, /**< additional value of new element */
3889  SCIP_Bool field5val, /**< additional value of new element */
3890  int* len, /**< pointer to length of arrays (will be increased by 1) */
3891  int* pos /**< pointer to store the insertion position, or NULL */
3892  );
3893 
3894 /** insert a new element into four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
3895 extern
3897  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3898  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3899  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3900  int* intarray, /**< int array where an element is to be inserted */
3901  SCIP_Longint keyval, /**< key value of new element */
3902  void* field1val, /**< additional value of new element */
3903  void* field2val, /**< additional value of new element */
3904  int field3val, /**< additional value of new element */
3905  int* len, /**< pointer to length of arrays (will be increased by 1) */
3906  int* pos /**< pointer to store the insertion position, or NULL */
3907  );
3908 
3909 /** insert a new element into five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-increasing order */
3910 extern
3912  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3913  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3914  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3915  int* intarray1, /**< first int array where an element is to be inserted */
3916  int* intarray2, /**< second int array where an element is to be inserted */
3917  SCIP_Longint keyval, /**< key value of new element */
3918  void* field1val, /**< additional value of new element */
3919  void* field2val, /**< additional value of new element */
3920  int field3val, /**< additional value of new element */
3921  int field4val, /**< additional value of new element */
3922  int* len, /**< pointer to length of arrays (will be increased by 1) */
3923  int* pos /**< pointer to store the insertion position, or NULL */
3924  );
3925 
3926 /** insert a new element into five joint arrays of Long/pointer/pointer/Bool/ints, sorted by first array in non-increasing order */
3927 extern
3929  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be inserted */
3930  void** ptrarray1, /**< first pointer array where an element is to be inserted */
3931  void** ptrarray2, /**< second pointer array where an element is to be inserted */
3932  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
3933  int* intarray, /**< int array where an element is to be inserted */
3934  SCIP_Longint keyval, /**< key value of new element */
3935  void* field1val, /**< additional value of new element */
3936  void* field2val, /**< additional value of new element */
3937  SCIP_Bool field3val, /**< additional value of new element */
3938  int field4val, /**< additional value of new element */
3939  int* len, /**< pointer to length of arrays (will be increased by 1) */
3940  int* pos /**< pointer to store the insertion position, or NULL */
3941  );
3942 
3943 /** insert a new element into five joint arrays of pointer/ints/ints/Bool/Bool, sorted by first array in non-increasing order */
3944 extern
3946  void** ptrarray, /**< pointer array to be sorted */
3947  int* intarray1, /**< first int array to be permuted in the same way */
3948  int* intarray2, /**< second int array to be permuted in the same way */
3949  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3950  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3951  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3952  void* keyval, /**< key value of new element */
3953  int field1val, /**< additional value of new element */
3954  int field2val, /**< additional value of new element */
3955  SCIP_Bool field3val, /**< additional value of new element */
3956  SCIP_Bool field4val, /**< additional value of new element */
3957  int* len, /**< pointer to length of arrays (will be increased by 1) */
3958  int* pos /**< pointer to store the insertion position, or NULL */
3959  );
3960 
3961 /** insert a new element into six joint arrays of ints/pointer/ints/ints/Bool/Bool, sorted by first array in non-increased order */
3962 extern
3964  int* intarray1, /**< int array to be sorted */
3965  void** ptrarray, /**< pointer array to be permuted in the same way */
3966  int* intarray2, /**< second int array to be permuted in the same way */
3967  int* intarray3, /**< thrid int array to be permuted in the same way */
3968  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
3969  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
3970  int keyval, /**< key value of new element */
3971  void* field1val, /**< additional value of new element */
3972  int field2val, /**< additional value of new element */
3973  int field3val, /**< additional value of new element */
3974  SCIP_Bool field4val, /**< additional value of new element */
3975  SCIP_Bool field5val, /**< additional value of new element */
3976  int* len, /**< pointer to length of arrays (will be increased by 1) */
3977  int* pos /**< pointer to store the insertion position, or NULL */
3978  );
3979 
3980 /* upwards position deletion */
3981 
3982 /** delete the element at the given position from an index array in non-decreasing order */
3983 extern
3985  int* indarray, /**< pointer to the index array where an element is to be deleted */
3986  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
3987  void* dataptr, /**< pointer to data field that is given to the external compare method */
3988  int pos, /**< array position of element to be deleted */
3989  int* len /**< pointer to length of arrays (will be decreased by 1) */
3990  );
3991 
3992 /** delete the element at the given position from an array of pointers in non-decreasing order */
3993 extern
3995  void** ptrarray, /**< pointer array where an element is to be deleted */
3996  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
3997  int pos, /**< array position of element to be deleted */
3998  int* len /**< pointer to length of arrays (will be decreased by 1) */
3999  );
4000 
4001 /** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-decreasing order */
4002 extern
4004  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4005  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4006  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4007  int pos, /**< array position of element to be deleted */
4008  int* len /**< pointer to length of arrays (will be decreased by 1) */
4009  );
4010 
4011 /** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-decreasing order */
4012 extern
4014  void** ptrarray, /**< pointer array where an element is to be deleted */
4015  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4016  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4017  int pos, /**< array position of element to be deleted */
4018  int* len /**< pointer to length of arrays (will be decreased by 1) */
4019  );
4020 
4021 /** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-decreasing order */
4022 extern
4024  void** ptrarray, /**< pointer array where an element is to be deleted */
4025  int* intarray, /**< int array where an element is to be deleted */
4026  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4027  int pos, /**< array position of element to be deleted */
4028  int* len /**< pointer to length of arrays (will be decreased by 1) */
4029  );
4030 
4031 /** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-decreasing order */
4032 extern
4034  void** ptrarray, /**< pointer array where an element is to be inserted */
4035  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
4036  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4037  int pos, /**< array position of element to be deleted */
4038  int* len /**< pointer to length of arrays (will be increased by 1) */
4039  );
4040 
4041 /** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-decreasing order */
4042 extern
4044  void** ptrarray, /**< pointer array where an element is to be deleted */
4045  int* intarray1, /**< first int array where an element is to be deleted */
4046  int* intarray2, /**< second int array where an element is to be deleted */
4047  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4048  int pos, /**< array position of element to be deleted */
4049  int* len /**< pointer to length of arrays (will be decreased by 1) */
4050  );
4051 
4052 /** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-decreasing order */
4053 extern
4055  void** ptrarray, /**< pointer array where an element is to be deleted */
4056  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4057  int* intarray, /**< int array where an element is to be deleted */
4058  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4059  int pos, /**< array position of element to be deleted */
4060  int* len /**< pointer to length of arrays (will be decreased by 1) */
4061  );
4062 
4063 /** delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-decreasing order */
4064 extern
4066  void** ptrarray, /**< pointer array where an element is to be deleted */
4067  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4068  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4069  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4070  int pos, /**< array position of element to be deleted */
4071  int* len /**< pointer to length of arrays (will be decreased by 1) */
4072  );
4073 
4074 /** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-decreasing order */
4075 extern
4077  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4078  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4079  int* intarray, /**< int array where an element is to be deleted */
4080  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4081  int pos, /**< array position of element to be deleted */
4082  int* len /**< pointer to length of arrays (will be decreased by 1) */
4083  );
4084 
4085 /** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-decreasing order */
4086 extern
4088  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4089  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4090  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4091  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4092  int pos, /**< array position of element to be deleted */
4093  int* len /**< pointer to length of arrays (will be decreased by 1) */
4094  );
4095 
4096 /** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
4097 extern
4099  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4100  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4101  int* intarray1, /**< first int array where an element is to be deleted */
4102  int* intarray2, /**< second array where an element is to be deleted */
4103  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4104  int pos, /**< array position of element to be deleted */
4105  int* len /**< pointer to length of arrays (will be decreased by 1) */
4106  );
4107 
4108 /** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-decreasing order */
4109 extern
4111  void** ptrarray, /**< pointer array where an element is to be deleted */
4112  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4113  int* intarray1, /**< first int array where an element is to be deleted */
4114  int* intarray2, /**< second int array where an element is to be deleted */
4115  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4116  int pos, /**< array position of element to be deleted */
4117  int* len /**< pointer to length of arrays (will be decreased by 1) */
4118  );
4119 
4120 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-decreasing order */
4121 extern
4123  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4124  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4125  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4126  int* intarray, /**< int array where an element is to be deleted */
4127  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4128  int pos, /**< array position of element to be deleted */
4129  int* len /**< pointer to length of arrays (will be decreased by 1) */
4130  );
4131 
4132 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-decreasing order */
4133 extern
4135  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4136  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4137  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4138  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4139  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4140  int pos, /**< array position of element to be deleted */
4141  int* len /**< pointer to length of arrays (will be decreased by 1) */
4142  );
4143 
4144 /** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-decreasing order */
4145 extern
4147  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4148  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4149  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4150  int* intarray, /**< int array where an element is to be deleted */
4151  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4152  int pos, /**< array position of element to be deleted */
4153  int* len /**< pointer to length of arrays (will be decreased by 1) */
4154  );
4155 
4156 /** 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 */
4157 extern
4159  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4160  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4161  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4162  int* intarray1, /**< first int array where an element is to be deleted */
4163  int* intarray2, /**< second int array where an element is to be deleted */
4164  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4165  int pos, /**< array position of element to be deleted */
4166  int* len /**< pointer to length of arrays (will be decreased by 1) */
4167  );
4168 
4169 /** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-decreasing order */
4170 extern
4172  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
4173  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
4174  void** ptrarray, /**< pointer array to be permuted in the same way */
4175  int pos, /**< array position of element to be deleted */
4176  int* len /**< pointer to length of arrays (will be decreased by 1) */
4177  );
4178 
4179 /** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-decreasing order */
4180 extern
4182  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4183  void** ptrarray, /**< pointer array where an element is to be deleted */
4184  int pos, /**< array position of element to be deleted */
4185  int* len /**< pointer to length of arrays (will be decreased by 1) */
4186  );
4187 
4188 /** delete the element at the given position from an arrays of Reals, sorted in non-decreasing order */
4189 extern
4191  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
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 two joint arrays of Reals/ints, sorted by first array in non-decreasing order */
4197 extern
4199  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4200  int* intarray, /**< int array where an element is to be deleted */
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 Reals/ints, sorted by first array in non-decreasing order */
4206 extern
4208  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4209  int* intarray1, /**< int array where an element is to be deleted */
4210  int* intarray2, /**< int array where an element is to be deleted */
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 three joint arrays of Reals/ints/Longs, sorted by first array in non-decreasing order */
4216 extern
4218  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4219  int* intarray, /**< int array where an element is to be deleted */
4220  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
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 three joint arrays of Reals/ints/Pointer, sorted by first array in non-decreasing order */
4226 extern
4228  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4229  int* intarray, /**< int array where an element is to be deleted */
4230  void** ptrarray, /**< pointer array where an element is to be deleted */
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 three joint arrays of Reals/Reals/Pointer, sorted by first array in non-decreasing order */
4236 extern
4238  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be deleted */
4239  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4240  void** ptrarray, /**< pointer array where an element is to be deleted */
4241  int pos, /**< array position of element to be deleted */
4242  int* len /**< pointer to length of arrays (will be decreased by 1) */
4243  );
4244 
4245 /** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-decreasing order */
4246 extern
4248  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4249  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4250  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4251  int* intarray, /**< int array where an element is to be deleted */
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 five joint arrays of Reals/pointers/pointers/ints/ints, sorted by first array in non-decreasing order */
4257 extern
4259  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4260  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4261  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4262  int* intarray1, /**< int array where an element is to be deleted */
4263  int* intarray2, /**< int array where an element is to be deleted */
4264  int pos, /**< array position of element to be deleted */
4265  int* len /**< pointer to length of arrays (will be decreased by 1) */
4266  );
4267 
4268 /** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-decreasing order */
4269 extern
4271  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4272  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4273  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4274  int* intarray, /**< int array where an element is to be deleted */
4275  int pos, /**< array position of element to be deleted */
4276  int* len /**< pointer to length of arrays (will be decreased by 1) */
4277  );
4278 
4279 /** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-decreasing order */
4280 extern
4282  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4283  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4284  int* intarray1, /**< int array where an element is to be deleted */
4285  int* intarray2, /**< int array where an element is to be deleted */
4286  int pos, /**< array position of element to be deleted */
4287  int* len /**< pointer to length of arrays (will be decreased by 1) */
4288  );
4289 
4290 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-decreasing order */
4291 extern
4293  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4294  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4295  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4296  int* intarray, /**< int array where an element is to be deleted */
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 Reals/Reals/Reals/pointers, sorted by first array in non-decreasing order */
4302 extern
4304  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4305  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4306  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4307  void** ptrarray, /**< pointer array where an element is to be deleted */
4308  int pos, /**< array position of element to be deleted */
4309  int* len /**< pointer to length of arrays (will be decreased by 1) */
4310  );
4311 
4312 /** 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 */
4313 extern
4315  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4316  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4317  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4318  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4319  void** ptrarray, /**< pointer array where an element is to be deleted */
4320  int pos, /**< array position of element to be deleted */
4321  int* len /**< pointer to length of arrays (will be decreased by 1) */
4322  );
4323 
4324 /** delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-decreasing order */
4325 extern
4327  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4328  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4329  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4330  SCIP_Bool* boolarray1, /**< SCIP_Bool array where an element is to be deleted */
4331  SCIP_Bool* boolarray2, /**< SCIP_Bool array where an element is to be deleted */
4332  void** ptrarray, /**< pointer array where an element is to be deleted */
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 /** delete the element at the given position from an array of ints in non-decreasing order */
4338 extern
4340  int* intarray, /**< int array where an element is to be deleted */
4341  int pos, /**< array position of element to be deleted */
4342  int* len /**< pointer to length of arrays (will be decreased by 1) */
4343  );
4344 
4345 /** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-decreasing order */
4346 extern
4348  int* intarray1, /**< int array where an element is to be deleted */
4349  int* intarray2, /**< second int array where an element is to be deleted */
4350  int pos, /**< array position of element to be deleted */
4351  int* len /**< pointer to length of arrays (will be decreased by 1) */
4352  );
4353 
4354 /** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-decreasing order */
4355 extern
4357  int* intarray, /**< int array where an element is to be deleted */
4358  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4359  int pos, /**< array position of element to be deleted */
4360  int* len /**< pointer to length of arrays (will be decreased by 1) */
4361  );
4362 
4363 /** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-decreasing order */
4364 extern
4366  int* intarray1, /**< int array where an element is to be deleted */
4367  int* intarray2, /**< second int array where an element is to be deleted */
4368  int* intarray3, /**< third int array where an element is to be deleted */
4369  int pos, /**< array position of element to be deleted */
4370  int* len /**< pointer to length of arrays (will be decreased by 1) */
4371  );
4372 
4373 /** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-decreasing order */
4374 extern
4376  int* intarray1, /**< int array where an element is to be deleted */
4377  int* intarray2, /**< second int array where an element is to be deleted */
4378  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4379  int pos, /**< array position of element to be deleted */
4380  int* len /**< pointer to length of arrays (will be decreased by 1) */
4381  );
4382 
4383 /** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-decreasing order */
4384 extern
4386  int* intarray1, /**< int array where an element is to be deleted */
4387  int* intarray2, /**< second int array where an element is to be deleted */
4388  void** ptrarray, /**< pointer array where an element is to be deleted */
4389  int pos, /**< array position of element to be deleted */
4390  int* len /**< pointer to length of arrays (will be decreased by 1) */
4391  );
4392 
4393 /** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-decreasing order */
4394 extern
4396  int* intarray1, /**< int array where an element is to be deleted */
4397  int* intarray2, /**< second int array where an element is to be deleted */
4398  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4399  int pos, /**< array position of element to be deleted */
4400  int* len /**< pointer to length of arrays (will be decreased by 1) */
4401  );
4402 
4403 /** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-decreasing order */
4404 extern
4406  int* intarray, /**< int array where an element is to be deleted */
4407  void** ptrarray, /**< pointer array where an element is to be deleted */
4408  int pos, /**< array position of element to be deleted */
4409  int* len /**< pointer to length of arrays (will be decreased by 1) */
4410  );
4411 
4412 /** delete the element at the given position from three joint arrays of ints/pointers/Reals, sorted by first array in non-decreasing order */
4413 extern
4415  int* intarray, /**< int array where an element is to be deleted */
4416  void** ptrarray, /**< pointer array where an element is to be deleted */
4417  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4418  int pos, /**< array position of element to be deleted */
4419  int* len /**< pointer to length of arrays (will be decreased by 1) */
4420  );
4421 
4422 /** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
4423 extern
4425  int* intarray1, /**< int array where an element is to be deleted */
4426  int* intarray2, /**< int array where an element is to be deleted */
4427  int* intarray3, /**< int array where an element is to be deleted */
4428  void** ptrarray, /**< pointer array where an element is to be deleted */
4429  int pos, /**< array position of element to be deleted */
4430  int* len /**< pointer to length of arrays (will be decreased by 1) */
4431  );
4432 
4433 /** delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
4434 extern
4436  int* intarray1, /**< int array where an element is to be deleted */
4437  int* intarray2, /**< int array where an element is to be deleted */
4438  int* intarray3, /**< int array where an element is to be deleted */
4439  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4440  int pos, /**< array position of element to be deleted */
4441  int* len /**< pointer to length of arrays (will be decreased by 1) */
4442  );
4443 
4444 /** delete the element at the given position from four joint arrays of ints/pointers/ints/Reals, sorted by first array in non-decreasing order */
4445 extern
4447  int* intarray1, /**< int array where an element is to be deleted */
4448  void** ptrarray, /**< pointer array where an element is to be deleted */
4449  int* intarray2, /**< int array where an element is to be deleted */
4450  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4451  int pos, /**< array position of element to be deleted */
4452  int* len /**< pointer to length of arrays (will be decreased by 1) */
4453  );
4454 
4455 /** delete the element at the given position from an array of Longints, sorted by in non-decreasing order */
4456 extern
4458  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4459  int pos, /**< array position of element to be deleted */
4460  int* len /**< pointer to length of arrays (will be decreased by 1) */
4461  );
4462 
4463 /** delete the element at the given position from two joint arrays of Long/pointer, sorted by the first array in non-decreasing order */
4464 extern
4466  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4467  void** ptrarray, /**< pointer 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 three joint arrays of Long/pointer/int, sorted by the first array in non-decreasing order */
4473 extern
4475  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4476  void** ptrarray, /**< pointer array where an element is to be deleted */
4477  int* intarray, /**< int array where an element is to be deleted */
4478  int pos, /**< array position of element to be deleted */
4479  int* len /**< pointer to length of arrays (will be decreased by 1) */
4480  );
4481 
4482 /** 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 */
4483 extern
4485  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4486  void** ptrarray, /**< pointer array where an element is to be deleted */
4487  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4488  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4489  int pos, /**< array position of element to be deleted */
4490  int* len /**< pointer to length of arrays (will be decreased by 1) */
4491  );
4492 
4493 /** 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 */
4494 extern
4496  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4497  void** ptrarray, /**< pointer array where an element is to be deleted */
4498  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4499  SCIP_Real* realarray2, /**< second 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  int pos, /**< array position of element to be deleted */
4502  int* len /**< pointer to length of arrays (will be decreased by 1) */
4503  );
4504 
4505 /** 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 */
4506 extern
4508  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4509  void** ptrarray, /**< pointer array where an element is to be deleted */
4510  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4511  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4512  int* intarray, /**< int array where an element is to be deleted */
4513  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4514  int pos, /**< array position of element to be deleted */
4515  int* len /**< pointer to length of arrays (will be decreased by 1) */
4516  );
4517 
4518 /** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-decreasing order */
4519 extern
4521  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4522  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4523  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4524  int* intarray, /**< int array where an element is to be deleted */
4525  int pos, /**< array position of element to be deleted */
4526  int* len /**< pointer to length of arrays (will be decreased by 1) */
4527  );
4528 
4529 /** delete the element at the given position from five joint arrays of Long/pointer/pointer/ints/ints, sorted by first array in non-decreasing order */
4530 extern
4532  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4533  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4534  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4535  int* intarray1, /**< first int array where an element is to be deleted */
4536  int* intarray2, /**< second int array where an element is to be deleted */
4537  int pos, /**< array position of element to be deleted */
4538  int* len /**< pointer to length of arrays (will be decreased by 1) */
4539  );
4540 
4541 /** 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 */
4542 extern
4544  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4545  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4546  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4547  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4548  int* intarray, /**< int array where an element is to be deleted */
4549  int pos, /**< array position of element to be deleted */
4550  int* len /**< pointer to length of arrays (will be decreased by 1) */
4551  );
4552 
4553 /** 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 */
4554 extern
4556  void** ptrarray, /**< pointer array to be sorted */
4557  int* intarray1, /**< first int array to be permuted in the same way */
4558  int* intarray2, /**< second int array to be permuted in the same way */
4559  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4560  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4561  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4562  int pos, /**< array position of element to be deleted */
4563  int* len /**< pointer to length of arrays (will be decreased by 1) */
4564  );
4565 
4566 /** 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 */
4567 extern
4569  int* intarray1, /**< int array to be sorted */
4570  void** ptrarray, /**< pointer array to be permuted in the same way */
4571  int* intarray2, /**< second int array to be permuted in the same way */
4572  int* intarray3, /**< thrid int array to be permuted in the same way */
4573  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
4574  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
4575  int pos, /**< array position of element to be deleted */
4576  int* len /**< pointer to length of arrays (will be decreased by 1) */
4577  );
4578 
4579 /* downwards position deletion */
4580 
4581 /** delete the element at the given position from an index array in non-increasing order */
4582 extern
4584  int* indarray, /**< pointer to the index array where an element is to be deleted */
4585  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
4586  void* dataptr, /**< pointer to data field that is given to the external compare method */
4587  int pos, /**< array position of element to be deleted */
4588  int* len /**< pointer to length of arrays (will be decreased by 1) */
4589  );
4590 
4591 /** delete the element at the given position from an array of pointers in non-increasing order */
4592 extern
4594  void** ptrarray, /**< pointer array where an element is to be deleted */
4595  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4596  int pos, /**< array position of element to be deleted */
4597  int* len /**< pointer to length of arrays (will be decreased by 1) */
4598  );
4599 
4600 /** delete the element at the given position from two joint arrays of pointers/pointers, sorted by first array in non-increasing order */
4601 extern
4603  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4604  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4605  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4606  int pos, /**< array position of element to be deleted */
4607  int* len /**< pointer to length of arrays (will be decreased by 1) */
4608  );
4609 
4610 /** delete the element at the given position from two joint arrays of pointers/Reals, sorted by first array in non-increasing order */
4611 extern
4613  void** ptrarray, /**< pointer array where an element is to be deleted */
4614  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4615  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4616  int pos, /**< array position of element to be deleted */
4617  int* len /**< pointer to length of arrays (will be decreased by 1) */
4618  );
4619 
4620 /** delete the element at the given position from two joint arrays of pointers/ints, sorted by first array in non-increasing order */
4621 extern
4623  void** ptrarray, /**< pointer array where an element is to be deleted */
4624  int* intarray, /**< int array where an element is to be deleted */
4625  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4626  int pos, /**< array position of element to be deleted */
4627  int* len /**< pointer to length of arrays (will be decreased by 1) */
4628  );
4629 
4630 /** delete the element at the given position from two joint arrays of pointers/Bools, sorted by first array in non-increasing order */
4631 extern
4633  void** ptrarray, /**< pointer array where an element is to be inserted */
4634  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be inserted */
4635  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4636  int pos, /**< array position of element to be deleted */
4637  int* len /**< pointer to length of arrays (will be increased by 1) */
4638  );
4639 
4640 /** delete the element at the given position from three joint arrays of pointers/ints/ints, sorted by first array in non-increasing order */
4641 extern
4643  void** ptrarray, /**< pointer array where an element is to be deleted */
4644  int* intarray1, /**< first int array where an element is to be deleted */
4645  int* intarray2, /**< second int array where an element is to be deleted */
4646  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4647  int pos, /**< array position of element to be deleted */
4648  int* len /**< pointer to length of arrays (will be decreased by 1) */
4649  );
4650 
4651 /** delete the element at the given position from three joint arrays of pointers/Reals/ints, sorted by first array in non-increasing order */
4652 extern
4654  void** ptrarray, /**< pointer array where an element is to be deleted */
4655  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4656  int* intarray, /**< int array where an element is to be deleted */
4657  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4658  int pos, /**< array position of element to be deleted */
4659  int* len /**< pointer to length of arrays (will be decreased by 1) */
4660  );
4661 
4662 /** delete the element at the given position from three joint arrays of pointers/Reals/Bools, sorted by first array in non-increasing order */
4663 extern
4665  void** ptrarray, /**< pointer array where an element is to be deleted */
4666  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4667  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4668  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4669  int pos, /**< array position of element to be deleted */
4670  int* len /**< pointer to length of arrays (will be decreased by 1) */
4671  );
4672 
4673 /** delete the element at the given position from three joint arrays of pointers/pointers/Ints, sorted by first array in non-increasing order */
4674 extern
4676  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4677  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4678  int* intarray, /**< int array where an element is to be deleted */
4679  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4680  int pos, /**< array position of element to be deleted */
4681  int* len /**< pointer to length of arrays (will be decreased by 1) */
4682  );
4683 
4684 /** delete the element at the given position from three joint arrays of pointers/pointers/Reals, sorted by first array in non-increasing order */
4685 extern
4687  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4688  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4689  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4690  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4691  int pos, /**< array position of element to be deleted */
4692  int* len /**< pointer to length of arrays (will be decreased by 1) */
4693  );
4694 
4695 /** delete the element at the given position from four joint arrays of pointers/pointers/ints/ints, sorted by first array in non-increasing order */
4696 extern
4698  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4699  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4700  int* intarray1, /**< first int array where an element is to be deleted */
4701  int* intarray2, /**< second int array where an element is to be deleted */
4702  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4703  int pos, /**< array position of element to be deleted */
4704  int* len /**< pointer to length of arrays (will be decreased by 1) */
4705  );
4706 
4707 /** delete the element at the given position from four joint arrays of pointers/Reals/ints/ints, sorted by first array in non-increasing order */
4708 extern
4710  void** ptrarray, /**< pointer array where an element is to be deleted */
4711  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4712  int* intarray1, /**< first int array where an element is to be deleted */
4713  int* intarray2, /**< second int array where an element is to be deleted */
4714  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4715  int pos, /**< array position of element to be deleted */
4716  int* len /**< pointer to length of arrays (will be decreased by 1) */
4717  );
4718 
4719 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/ints, sorted by first array in non-increasing order */
4720 extern
4722  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4723  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4724  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4725  int* intarray, /**< int array where an element is to be deleted */
4726  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4727  int pos, /**< array position of element to be deleted */
4728  int* len /**< pointer to length of arrays (will be decreased by 1) */
4729  );
4730 
4731 /** deletes the element at the given position from four joint arrays of pointer/pointer/Reals/bools, sorted by first array in non-increasing order */
4732 extern
4734  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4735  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4736  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4737  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4738  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4739  int pos, /**< array position of element to be deleted */
4740  int* len /**< pointer to length of arrays (will be decreased by 1) */
4741  );
4742 
4743 /** deletes the element at the given position from four joint arrays of pointer/pointer/Longs/ints, sorted by first array in non-increasing order */
4744 extern
4746  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4747  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4748  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4749  int* intarray, /**< int array where an element is to be deleted */
4750  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4751  int pos, /**< array position of element to be deleted */
4752  int* len /**< pointer to length of arrays (will be decreased by 1) */
4753  );
4754 
4755 /** 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 */
4756 extern
4758  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4759  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4760  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4761  int* intarray1, /**< first int array where an element is to be deleted */
4762  int* intarray2, /**< second int array where an element is to be deleted */
4763  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
4764  int pos, /**< array position of element to be deleted */
4765  int* len /**< pointer to length of arrays (will be decreased by 1) */
4766  );
4767 
4768 /** delete the element at the given position from an array of Reals, sorted in non-increasing order */
4769 extern
4771  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4772  int pos, /**< array position of element to be deleted */
4773  int* len /**< pointer to length of arrays (will be decreased by 1) */
4774  );
4775 
4776 
4777 /** delete the element at the given position from three joint arrays of Reals/Bools/pointers, sorted by first array in non-increasing order */
4778 extern
4780  SCIP_Real* realarray, /**< SCIP_Real array to be sorted */
4781  SCIP_Bool* boolarray, /**< SCIP_Bool array to be permuted in the same way */
4782  void** ptrarray, /**< pointer array to be permuted in the same way */
4783  int pos, /**< array position of element to be deleted */
4784  int* len /**< pointer to length of arrays (will be decreased by 1) */
4785  );
4786 
4787 /** delete the element at the given position from two joint arrays of Reals/pointers, sorted by first array in non-increasing order */
4788 extern
4790  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4791  void** ptrarray, /**< pointer array where an element is to be deleted */
4792  int pos, /**< array position of element to be deleted */
4793  int* len /**< pointer to length of arrays (will be decreased by 1) */
4794  );
4795 
4796 /** delete the element at the given position from two joint arrays of Reals/ints, sorted by first array in non-increasing order */
4797 extern
4799  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4800  int* intarray, /**< pointer array where an element is to be deleted */
4801  int pos, /**< array position of element to be deleted */
4802  int* len /**< pointer to length of arrays (will be decreased by 1) */
4803  );
4804 
4805 /** delete the element at the given position from three joint arrays of Reals/ints/Longs, sorted by first array in non-increasing order */
4806 extern
4808  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4809  int* intarray, /**< int array where an element is to be deleted */
4810  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4811  int pos, /**< array position of element to be deleted */
4812  int* len /**< pointer to length of arrays (will be decreased by 1) */
4813  );
4814 
4815 /** delete the element at the given position from three joint arrays of Reals/ints/Pointer, sorted by first array in non-increasing order */
4816 extern
4818  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
4819  int* intarray, /**< int array where an element is to be deleted */
4820  void** ptrarray, /**< pointer array where an element is to be deleted */
4821  int pos, /**< array position of element to be deleted */
4822  int* len /**< pointer to length of arrays (will be decreased by 1) */
4823  );
4824 
4825 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
4826 extern
4828  SCIP_Real* realarray1, /**< first SCIP_Real array where an element is to be deleted */
4829  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
4830  void** ptrarray, /**< pointer array where an element is to be deleted */
4831  int pos, /**< array position of element to be deleted */
4832  int* len /**< pointer to length of arrays (will be decreased by 1) */
4833  );
4834 
4835 /** delete the element at the given position from three joint arrays of Reals/Reals/Pointer, sorted by first array in non-increasing order */
4836 extern
4838  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4839  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4840  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4841  int pos, /**< array position of element to be deleted */
4842  int* len /**< pointer to length of arrays (will be decreased by 1) */
4843  );
4844 
4845 /** delete the element at the given position from four joint arrays of Reals/pointers/pointers/ints, sorted by first array in non-increasing order */
4846 extern
4848  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4849  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4850  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4851  int* intarray, /**< int array where an element is to be deleted */
4852  int pos, /**< array position of element to be deleted */
4853  int* len /**< pointer to length of arrays (will be decreased by 1) */
4854  );
4855 
4856 /** 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 */
4857 extern
4859  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
4860  void** ptrarray1, /**< first pointer array where an element is to be deleted */
4861  void** ptrarray2, /**< second pointer array where an element is to be deleted */
4862  int* intarray1, /**< int array where an element is to be deleted */
4863  int* intarray2, /**< int array where an element is to be deleted */
4864  int pos, /**< array position of element to be deleted */
4865  int* len /**< pointer to length of arrays (will be decreased by 1) */
4866  );
4867 
4868 /** delete the element at the given position from four joint arrays of Reals/Long/Reals/ints, sorted by first array in non-increasing order */
4869 extern
4871  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4872  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4873  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4874  int* intarray, /**< int array where an element is to be deleted */
4875  int pos, /**< array position of element to be deleted */
4876  int* len /**< pointer to length of arrays (will be decreased by 1) */
4877  );
4878 
4879 /** delete the element at the given position from four joint arrays of Reals/Reals/ints/ints, sorted by first array in non-increasing order */
4880 extern
4882  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4883  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4884  int* intarray1, /**< int array where an element is to be deleted */
4885  int* intarray2, /**< int array where an element is to be deleted */
4886  int pos, /**< array position of element to be deleted */
4887  int* len /**< pointer to length of arrays (will be decreased by 1) */
4888  );
4889 
4890 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/ints, sorted by first array in non-increasing order */
4891 extern
4893  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4894  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4895  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4896  int* intarray, /**< int array where an element is to be deleted */
4897  int pos, /**< array position of element to be deleted */
4898  int* len /**< pointer to length of arrays (will be decreased by 1) */
4899  );
4900 
4901 /** delete the element at the given position from four joint arrays of Reals/Reals/Reals/pointers, sorted by first array in non-increasing order */
4902 extern
4904  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4905  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4906  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4907  void** ptrarray, /**< pointer array where an element is to be deleted */
4908  int pos, /**< array position of element to be deleted */
4909  int* len /**< pointer to length of arrays (will be decreased by 1) */
4910  );
4911 
4912 /** 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 */
4913 extern
4915  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4916  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4917  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4918  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
4919  void** ptrarray, /**< pointer array where an element is to be deleted */
4920  int pos, /**< array position of element to be deleted */
4921  int* len /**< pointer to length of arrays (will be decreased by 1) */
4922  );
4923 
4924 /** delete the element at the given position from six joint arrays of Reals/Reals/Reals/Bools/Bools/pointers, sorted by first array in non-increasing order */
4925 extern
4927  SCIP_Real* realarray1, /**< SCIP_Real array where an element is to be deleted */
4928  SCIP_Real* realarray2, /**< SCIP_Real array where an element is to be deleted */
4929  SCIP_Real* realarray3, /**< SCIP_Real array where an element is to be deleted */
4930  SCIP_Bool* boolarray1, /**< SCIP_Bool array where an element is to be deleted */
4931  SCIP_Bool* boolarray2, /**< SCIP_Bool array where an element is to be deleted */
4932  void** ptrarray, /**< pointer array where an element is to be deleted */
4933  int pos, /**< array position of element to be deleted */
4934  int* len /**< pointer to length of arrays (will be decreased by 1) */
4935  );
4936 
4937 /** delete the element at the given position from an array of ints in non-increasing order */
4938 extern
4940  int* intarray, /**< int array where an element is to be deleted */
4941  int pos, /**< array position of element to be deleted */
4942  int* len /**< pointer to length of arrays (will be decreased by 1) */
4943  );
4944 
4945 /** delete the element at the given position from two joint arrays of ints/ints, sorted by first array in non-increasing order */
4946 extern
4948  int* intarray1, /**< int array where an element is to be deleted */
4949  int* intarray2, /**< second int array where an element is to be deleted */
4950  int pos, /**< array position of element to be deleted */
4951  int* len /**< pointer to length of arrays (will be decreased by 1) */
4952  );
4953 
4954 /** delete the element at the given position from two joint arrays of ints/reals, sorted by first array in non-increasing order */
4955 extern
4957  int* intarray, /**< int array where an element is to be deleted */
4958  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4959  int pos, /**< array position of element to be deleted */
4960  int* len /**< pointer to length of arrays (will be decreased by 1) */
4961  );
4962 
4963 /** delete the element at the given position from three joint arrays of ints/ints/ints, sorted by first array in non-increasing order */
4964 extern
4966  int* intarray1, /**< int array where an element is to be deleted */
4967  int* intarray2, /**< second int array where an element is to be deleted */
4968  int* intarray3, /**< third int array where an element is to be deleted */
4969  int pos, /**< array position of element to be deleted */
4970  int* len /**< pointer to length of arrays (will be decreased by 1) */
4971  );
4972 
4973 /** delete the element at the given position from three joint arrays of ints/ints/SCIP_Longint, sorted by first array in non-increasing order */
4974 extern
4976  int* intarray1, /**< int array where an element is to be deleted */
4977  int* intarray2, /**< second int array where an element is to be deleted */
4978  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
4979  int pos, /**< array position of element to be deleted */
4980  int* len /**< pointer to length of arrays (will be decreased by 1) */
4981  );
4982 
4983 /** delete the element at the given position from three joint arrays of ints/ints/pointers, sorted by first array in non-increasing order */
4984 extern
4986  int* intarray1, /**< int array where an element is to be deleted */
4987  int* intarray2, /**< second int array where an element is to be deleted */
4988  void** ptrarray, /**< pointer array where an element is to be deleted */
4989  int pos, /**< array position of element to be deleted */
4990  int* len /**< pointer to length of arrays (will be decreased by 1) */
4991  );
4992 
4993 /** delete the element at the given position from three joint arrays of ints/ints/Reals, sorted by first array in non-increasing order */
4994 extern
4996  int* intarray1, /**< int array where an element is to be deleted */
4997  int* intarray2, /**< second int array where an element is to be deleted */
4998  SCIP_Real* realarray, /**< real array where an element is to be deleted */
4999  int pos, /**< array position of element to be deleted */
5000  int* len /**< pointer to length of arrays (will be decreased by 1) */
5001  );
5002 
5003 /** delete the element at the given position from two joint arrays of ints/pointers, sorted by first array in non-increasing order */
5004 extern
5006  int* intarray, /**< int array where an element is to be deleted */
5007  void** ptrarray, /**< pointer array where an element is to be deleted */
5008  int pos, /**< array position of element to be deleted */
5009  int* len /**< pointer to length of arrays (will be decreased by 1) */
5010  );
5011 
5012 /** delete the element at the given position from four joint arrays of ints/ints/ints/pointers, sorted by first array in non-decreasing order */
5013 extern
5015  int* intarray1, /**< int array where an element is to be deleted */
5016  int* intarray2, /**< int array where an element is to be deleted */
5017  int* intarray3, /**< int array where an element is to be deleted */
5018  void** ptrarray, /**< pointer array where an element is to be deleted */
5019  int pos, /**< array position of element to be deleted */
5020  int* len /**< pointer to length of arrays (will be decreased by 1) */
5021  );
5022 
5023 /** delete the element at the given position from four joint arrays of ints/ints/ints/reals, sorted by first array in non-decreasing order */
5024 extern
5026  int* intarray1, /**< int array where an element is to be deleted */
5027  int* intarray2, /**< int array where an element is to be deleted */
5028  int* intarray3, /**< int array where an element is to be deleted */
5029  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
5030  int pos, /**< array position of element to be deleted */
5031  int* len /**< pointer to length of arrays (will be decreased by 1) */
5032  );
5033 
5034 /** delete the element at the given position from four joint arrays of ints/pointers/ints/reals, sorted by first array in non-decreasing order */
5035 extern
5037  int* intarray1, /**< int array where an element is to be deleted */
5038  void** ptrarray, /**< pointer array where an element is to be deleted */
5039  int* intarray2, /**< int array where an element is to be deleted */
5040  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
5041  int pos, /**< array position of element to be deleted */
5042  int* len /**< pointer to length of arrays (will be decreased by 1) */
5043  );
5044 
5045 /** delete the element at the given position from an array of Longints, sorted in non-increasing order */
5046 extern
5048  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5049  int pos, /**< array position of element to be deleted */
5050  int* len /**< pointer to length of arrays (will be decreased by 1) */
5051  );
5052 
5053 /** delete the element at the given position from three two arrays of Long/pointer, sorted by the first array in non-increasing order */
5054 extern
5056  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5057  void** ptrarray, /**< pointer array where an element is to be deleted */
5058  int pos, /**< array position of element to be deleted */
5059  int* len /**< pointer to length of arrays (will be decreased by 1) */
5060  );
5061 
5062 /** delete the element at the given position from three joint arrays of Long/pointer/int, sorted by the first array in non-increasing order */
5063 extern
5065  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5066  void** ptrarray, /**< pointer array where an element is to be deleted */
5067  int* intarray, /**< int array where an element is to be deleted */
5068  int pos, /**< array position of element to be deleted */
5069  int* len /**< pointer to length of arrays (will be decreased by 1) */
5070  );
5071 
5072 /** 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 */
5073 extern
5075  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5076  void** ptrarray, /**< pointer array where an element is to be deleted */
5077  SCIP_Real* realarray, /**< SCIP_Real array where an element is to be deleted */
5078  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
5079  int pos, /**< array position of element to be deleted */
5080  int* len /**< pointer to length of arrays (will be decreased by 1) */
5081  );
5082 
5083 /** 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 */
5084 extern
5086  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5087  void** ptrarray, /**< pointer array where an element is to be deleted */
5088  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
5089  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
5090  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
5091  int pos, /**< array position of element to be deleted */
5092  int* len /**< pointer to length of arrays (will be decreased by 1) */
5093  );
5094 
5095 /** 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 */
5096 extern
5098  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5099  void** ptrarray, /**< pointer array where an element is to be deleted */
5100  SCIP_Real* realarray, /**< first SCIP_Real array where an element is to be deleted */
5101  SCIP_Real* realarray2, /**< second SCIP_Real array where an element is to be deleted */
5102  int* intarray, /**< int array where an element is to be deleted */
5103  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
5104  int pos, /**< array position of element to be deleted */
5105  int* len /**< pointer to length of arrays (will be decreased by 1) */
5106  );
5107 
5108 
5109 /** delete the element at the given position from four joint arrays of Long/pointer/pointer/ints, sorted by first array in non-increasing order */
5110 extern
5112  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5113  void** ptrarray1, /**< first pointer array where an element is to be deleted */
5114  void** ptrarray2, /**< second pointer array where an element is to be deleted */
5115  int* intarray, /**< int array where an element is to be deleted */
5116  int pos, /**< array position of element to be deleted */
5117  int* len /**< pointer to length of arrays (will be decreased by 1) */
5118  );
5119 
5120 /** 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 */
5121 extern
5123  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5124  void** ptrarray1, /**< first pointer array where an element is to be deleted */
5125  void** ptrarray2, /**< second pointer array where an element is to be deleted */
5126  int* intarray1, /**< first int array where an element is to be deleted */
5127  int* intarray2, /**< second int array where an element is to be deleted */
5128  int pos, /**< array position of element to be deleted */
5129  int* len /**< pointer to length of arrays (will be decreased by 1) */
5130  );
5131 
5132 /** 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 */
5133 extern
5135  SCIP_Longint* longarray, /**< SCIP_Longint array where an element is to be deleted */
5136  void** ptrarray1, /**< first pointer array where an element is to be deleted */
5137  void** ptrarray2, /**< second pointer array where an element is to be deleted */
5138  SCIP_Bool* boolarray, /**< SCIP_Bool array where an element is to be deleted */
5139  int* intarray, /**< int array where an element is to be deleted */
5140  int pos, /**< array position of element to be deleted */
5141  int* len /**< pointer to length of arrays (will be decreased by 1) */
5142  );
5143 
5144 /** 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 */
5145 extern
5147  void** ptrarray, /**< pointer array to be sorted */
5148  int* intarray1, /**< first int array to be permuted in the same way */
5149  int* intarray2, /**< second int array to be permuted in the same way */
5150  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
5151  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
5152  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
5153  int pos, /**< array position of element to be deleted */
5154  int* len /**< pointer to length of arrays (will be decreased by 1) */
5155  );
5156 
5157 /** 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 */
5158 extern
5160  int* intarray1, /**< int array to be sorted */
5161  void** ptrarray, /**< pointer array to be permuted in the same way */
5162  int* intarray2, /**< second int array to be permuted in the same way */
5163  int* intarray3, /**< thrid int array to be permuted in the same way */
5164  SCIP_Bool* boolarray1, /**< first SCIP_Bool array to be permuted in the same way */
5165  SCIP_Bool* boolarray2, /**< second SCIP_Bool array to be permuted in the same way */
5166  int pos, /**< array position of element to be deleted */
5167  int* len /**< pointer to length of arrays (will be decreased by 1) */
5168  );
5169 
5170 
5171 /* upwards binary search */
5172 
5173 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5174  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5175  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5176  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5177  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5178  */
5179 extern
5181  int* indarray, /**< index array to be searched */
5182  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
5183  void* dataptr, /**< pointer to data field that is given to the external compare method */
5184  int val, /**< value to search */
5185  int len, /**< length of array */
5186  int* pos /**< pointer to store position of element */
5187  );
5188 
5189 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5190  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5191  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5192  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5193  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5194  */
5195 extern
5197  void** ptrarray, /**< pointer array to be searched */
5198  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
5199  void* val, /**< value to search */
5200  int len, /**< length of array */
5201  int* pos /**< pointer to store position of element */
5202  );
5203 
5204 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5205  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5206  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5207  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5208  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5209  */
5210 extern
5212  SCIP_Real* realarray, /**< SCIP_Real array to be searched */
5213  SCIP_Real val, /**< value to search */
5214  int len, /**< length of array */
5215  int* pos /**< pointer to store position of element */
5216  );
5217 
5218 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5219  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5220  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5221  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5222  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5223  */
5224 extern
5226  int* intarray, /**< int array to be searched */
5227  int val, /**< value to search */
5228  int len, /**< length of array */
5229  int* pos /**< pointer to store position of element */
5230  );
5231 
5232 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5233  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5234  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5235  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5236  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5237  */
5238 extern
5240  SCIP_Longint* longarray, /**< SCIP_Longint array to be searched */
5241  SCIP_Longint val, /**< value to search */
5242  int len, /**< length of array */
5243  int* pos /**< pointer to store position of element */
5244  );
5245 
5246 
5247 /* downwards binary search */
5248 
5249 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5250  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5251  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5252  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5253  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5254  */
5255 extern
5257  int* indarray, /**< index array to be searched */
5258  SCIP_DECL_SORTINDCOMP((*indcomp)), /**< data element comparator */
5259  void* dataptr, /**< pointer to data field that is given to the external compare method */
5260  int val, /**< value to search */
5261  int len, /**< length of array */
5262  int* pos /**< pointer to store position of element */
5263  );
5264 
5265 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5266  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5267  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5268  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5269  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5270  */
5271 extern
5273  void** ptrarray, /**< pointer array to be searched */
5274  SCIP_DECL_SORTPTRCOMP((*ptrcomp)), /**< data element comparator */
5275  void* val, /**< value to search */
5276  int len, /**< length of array */
5277  int* pos /**< pointer to store position of element */
5278  );
5279 
5280 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5281  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5282  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5283  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5284  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5285  */
5286 extern
5288  SCIP_Real* realarray, /**< SCIP_Real array to be searched */
5289  SCIP_Real val, /**< value to search */
5290  int len, /**< length of array */
5291  int* pos /**< pointer to store position of element */
5292  );
5293 
5294 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5295  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5296  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5297  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5298  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5299  */
5300 extern
5302  int* intarray, /**< int array to be searched */
5303  int val, /**< value to search */
5304  int len, /**< length of array */
5305  int* pos /**< pointer to store position of element */
5306  );
5307 
5308 /** Finds the position at which 'val' is located in the sorted vector by binary search.
5309  * If the element exists, the method returns TRUE and stores the position of the element in '*pos'.
5310  * If the element does not exist, the method returns FALSE and stores the position of the element that follows
5311  * 'val' in the ordering in '*pos', i.e., '*pos' is the position at which 'val' would be inserted.
5312  * Note that if the element is not found, '*pos' may be equal to len if all existing elements are smaller than 'val'.
5313  */
5314 extern
5316  SCIP_Longint* longarray, /**< SCIP_Longint array to be searched */
5317  SCIP_Longint val, /**< value to search */
5318  int len, /**< length of array */
5319  int* pos /**< pointer to store position of element */
5320  );
5321 
5322 /**@} */
5323 
5324 /**@defgroup MiscellaneousMethods Miscellaneous Methods
5325  *
5326  * Below you find a list of miscellaneous methods grouped by different categories
5327  *@{
5328  */
5329 
5330 /*
5331  * Numerical methods
5332  */
5333 
5334 /**@defgroup NumericalMethods Numerical Methods
5335  *
5336  *@{
5337  */
5338 
5339 /** returns the machine epsilon: the smallest number eps > 0, for which 1.0 + eps > 1.0 */
5340 extern
5342  void
5343  );
5344 
5345 /** calculates the greatest common divisor of the two given values */
5346 extern
5348  SCIP_Longint val1, /**< first value of greatest common devisor calculation */
5349  SCIP_Longint val2 /**< second value of greatest common devisor calculation */
5350  );
5351 
5352 /** calculates the smallest common multiple of the two given values */
5353 extern
5355  SCIP_Longint val1, /**< first value of smallest common multiple calculation */
5356  SCIP_Longint val2 /**< second value of smallest common multiple calculation */
5357  );
5358 
5359 /** converts a real number into a (approximate) rational representation, and returns TRUE iff the conversion was
5360  * successful
5361  */
5362 extern
5364  SCIP_Real val, /**< real value r to convert into rational number */
5365  SCIP_Real mindelta, /**< minimal allowed difference r - q of real r and rational q = n/d */
5366  SCIP_Real maxdelta, /**< maximal allowed difference r - q of real r and rational q = n/d */
5367  SCIP_Longint maxdnom, /**< maximal denominator allowed */
5368  SCIP_Longint* nominator, /**< pointer to store the nominator n of the rational number */
5369  SCIP_Longint* denominator /**< pointer to store the denominator d of the rational number */
5370  );
5371 
5372 /** tries to find a value, such that all given values, if scaled with this value become integral in relative allowed
5373  * difference in between mindelta and maxdelta
5374  */
5375 extern
5377  SCIP_Real* vals, /**< values to scale */
5378  int nvals, /**< number of values to scale */
5379  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
5380  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
5381  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
5382  SCIP_Real maxscale, /**< maximal allowed scalar */
5383  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
5384  SCIP_Bool* success /**< stores whether returned value is valid */
5385  );
5386 
5387 /** given a (usually very small) interval, tries to find a rational number with simple denominator (i.e. a small
5388  * number, probably multiplied with powers of 10) out of this interval; returns TRUE iff a valid rational
5389  * number inside the interval was found
5390  */
5391 extern
5393  SCIP_Real lb, /**< lower bound of the interval */
5394  SCIP_Real ub, /**< upper bound of the interval */
5395  SCIP_Longint maxdnom, /**< maximal denominator allowed for resulting rational number */
5396  SCIP_Longint* nominator, /**< pointer to store the nominator n of the rational number */
5397  SCIP_Longint* denominator /**< pointer to store the denominator d of the rational number */
5398  );
5399 
5400 /** given a (usually very small) interval, selects a value inside this interval; it is tried to select a rational number
5401  * with simple denominator (i.e. a small number, probably multiplied with powers of 10);
5402  * if no valid rational number inside the interval was found, selects the central value of the interval
5403  */
5404 extern
5406  SCIP_Real lb, /**< lower bound of the interval */
5407  SCIP_Real ub, /**< upper bound of the interval */
5408  SCIP_Longint maxdnom /**< maximal denominator allowed for resulting rational number */
5409  );
5410 
5411 /* The C99 standard defines the function (or macro) isfinite.
5412  * On MacOS X, isfinite is also available.
5413  * From the BSD world, there comes a function finite.
5414  * On SunOS, finite is also available.
5415  * In the MS compiler world, there is a function _finite.
5416  * As last resort, we check whether x == x does not hold, but this works only for NaN's, not for infinities!
5417  */
5418 #if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L || defined(__APPLE__)
5419 #define SCIPisFinite isfinite
5420 #elif defined(_BSD_SOURCE) || defined(__sun)
5421 #define SCIPisFinite finite
5422 #elif defined(_MSC_VER)
5423 #define SCIPisFinite _finite
5424 #else
5425 #define SCIPisFinite(x) ((x) == (x))
5426 #endif
5427 
5428 /* In debug mode, the following methods are implemented as function calls to ensure
5429  * type validity.
5430  */
5431 
5432 /** returns the relative difference: (val1-val2)/max(|val1|,|val2|,1.0) */
5433 extern
5435  SCIP_Real val1, /**< first value to be compared */
5436  SCIP_Real val2 /**< second value to be compared */
5437  );
5438 
5439 #ifdef NDEBUG
5440 
5441 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
5442  * speed up the algorithms.
5443  */
5444 
5445 #define SCIPrelDiff(val1, val2) ( ((val1)-(val2))/(MAX3(1.0,REALABS(val1),REALABS(val2))) )
5446 
5447 #endif
5448 
5449 /**@} */
5450 
5451 
5452 /*
5453  * Random Numbers
5454  */
5455 
5456 /**@defgroup RandomNumbers Random Numbers
5457  *
5458  *@{
5459  */
5460 
5461 /** returns a random integer between minrandval and maxrandval */
5462 extern
5463 int SCIPgetRandomInt(
5464  int minrandval, /**< minimal value to return */
5465  int maxrandval, /**< maximal value to return */
5466  unsigned int* seedp /**< pointer to seed value */
5467  );
5468 
5469 /** returns a random real between minrandval and maxrandval */
5470 extern
5472  SCIP_Real minrandval, /**< minimal value to return */
5473  SCIP_Real maxrandval, /**< maximal value to return */
5474  unsigned int* seedp /**< pointer to seed value */
5475  );
5476 
5477 /**@} */
5478 
5479 
5480 /*
5481  * Additional math functions
5482  */
5483 
5484 /**@defgroup AdditionalMathFunctions Additional math functions
5485  *
5486  *@{
5487  */
5488 
5489 /** calculates a binomial coefficient n over m, choose m elements out of n, maximal value will be 33 over 16 (because
5490  * 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
5491  * big numbers or an negative value m (and m < n) and -1 will be returned
5492  */
5493 extern
5495  int n, /**< number of different elements */
5496  int m /**< number to choose out of the above */
5497  );
5498 
5499 /**@} */
5500 
5501 /*
5502  * Permutations / Shuffling
5503  */
5504 
5505 /**@defgroup PermutationsShuffling Permutations Shuffling
5506  *
5507  *@{
5508  */
5509 
5510 /** swaps two ints */
5511 extern
5512 void SCIPswapInts(
5513  int* value1, /**< pointer to first integer */
5514  int* value2 /**< pointer ti second integer */
5515  );
5516 
5517 /** swaps the addresses of two pointers */
5518 extern
5519 void SCIPswapPointers(
5520  void** pointer1, /**< first pointer */
5521  void** pointer2 /**< second pointer */
5522  );
5523 
5524 /** randomly shuffles parts of an integer array using the Fisher-Yates algorithm */
5525 extern
5526 void SCIPpermuteIntArray(
5527  int* array, /**< array to be shuffled */
5528  int begin, /**< first index that should be subject to shuffling (0 for whole array) */
5529  int end, /**< last index that should be subject to shuffling (array size for whole
5530  * array)
5531  */
5532  unsigned int* randseed /**< seed value for the random generator */
5533  );
5534 
5535 /** randomly shuffles parts of an array using the Fisher-Yates algorithm */
5536 extern
5537 void SCIPpermuteArray(
5538  void** array, /**< array to be shuffled */
5539  int begin, /**< first index that should be subject to shuffling (0 for whole array) */
5540  int end, /**< last index that should be subject to shuffling (array size for whole
5541  * array)
5542  */
5543  unsigned int* randseed /**< pointer to seed value for the random generator */
5544  );
5545 
5546 /** draws a random subset of disjoint elements from a given set of disjoint elements;
5547  * this implementation is suited for the case that nsubelems is considerably smaller then nelems
5548  */
5549 extern
5551  void** set, /**< original set, from which elements should be drawn */
5552  int nelems, /**< number of elements in original set */
5553  void** subset, /**< subset in which drawn elements should be stored */
5554  int nsubelems, /**< number of elements that should be drawn and stored */
5555  unsigned int randseed /**< seed value for random generator */
5556  );
5557 
5558 
5559 
5560 /**@} */
5561 
5562 
5563 /*
5564  * Arrays
5565  */
5566 
5567 /**@defgroup Arrays Arrays
5568  *
5569  *@{
5570  */
5571 
5572 
5573 /** computes set intersection (duplicates removed) of two arrays that are ordered ascendingly */
5574 extern
5576  int* array1, /**< first array (in ascending order) */
5577  int narray1, /**< number of entries of first array */
5578  int* array2, /**< second array (in ascending order) */
5579  int narray2, /**< number of entries of second array */
5580  int* intersectarray, /**< intersection of array1 and array2
5581  * (note: it is possible to use array1 for this input argument) */
5582  int* nintersectarray /**< pointer to store number of entries of intersection array
5583  * (note: it is possible to use narray1 for this input argument) */
5584  );
5585 
5586 /** computes set difference (duplicates removed) of two arrays that are ordered ascendingly */
5587 extern
5589  int* array1, /**< first array (in ascending order) */
5590  int narray1, /**< number of entries of first array */
5591  int* array2, /**< second array (in ascending order) */
5592  int narray2, /**< number of entries of second array */
5593  int* setminusarray, /**< array to store entries of array1 that are not an entry of array2
5594  * (note: it is possible to use array1 for this input argument) */
5595  int* nsetminusarray /**< pointer to store number of entries of setminus array
5596  * (note: it is possible to use narray1 for this input argument) */
5597  );
5598 
5599 
5600 /**@} */
5601 
5602 
5603 /*
5604  * Strings
5605  */
5606 
5607 /**@defgroup StringMethods String Methods
5608  *
5609  *@{
5610  */
5611 
5612 /** copies characters from 'src' to 'dest', copying is stopped when either the 'stop' character is reached or after
5613  * 'cnt' characters have been copied, whichever comes first.
5614  *
5615  * @note undefined behaviuor on overlapping arrays
5616  */
5617 extern
5618 int SCIPmemccpy(
5619  char* dest, /**< destination pointer to copy to */
5620  const char* src, /**< source pointer to copy to */
5621  char stop, /**< character when found stop copying */
5622  unsigned int cnt /**< maximal number of characters to copy too */
5623  );
5624 
5625 /** prints an error message containing of the given string followed by a string describing the current system error;
5626  * prefers to use the strerror_r method, which is threadsafe; on systems where this method does not exist,
5627  * NO_STRERROR_R should be defined (see INSTALL), in this case, srerror is used which is not guaranteed to be
5628  * threadsafe (on SUN-systems, it actually is)
5629  */
5630 extern
5631 void SCIPprintSysError(
5632  const char* message /**< first part of the error message, e.g. the filename */
5633  );
5634 
5635 /** extracts tokens from strings - wrapper method for strtok_r() */
5636 extern
5637 char* SCIPstrtok(
5638  char* s, /**< string to parse */
5639  const char* delim, /**< delimiters for parsing */
5640  char** ptrptr /**< pointer to working char pointer - must stay the same while parsing */
5641  );
5642 
5643 /** translates the given string into a string where symbols ", ', and spaces are escaped with a \ prefix */
5644 extern
5645 void SCIPescapeString(
5646  char* t, /**< target buffer to store escaped string */
5647  int bufsize, /**< size of buffer t */
5648  const char* s /**< string to transform into escaped string */
5649  );
5650 
5651 /** safe version of snprintf */
5652 extern
5653 int SCIPsnprintf(
5654  char* t, /**< target string */
5655  int len, /**< length of the string to copy */
5656  const char* s, /**< source string */
5657  ... /**< further parameters */
5658  );
5659 
5660 /** 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
5661  *
5662  * @return Returns TRUE if a value could be extracted, otherwise FALSE
5663  */
5664 extern
5666  const char* str, /**< string to search */
5667  int* value, /**< pointer to store the parsed value */
5668  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5669  );
5670 
5671 /** 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
5672  *
5673  * @return Returns TRUE if a value could be extracted, otherwise FALSE
5674  */
5675 extern
5677  const char* str, /**< string to search */
5678  SCIP_Real* value, /**< pointer to store the parsed value */
5679  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5680  );
5681 
5682 /** copies the first size characters between a start and end character of str into token, if no error occured endptr
5683  * will point to the position after the read part, otherwise it will point to @p str
5684  */
5685 extern
5686 void SCIPstrCopySection(
5687  const char* str, /**< string to search */
5688  char startchar, /**< character which defines the beginning */
5689  char endchar, /**< character which defines the ending */
5690  char* token, /**< string to store the copy */
5691  int size, /**< size of the token char array */
5692  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
5693  );
5694 
5695 /**@} */
5696 
5697 /*
5698  * File methods
5699  */
5700 
5701 /**@defgroup FileMethods File Methods
5702  *
5703  *@{
5704  */
5705 
5706 /** returns, whether the given file exists */
5707 extern
5709  const char* filename /**< file name */
5710  );
5711 
5712 /** splits filename into path, name, and extension */
5713 extern
5714 void SCIPsplitFilename(
5715  char* filename, /**< filename to split; is destroyed (but not freed) during process */
5716  char** path, /**< pointer to store path, or NULL if not needed */
5717  char** name, /**< pointer to store name, or NULL if not needed */
5718  char** extension, /**< pointer to store extension, or NULL if not needed */
5719  char** compression /**< pointer to store compression extension, or NULL if not needed */
5720  );
5721 
5722 /**@} */
5723 
5724 /**@} */
5725 
5726 #ifdef __cplusplus
5727 }
5728 #endif
5729 
5730 #endif
void SCIPsortPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int len)
void SCIPsortDownPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortRealInt(SCIP_Real *realarray, int *intarray, int len)
void SCIPpermuteArray(void **array, int begin, int end, unsigned int *randseed)
void SCIPsortedvecDelPosRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)
void SCIPsortLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)
void SCIPsortRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int len)
SCIP_RETCODE SCIPbtnodeCreate(SCIP_BT *tree, SCIP_BTNODE **node, void *dataptr)
void SCIPsortedvecInsertReal(SCIP_Real *realarray, SCIP_Real keyval, int *len, int *pos)
void SCIPsortPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int len)
void ** SCIPdigraphGetSuccessorsData(SCIP_DIGRAPH *digraph, int node)
int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)
void SCIPsortedvecDelPosRealInt(SCIP_Real *realarray, int *intarray, int pos, int *len)
void SCIPsortedvecDelPosRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, int pos, int *len)
void SCIPbtnodeFree(SCIP_BT *tree, SCIP_BTNODE **node)
void SCIPsortedvecInsertLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Longint keyval, void *field1val, int field2val, int *len, int *pos)
SCIP_Real SCIPnormalGetCriticalValue(SCIP_CONFIDENCELEVEL clevel)
void SCIPsortedvecInsertDownLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int field4val, int *len, int *pos)
void SCIPsortDownLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)
struct SCIP_PQueue SCIP_PQUEUE
Definition: type_misc.h:63
void SCIPsortIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int len)
void SCIPsortedvecInsertDownRealInt(SCIP_Real *realarray, int *intarray, SCIP_Real keyval, int field1val, int *len, int *pos)
void SCIPsortedvecDelPosDownRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int pos, int *len)
void SCIPsortedvecInsertIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int keyval, int field1val, int field2val, void *field3val, int *len, int *pos)
int SCIPmemccpy(char *dest, const char *src, char stop, unsigned int cnt)
void SCIPsortedvecInsertIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int keyval, void *field1val, int field2val, int field3val, SCIP_Bool field4val, SCIP_Bool field5val, int *len, int *pos)
SCIP_Real SCIPerf(SCIP_Real x)
void SCIPsortDownRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)
void SCIPsortDownRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int len)
void SCIPsortedvecDelPosLongPtr(SCIP_Longint *longarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecInsertPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int *len, int *pos)
void SCIPsortedvecInsertDownReal(SCIP_Real *realarray, SCIP_Real keyval, int *len, int *pos)
void SCIPsortedvecInsertLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int field4val, int *len, int *pos)
void SCIPsparseSolGetFirstSol(SCIP_SPARSESOL *sparsesol, SCIP_Longint *sol, int nvars)
void SCIPsortedvecDelPosLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)
type definitions for miscellaneous datastructures
void * SCIPhashmapListGetOrigin(SCIP_HASHMAPLIST *hashmaplist)
SCIP_BTNODE * SCIPbtnodeGetSibling(SCIP_BTNODE *node)
void SCIPsortRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)
void SCIPsortRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int len)
SCIP_RETCODE SCIPprofileDeleteCore(SCIP_PROFILE *profile, int left, int right, int height)
void * SCIPbtnodeGetData(SCIP_BTNODE *node)
void SCIPsortInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortedvecDelPosRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int pos, int *len)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
void SCIPsortedvecDelPosDownPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecDelPosLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int pos, int *len)
void SCIPsortedvecInsertDownLong(SCIP_Longint *longarray, SCIP_Longint keyval, int *len, int *pos)
void SCIPsortedvecInsertDownPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)
void SCIPsortRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int len)
void SCIPdigraphFreeComponents(SCIP_DIGRAPH *digraph)
void SCIPsortRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)
void SCIPsortDownLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)
void SCIPsortedvecDelPosDownIntIntInt(int *intarray1, int *intarray2, int *intarray3, int pos, int *len)
void SCIPsortedvecInsertDownRealPtr(SCIP_Real *realarray, void **ptrarray, SCIP_Real keyval, void *field1val, int *len, int *pos)
void SCIPsortDownPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecInsertPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int *len, int *pos)
void SCIPsortRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int len)
void SCIPsortIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int len)
void SCIPsortedvecInsertRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real keyval, int field2val, int field3val, int *len, int *pos)
void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
void SCIPsortPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosDownRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int pos, int *len)
void SCIPsortDownLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int len)
void SCIPsortedvecInsertDownIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int keyval, void *field1val, int field2val, SCIP_Real field3val, int *len, int *pos)
SCIP_RETCODE SCIPdigraphComputeUndirectedComponents(SCIP_DIGRAPH *digraph, int minsize, int *components, int *ncomponents)
void SCIPsortDownPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosIntIntInt(int *intarray1, int *intarray2, int *intarray3, int pos, int *len)
struct SCIP_Digraph SCIP_DIGRAPH
Definition: type_misc.h:111
void SCIPsortedvecDelPosDownRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertDownLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int *len, int *pos)
void SCIPsortDownRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int len)
void SCIPsortDownIntReal(int *intarray, SCIP_Real *realarray, int len)
int * SCIPdigraphGetSuccessors(SCIP_DIGRAPH *digraph, int node)
void SCIPsortDownRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int len)
void SCIPsortedvecInsertDownInt(int *intarray, int keyval, int *len, int *pos)
void SCIPsortIntIntInt(int *intarray1, int *intarray2, int *intarray3, int len)
SCIP_RETCODE SCIPqueueInsert(SCIP_QUEUE *queue, void *elem)
void SCIPsortedvecDelPosDownReal(SCIP_Real *realarray, int pos, int *len)
void SCIPsortDownRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPsplitFilename(char *filename, char **path, char **name, char **extension, char **compression)
void SCIPsortedvecInsertPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int field4val, int *len, int *pos)
SCIP_Bool SCIPsparseSolGetNextSol(SCIP_SPARSESOL *sparsesol, SCIP_Longint *sol, int nvars)
int SCIPprofileGetTime(SCIP_PROFILE *profile, int pos)
void SCIPsortedvecDelPosDownPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void * SCIPhashmapListGetImage(SCIP_HASHMAPLIST *hashmaplist)
void SCIPsortedvecDelPosPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertDownIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int keyval, int field1val, int field2val, SCIP_Real field3val, int *len, int *pos)
void SCIPsortedvecInsertIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)
struct SCIP_Bt SCIP_BT
Definition: type_misc.h:117
void SCIPsortedvecInsertPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int *len, int *pos)
void SCIPgmlWriteClosing(FILE *file)
void SCIPsortedvecInsertDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int keyval, int *len, int *pos)
void SCIPsortDownPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
Definition: type_message.h:50
void SCIPswapPointers(void **pointer1, void **pointer2)
void SCIPsortedvecDelPosPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPbtnodeSetRightchild(SCIP_BTNODE *node, SCIP_BTNODE *right)
SCIP_Longint SCIPcalcBinomCoef(int n, int m)
SCIP_Bool SCIPsortedvecFindDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int val, int len, int *pos)
void SCIPsortedvecDelPosLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)
struct SCIP_HashMap SCIP_HASHMAP
Definition: type_misc.h:78
void SCIPsortedvecInsertLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, int field3val, int *len, int *pos)
void SCIPsortedvecDelPosLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int pos, int *len)
void SCIPsortIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int len)
void SCIPsortedvecDelPosDownLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int pos, int *len)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
void SCIPsortedvecDelPosDownLongPtrPtrIntInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)
struct SCIP_ResourceActivity SCIP_RESOURCEACTIVITY
Definition: type_misc.h:99
void SCIPsortedvecInsertRealPtr(SCIP_Real *realarray, void **ptrarray, SCIP_Real keyval, void *field1val, int *len, int *pos)
void SCIPsortedvecInsertDownIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int keyval, int field1val, void *field2val, int *len, int *pos)
void SCIPsortedvecDelPosDownInt(int *intarray, int pos, int *len)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
void SCIPsortedvecInsertLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, SCIP_Bool field3val, int field4val, int *len, int *pos)
int SCIPprofileGetEarliestFeasibleStart(SCIP_PROFILE *profile, int est, int lst, int duration, int height, SCIP_Bool *infeasible)
SCIP_HASHMAPLIST * SCIPhashmapGetList(SCIP_HASHMAP *hashmap, int listindex)
void SCIPsortedvecDelPosDownIntInt(int *intarray1, int *intarray2, int pos, int *len)
void SCIPsortedvecDelPosDownRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecInsertPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int field3val, int *len, int *pos)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPsortedvecInsertRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Bool field1val, void *field2val, int *len, int *pos)
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPdigraphSetSizes(SCIP_DIGRAPH *digraph, int *sizes)
void SCIPsortedvecInsertLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, SCIP_Bool field4val, int *len, int *pos)
void SCIPsortDownIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int len)
void SCIPsortedvecInsertIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int keyval, int field1val, int field2val, SCIP_Real field3val, int *len, int *pos)
void SCIPsortDownPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPdigraphPrintComponents(SCIP_DIGRAPH *digraph, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
void SCIPsortPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosLong(SCIP_Longint *longarray, int pos, int *len)
SCIP_VAR * SCIPactivityGetVar(SCIP_RESOURCEACTIVITY *activity)
void SCIPsortedvecDelPosRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int pos, int *len)
void * SCIPpqueueFirst(SCIP_PQUEUE *pqueue)
void SCIPsortedvecInsertIntReal(int *intarray, SCIP_Real *realarray, int keyval, SCIP_Real field1val, int *len, int *pos)
void SCIPsortedvecInsertDownPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, int *len, int *pos)
void SCIPsortLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)
void SCIPhashtableClear(SCIP_HASHTABLE *hashtable)
SCIP_RETCODE SCIPcomputeArraysIntersection(int *array1, int narray1, int *array2, int narray2, int *intersectarray, int *nintersectarray)
void SCIPsortDownIntInt(int *intarray1, int *intarray2, int len)
int SCIPdigraphGetNComponents(SCIP_DIGRAPH *digraph)
SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)
void SCIPpqueueFree(SCIP_PQUEUE **pqueue)
SCIP_RETCODE SCIPprofileInsertCore(SCIP_PROFILE *profile, int left, int right, int height, int *pos, SCIP_Bool *infeasible)
void SCIPsortIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int len)
type definitions for return codes for SCIP methods
SCIP_Real SCIPselectSimpleValue(SCIP_Real lb, SCIP_Real ub, SCIP_Longint maxdnom)
void SCIPsortedvecDelPosDownIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int pos, int *len)
void SCIPsortedvecDelPosIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int pos, int *len)
void SCIPsortDownIntPtr(int *intarray, void **ptrarray, int len)
void SCIPsortedvecInsertDownRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int *len, int *pos)
void SCIPdigraphGetComponent(SCIP_DIGRAPH *digraph, int compidx, int **nodes, int *nnodes)
void SCIPsortDownRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int len)
void SCIPsortedvecInsertDownRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real keyval, void *field1val, void *field2val, int intval1, int intval2, int *len, int *pos)
SCIP_Bool SCIPhashmapIsEmpty(SCIP_HASHMAP *hashmap)
void SCIPsortedvecInsertDownIntInt(int *intarray1, int *intarray2, int keyval, int field1val, int *len, int *pos)
void SCIPsortedvecInsertDownRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)
void SCIPsortedvecInsertDownRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Bool field1val, void *field2val, int *len, int *pos)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
void SCIPsortedvecDelPosPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecDelPosRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int pos, int *len)
SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)
void SCIPsortIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int len)
void SCIPsortedvecInsertDownLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, SCIP_Longint keyval, void *field1val, void *field2val, SCIP_Bool field3val, int field4val, int *len, int *pos)
void SCIPsortDown(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortedvecDelPosIntInt(int *intarray1, int *intarray2, int pos, int *len)
struct SCIP_HashTable SCIP_HASHTABLE
Definition: type_misc.h:69
void SCIPsortedvecInsertPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int *len, int *pos)
void SCIPsortDownIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int len)
int SCIPprofileGetLoad(SCIP_PROFILE *profile, int pos)
SCIP_Bool SCIPsortedvecFindLong(SCIP_Longint *longarray, SCIP_Longint val, int len, int *pos)
void SCIPsortIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int len)
void SCIPsortedvecDelPosIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int pos, int *len)
SCIP_RETCODE SCIPdigraphTopoSortComponents(SCIP_DIGRAPH *digraph)
void SCIPsortedvecDelPosDownPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertDownPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int *len, int *pos)
SCIP_Bool SCIPbtnodeIsRoot(SCIP_BTNODE *node)
void SCIPsortedvecDelPosLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, int pos, int *len)
void SCIPsortedvecInsertIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int keyval, void *field1val, int field2val, SCIP_Real field3val, int *len, int *pos)
void SCIPsortRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int len)
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
void SCIPsortedvecInsertDownRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, void *field2val, int *len, int *pos)
void SCIPsortedvecInsertDownRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, void *field5val, int *len, int *pos)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
void SCIPsortIntPtr(int *intarray, void **ptrarray, int len)
void SCIPsortedvecInsertLong(SCIP_Longint *longarray, SCIP_Longint keyval, int *len, int *pos)
SCIP_Bool SCIPfileExists(const char *filename)
void SCIPqueueClear(SCIP_QUEUE *queue)
void SCIPsortedvecInsertRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, SCIP_Bool field4val, void *field5val, int *len, int *pos)
int SCIPdigraphGetNNodes(SCIP_DIGRAPH *digraph)
int SCIPprofileGetCapacity(SCIP_PROFILE *profile)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_RETCODE SCIPdigraphCreate(SCIP_DIGRAPH **digraph, int nnodes)
void SCIPsortedvecDelPosPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortDownPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecInsertIntInt(int *intarray1, int *intarray2, int keyval, int field1val, int *len, int *pos)
void SCIPsortLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int len)
void SCIPsortedvecDelPosDownLong(SCIP_Longint *longarray, int pos, int *len)
void SCIPsortLong(SCIP_Longint *longarray, int len)
SCIP_RETCODE SCIPactivityCreate(SCIP_RESOURCEACTIVITY **activity, SCIP_VAR *var, int duration, int demand)
void SCIPsortDownLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int len)
void SCIPsortedvecDelPosDownIntReal(int *intarray, SCIP_Real *realarray, int pos, int *len)
int SCIPhashmapListGetNEntries(SCIP_HASHMAPLIST *hashmaplist)
void SCIPsortDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void * SCIPhashtableRetrieveNext(SCIP_HASHTABLE *hashtable, SCIP_HASHTABLELIST **hashtablelist, void *key)
int SCIPhashmapGetNLists(SCIP_HASHMAP *hashmap)
void SCIPsortedvecDelPosDownRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int pos, int *len)
void SCIPsortedvecDelPosPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
void SCIPsortPtrRealReal(void **ptrarray, SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecInsertPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, SCIP_Bool field3val, SCIP_Bool field4val, int *len, int *pos)
void SCIPsortDownPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int len)
void SCIPsortedvecDelPosDownLongPtrPtrInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)
void SCIPsortRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, int len)
void SCIPsortDownPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_Longint * SCIPsparseSolGetLbs(SCIP_SPARSESOL *sparsesol)
int SCIPqueueNElems(SCIP_QUEUE *queue)
SCIP_Bool SCIPsortedvecFindDownReal(SCIP_Real *realarray, SCIP_Real val, int len, int *pos)
SCIP_BTNODE * SCIPbtnodeGetParent(SCIP_BTNODE *node)
SCIP_RETCODE SCIPdigraphSetNSuccessors(SCIP_DIGRAPH *digraph, int node, int nsuccessors)
void SCIPhashmapPrintStatistics(SCIP_HASHMAP *hashmap, SCIP_MESSAGEHDLR *messagehdlr)
int SCIPactivityGetEnergy(SCIP_RESOURCEACTIVITY *activity)
void SCIPsortedvecDelPosDownLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, int pos, int *len)
int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)
void SCIPsortedvecInsertRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, int field3val, int *len, int *pos)
struct SCIP_BtNode SCIP_BTNODE
Definition: type_misc.h:120
void SCIPsortIntInt(int *intarray1, int *intarray2, int len)
void SCIPsortedvecInsertDownPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int *len, int *pos)
void SCIPsortPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecInsertPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int *len, int *pos)
void SCIPsortedvecInsertRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real keyval, int field1val, void *field2val, int *len, int *pos)
void SCIPbtnodeSetLeftchild(SCIP_BTNODE *node, SCIP_BTNODE *left)
void SCIPsortLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int len)
SCIP_Bool SCIPsortedvecFindDownLong(SCIP_Longint *longarray, SCIP_Longint val, int len, int *pos)
void * SCIPdigraphGetNodeData(SCIP_DIGRAPH *digraph, int node)
int SCIPcalcHashtableSize(int minsize)
void SCIPsortedvecDelPosRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int pos, int *len)
void SCIPsortedvecInsertDownIntReal(int *intarray, SCIP_Real *realarray, int keyval, SCIP_Real field1val, int *len, int *pos)
void SCIPsortedvecDelPosInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int pos, int *len)
void SCIPsortedvecInsertDownPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, SCIP_Bool field2val, int *len, int *pos)
SCIP_Bool SCIPsortedvecFindDownInt(int *intarray, int val, int len, int *pos)
void SCIPdigraphSetNodeData(SCIP_DIGRAPH *digraph, void *dataptr, int node)
void SCIPescapeString(char *t, int bufsize, const char *s)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
void SCIPsortedvecInsertRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, void *field4val, int *len, int *pos)
void SCIPsortReal(SCIP_Real *realarray, int len)
struct SCIP_Queue SCIP_QUEUE
Definition: type_misc.h:57
struct SCIP_HashTableList SCIP_HASHTABLELIST
Definition: type_misc.h:72
void SCIPsortedvecDelPosReal(SCIP_Real *realarray, int pos, int *len)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void SCIPsortedvecInsertDownPtrPtrInt(void **ptrarray1, void **ptrarray2, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int *len, int *pos)
void SCIPdigraphPrint(SCIP_DIGRAPH *digraph, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
void SCIPsortedvecInsertRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, void *field3val, int *len, int *pos)
void SCIPsortedvecDelPosIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int pos, int *len)
void SCIPsortRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int len)
void SCIPsortedvecDelPosRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosDownPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int pos, int *len)
void SCIPactivityFree(SCIP_RESOURCEACTIVITY **activity)
void SCIPsortedvecDelPosDownIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int pos, int *len)
void SCIPsortedvecInsertDownIntPtr(int *intarray, void **ptrarray, int keyval, void *field1val, int *len, int *pos)
void SCIPsortedvecInsertIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)
void SCIPsortedvecInsertIntPtr(int *intarray, void **ptrarray, int keyval, void *field1val, int *len, int *pos)
void SCIPsortedvecInsertDownPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)
void SCIPsortedvecDelPosDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPgmlWriteEdge(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
void SCIPsortLongPtr(SCIP_Longint *longarray, void **ptrarray, int len)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosDownIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int pos, int *len)
void SCIPsortDownLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int len)
void SCIPsortDownIntIntInt(int *intarray1, int *intarray2, int *intarray3, int len)
void SCIPsortedvecDelPosDownRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int pos, int *len)
void SCIPhashtableRemoveAll(SCIP_HASHTABLE *hashtable)
type definitions for problem variables
SCIP_RETCODE SCIPhashtableRemove(SCIP_HASHTABLE *hashtable, void *element)
SCIP_DECL_HASHGETKEY(SCIPhashGetKeyStandard)
void SCIPsortedvecInsertRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, void *field2val, int *len, int *pos)
SCIP_RETCODE SCIPprofileCreate(SCIP_PROFILE **profile, int capacity)
void SCIPsortDownLong(SCIP_Longint *longarray, int len)
void SCIPsortedvecInsertRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Longint field1val, SCIP_Real field2val, int field3val, int *len, int *pos)
void SCIPqueueFree(SCIP_QUEUE **queue)
void SCIPsortPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_RETCODE SCIPdigraphAddArc(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)
void SCIPsortedvecInsertDownRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, SCIP_Bool field3val, void *field4val, int *len, int *pos)
void SCIPsortedvecDelPosDownIntPtr(int *intarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosDownRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int pos, int *len)
void SCIPsortPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_Bool SCIPbtnodeIsRightchild(SCIP_BTNODE *node)
void SCIPsortDownRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int len)
void SCIPsortRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int len)
void SCIPsortedvecDelPosPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)
void SCIPsortedvecInsertDownPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, SCIP_Bool field3val, SCIP_Bool field4val, int *len, int *pos)
void SCIPsortedvecInsertLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)
SCIP_Bool SCIPsortedvecFindInt(int *intarray, int val, int len, int *pos)
SCIP_DECL_HASHKEYVAL(SCIPhashKeyValString)
SCIP_BTNODE * SCIPbtGetRoot(SCIP_BT *tree)
SCIP_RETCODE SCIPgetRandomSubset(void **set, int nelems, void **subset, int nsubelems, unsigned int randseed)
void SCIPsortedvecDelPosLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int pos, int *len)
void SCIPsortDownRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, int len)
SCIP_RETCODE SCIPcomputeArraysSetminus(int *array1, int narray1, int *array2, int narray2, int *setminusarray, int *nsetminusarray)
void SCIPsortDownPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int pos, int *len)
void SCIPsortedvecDelPosPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecDelPosDownPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPhashtablePrintStatistics(SCIP_HASHTABLE *hashtable, SCIP_MESSAGEHDLR *messagehdlr)
void SCIPsortedvecDelPosDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int pos, int *len)
SCIP_DECL_SORTPTRCOMP(SCIPsortCompInt)
SCIP_BTNODE * SCIPbtnodeGetRightchild(SCIP_BTNODE *node)
void SCIPsortedvecInsertPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int field3val, int *len, int *pos)
SCIP_RETCODE SCIPdigraphAddArcSafe(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)
void SCIPsortedvecInsertDownLongPtrRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)
int SCIPdigraphGetNSuccessors(SCIP_DIGRAPH *digraph, int node)
struct SCIP_SparseSol SCIP_SPARSESOL
Definition: type_misc.h:51
void SCIPsortedvecInsertPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int field2val, int *len, int *pos)
void SCIPsortPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
#define SCIP_Bool
Definition: def.h:50
void SCIPsortedvecDelPosDownPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)
void SCIPsortedvecDelPosIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int pos, int *len)
void SCIPsortDownPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecInsertDownPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int field3val, int *len, int *pos)
void SCIPsortDownPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_Longint * SCIPsparseSolGetUbs(SCIP_SPARSESOL *sparsesol)
void SCIPsortedvecInsertIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int keyval, int field1val, void *field2val, int *len, int *pos)
void SCIPsortLongPtrPtrBoolInt(SCIP_Longint *longarray, void **ptrarray1, void **ptrarray2, SCIP_Bool *boolarray, int *intarray, int len)
void SCIPprintSysError(const char *message)
void SCIPsortedvecDelPosIntReal(int *intarray, SCIP_Real *realarray, int pos, int *len)
SCIP_RETCODE SCIPsparseSolCreate(SCIP_SPARSESOL **sparsesol, SCIP_VAR **vars, int nvars, SCIP_Bool cleared)
void SCIPsortedvecDelPosDownRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, int pos, int *len)
SCIP_RETCODE SCIPhashmapRemoveAll(SCIP_HASHMAP *hashmap)
SCIP_Bool SCIPprofileFindLeft(SCIP_PROFILE *profile, int timepoint, int *pos)
SCIP_RETCODE SCIPdigraphResize(SCIP_DIGRAPH *digraph, int nnodes)
void SCIPsortedvecInsertDownRealLongRealInt(SCIP_Real *realarray1, SCIP_Longint *longarray, SCIP_Real *realarray3, int *intarray, SCIP_Real keyval, SCIP_Longint field1val, SCIP_Real field2val, int field3val, int *len, int *pos)
void SCIPsortedvecInsertDownPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int field2val, int field3val, int *len, int *pos)
void SCIPsortDownRealRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, int *intarray, int len)
struct SCIP_HashMapList SCIP_HASHMAPLIST
Definition: type_misc.h:81
SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)
int SCIPdigraphGetNArcs(SCIP_DIGRAPH *digraph)
void SCIPsortedvecDelPosPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertDownIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)
void SCIPbtFree(SCIP_BT **tree)
void SCIPsortedvecDelPosRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecInsertIntIntInt(int *intarray1, int *intarray2, int *intarray3, int keyval, int field1val, int field2val, int *len, int *pos)
void SCIPsortedvecInsertDownLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, SCIP_Longint keyval, void *field1val, int field2val, int *len, int *pos)
SCIP_RETCODE SCIPhashtableSafeInsert(SCIP_HASHTABLE *hashtable, void *element)
void SCIPsortedvecDelPosDownRealPtr(SCIP_Real *realarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int pos, int *len)
SCIP_Bool SCIPbtnodeIsLeftchild(SCIP_BTNODE *node)
void SCIPsortDownIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int len)
void SCIPsortedvecInsertRealInt(SCIP_Real *realarray, int *intarray, SCIP_Real keyval, int field1val, int *len, int *pos)
void SCIPsortedvecInsertRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_Real keyval, void *field1val, void *field2val, int intval1, int intval2, int *len, int *pos)
void SCIPsortLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int len)
SCIP_RETCODE SCIPdigraphComputeDirectedComponents(SCIP_DIGRAPH *digraph, int compidx, int *strongcomponents, int *strongcompstartidx, int *nstrongcomponents)
SCIP_Real SCIPcomputeTwoSampleTTestValue(SCIP_Real meanx, SCIP_Real meany, SCIP_Real variancex, SCIP_Real variancey, SCIP_Real countx, SCIP_Real county)
void SCIPsortedvecDelPosRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)
void ** SCIPpqueueElems(SCIP_PQUEUE *pqueue)
void SCIPsortedvecInsertDownIntIntInt(int *intarray1, int *intarray2, int *intarray3, int keyval, int field1val, int field2val, int *len, int *pos)
void SCIPsortedvecDelPosDownLongPtr(SCIP_Longint *longarray, void **ptrarray, int pos, int *len)
void SCIPprofilePrint(SCIP_PROFILE *profile, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
void SCIPsortedvecInsertPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)
void SCIPgmlWriteNodeWeight(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor, SCIP_Real weight)
void SCIPsortedvecInsertPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int *len, int *pos)
struct SCIP_Var SCIP_VAR
Definition: type_var.h:95
void SCIPsortIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int len)
SCIP_Bool SCIPfindSimpleRational(SCIP_Real lb, SCIP_Real ub, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
void SCIPsortIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int len)
void SCIPsortRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int len)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
void SCIPsortedvecInsertRealRealIntInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray1, int *intarray2, SCIP_Real keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)
void SCIPsortedvecInsertDownRealPtrPtr(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, SCIP_Real keyval, void *field1val, void *field2val, int *len, int *pos)
int * SCIPprofileGetTimepoints(SCIP_PROFILE *profile)
void SCIPsortDownPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecInsertPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)
SCIP_VAR ** SCIPsparseSolGetVars(SCIP_SPARSESOL *sparsesol)
int * SCIPprofileGetLoads(SCIP_PROFILE *profile)
void SCIPsortedvecInsertDownPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int field4val, int *len, int *pos)
void SCIPsortedvecInsertDownIntIntIntPtr(int *intarray1, int *intarray2, int *intarray3, void **ptrarray, int keyval, int field1val, int field2val, void *field3val, int *len, int *pos)
int SCIPgetRandomInt(int minrandval, int maxrandval, unsigned int *seedp)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_Bool SCIPbtIsEmpty(SCIP_BT *tree)
void SCIPsortedvecDelPosDownIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int pos, int *len)
void SCIPsortedvecDelPosDownPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Bool field1val, int *len, int *pos)
void SCIPsortDownPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosInt(int *intarray, int pos, int *len)
void SCIPsortedvecInsertDownRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, SCIP_Real keyval, int field1val, SCIP_Longint field2val, int *len, int *pos)
SCIP_Real SCIPgetRandomReal(SCIP_Real minrandval, SCIP_Real maxrandval, unsigned int *seedp)
SCIP_BTNODE * SCIPbtnodeGetLeftchild(SCIP_BTNODE *node)
void SCIPsortedvecInsertPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, SCIP_Bool field2val, int *len, int *pos)
void SCIPsortedvecDelPosRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosDownPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
struct SCIP_Profile SCIP_PROFILE
Definition: type_misc.h:105
void SCIPsortedvecDelPosDownIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int pos, int *len)
#define SCIP_DECL_SORTINDCOMP(x)
Definition: type_misc.h:128
int SCIPsparseSolGetNVars(SCIP_SPARSESOL *sparsesol)
void SCIPsortedvecDelPosDownPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPbtSetRoot(SCIP_BT *tree, SCIP_BTNODE *root)
void SCIPsortedvecInsertDownLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, int field4val, SCIP_Bool field5val, int *len, int *pos)
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
void SCIPsortedvecDelPosDownPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real keyval, void *field1val, void *field2val, int intval, int *len, int *pos)
void SCIPbtnodeSetParent(SCIP_BTNODE *node, SCIP_BTNODE *parent)
void SCIPsortDownPtrIntIntBoolBool(void **ptrarray, int *intarray1, int *intarray2, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosRealPtr(SCIP_Real *realarray, void **ptrarray, int pos, int *len)
SCIP_Real SCIPstudentTGetCriticalValue(SCIP_CONFIDENCELEVEL clevel, int df)
void SCIPsort(int *perm, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
void SCIPsortedvecInsertDownRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, SCIP_Real keyval, SCIP_Real field1val, SCIP_Real field2val, void *field3val, int *len, int *pos)
SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)
void SCIPsortDownRealRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, void **ptrarray, int len)
SCIP_RETCODE SCIPdigraphCopy(SCIP_DIGRAPH **targetdigraph, SCIP_DIGRAPH *sourcedigraph)
SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)
void SCIPsortedvecDelPosDownLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, int pos, int *len)
void SCIPsortedvecDelPosDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
SCIP_Real SCIPcalcMachineEpsilon(void)
SCIP_RETCODE SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)))
void SCIPsortedvecInsertDownPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Bool field1val, int *len, int *pos)
void SCIPsortedvecInsertIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int keyval, int field1val, SCIP_Real field2val, int *len, int *pos)
void SCIPsortedvecDelPosLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int pos, int *len)
void SCIPsortDownLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int len)
SCIP_Real SCIPnormalCDF(SCIP_Real mean, SCIP_Real variance, SCIP_Real value)
void SCIPsortedvecDelPosIntPtr(int *intarray, void **ptrarray, int pos, int *len)
SCIP_Bool SCIPsortedvecFindReal(SCIP_Real *realarray, SCIP_Real val, int len, int *pos)
void SCIPsortedvecInsertDownPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Longint field2val, int field3val, int *len, int *pos)
void SCIPsortedvecInsertDownLongPtr(SCIP_Longint *longarray, void **ptrarray, SCIP_Longint keyval, void *field1val, int *len, int *pos)
int SCIPactivityGetDuration(SCIP_RESOURCEACTIVITY *activity)
void SCIPsortedvecInsertDownIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int keyval, void *field1val, int field2val, int field3val, SCIP_Bool field4val, SCIP_Bool field5val, int *len, int *pos)
void SCIPsortDownRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int len)
void SCIPsortedvecDelPosPtrBool(void **ptrarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
SCIP_RETCODE SCIPhashmapSetImage(SCIP_HASHMAP *hashmap, void *origin, void *image)
void SCIPsortedvecDelPosIntIntLong(int *intarray1, int *intarray2, SCIP_Longint *longarray, int pos, int *len)
void SCIPsortDownInt(int *intarray, int len)
#define SCIP_Real
Definition: def.h:124
void SCIPsortedvecDelPosPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertPtrRealIntInt(void **ptrarray, SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, SCIP_Real field1val, int field2val, int field3val, int *len, int *pos)
void SCIPpermuteIntArray(int *array, int begin, int end, unsigned int *randseed)
void SCIPsortedvecInsertLongPtr(SCIP_Longint *longarray, void **ptrarray, SCIP_Longint keyval, void *field1val, int *len, int *pos)
void SCIPsortedvecDelPosPtrPtrReal(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecDelPosDownRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosDownLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int pos, int *len)
void SCIPsortedvecDelPosDownRealPtrPtrIntInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, int pos, int *len)
void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortDownRealBoolPtr(SCIP_Real *realarray, SCIP_Bool *boolarray, void **ptrarray, int len)
void SCIPsortDownPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortInt(int *intarray, int len)
void SCIPsortedvecInsertInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int keyval, int *len, int *pos)
#define SCIP_Longint
Definition: def.h:109
SCIP_RETCODE SCIPcalcIntegralScalar(SCIP_Real *vals, int nvals, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Real *intscalar, SCIP_Bool *success)
void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
void SCIPsortedvecInsertDownRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, SCIP_Real keyval, int field1val, void *field2val, int *len, int *pos)
void SCIPsortedvecDelPosDownRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
void * SCIPqueueRemove(SCIP_QUEUE *queue)
SCIP_Bool SCIPsortedvecFindInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int val, int len, int *pos)
void SCIPsortLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, int len)
void SCIPsortedvecDelPosDownRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int pos, int *len)
void SCIPsortedvecDelPosDownLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, int pos, int *len)
void SCIPsortPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
type definitions for message output methods
void SCIPsortedvecDelPosPtrIntInt(void **ptrarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecDelPosDownRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int pos, int *len)
void SCIPsortedvecDelPosDownPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecInsertDownPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int *len, int *pos)
void SCIPsortPtrPtrLongIntInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortedvecDelPosDownPtrPtrLongInt(void **ptrarray1, void **ptrarray2, SCIP_Longint *longarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsortedvecDelPosPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
int SCIPprofileGetLatestFeasibleStart(SCIP_PROFILE *profile, int lb, int ub, int duration, int height, SCIP_Bool *infeasible)
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
void SCIPsortDownRealIntLong(SCIP_Real *realarray, int *intarray, SCIP_Longint *longarray, int len)
void SCIPsortedvecInsertDownPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, SCIP_Real field2val, SCIP_Bool field3val, int *len, int *pos)
void SCIPsortedvecInsertLongPtrRealRealIntBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, int *intarray, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, int field4val, SCIP_Bool field5val, int *len, int *pos)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_Real SCIPhashtableGetLoad(SCIP_HASHTABLE *hashtable)
void SCIPsortedvecDelPosDownPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
common defines and data types used in all packages of SCIP
void * SCIPqueueFirst(SCIP_QUEUE *queue)
void SCIPsortedvecDelPosDownRealInt(SCIP_Real *realarray, int *intarray, int pos, int *len)
void SCIPsortedvecInsertDownLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, SCIP_Longint keyval, void *field1val, SCIP_Real field2val, SCIP_Real field3val, SCIP_Bool field4val, int *len, int *pos)
void SCIPswapInts(int *value1, int *value2)
void SCIPsortedvecInsertDownRealIntInt(SCIP_Real *realarray, int *intarray1, int *intarray2, SCIP_Real keyval, int field1val, int field2val, int *len, int *pos)
void SCIPsortedvecDelPosDownIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int pos, int *len)
SCIP_RETCODE SCIPbtCreate(SCIP_BT **tree, BMS_BLKMEM *blkmem)
void SCIPsortedvecDelPosDownIntIntIntReal(int *intarray1, int *intarray2, int *intarray3, SCIP_Real *realarray, int pos, int *len)
void SCIPsortedvecDelPosIntPtrIntIntBoolBool(int *intarray1, void **ptrarray, int *intarray2, int *intarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, int pos, int *len)
void SCIPsortedvecDelPosDownPtrRealBool(void **ptrarray, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
int SCIPactivityGetDemand(SCIP_RESOURCEACTIVITY *activity)
void SCIPbtnodeSetData(SCIP_BTNODE *node, void *dataptr)
void SCIPdigraphFree(SCIP_DIGRAPH **digraph)
int SCIPprofileGetNTimepoints(SCIP_PROFILE *profile)
void SCIPsortedvecInsertPtrPtr(void **ptrarray1, void **ptrarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, void *field1val, int *len, int *pos)
void SCIPpqueueClear(SCIP_PQUEUE *pqueue)
SCIP_DECL_HASHKEYEQ(SCIPhashKeyEqString)
void SCIPsortRealIntPtr(SCIP_Real *realarray, int *intarray, void **ptrarray, int len)
char * SCIPstrtok(char *s, const char *delim, char **ptrptr)
void SCIPsortedvecDelPosPtrPtrIntInt(void **ptrarray1, void **ptrarray2, int *intarray1, int *intarray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
void SCIPsortedvecInsertDownIntIntReal(int *intarray1, int *intarray2, SCIP_Real *realarray, int keyval, int field1val, SCIP_Real field2val, int *len, int *pos)
void SCIPsortedvecDelPosRealRealRealBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray, void **ptrarray, int pos, int *len)
void SCIPsortedvecInsertDownRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, SCIP_Real keyval, void *field1val, void *field2val, int intval, int *len, int *pos)
void SCIPdigraphPrintGml(SCIP_DIGRAPH *digraph, FILE *file)
SCIP_HASHMAPLIST * SCIPhashmapListGetNext(SCIP_HASHMAPLIST *hashmaplist)
void SCIPsortDownReal(SCIP_Real *realarray, int len)
void SCIPsortDownLongPtr(SCIP_Longint *longarray, void **ptrarray, int len)
void SCIPsortedvecInsertDownPtrInt(void **ptrarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int field1val, int *len, int *pos)
void SCIPsortedvecInsertInt(int *intarray, int keyval, int *len, int *pos)
void SCIPbtPrintGml(SCIP_BT *tree, FILE *file)
void SCIPsortedvecDelPosDownPtrPtrRealBool(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, SCIP_Bool *boolarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
SCIP_Longint SCIPhashtableGetNElements(SCIP_HASHTABLE *hashtable)
void SCIPsortedvecInsertDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *keyval, int *len, int *pos)
SCIP_Longint SCIPcalcSmaComMul(SCIP_Longint val1, SCIP_Longint val2)
void SCIPsortDownIntIntPtr(int *intarray1, int *intarray2, void **ptrarray, int len)
SCIP_Bool SCIPsortedvecFindDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
SCIP_Bool SCIPbtnodeIsLeaf(SCIP_BTNODE *node)
void SCIPsortedvecDelPosPtrPtrRealInt(void **ptrarray1, void **ptrarray2, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int pos, int *len)
void SCIPsparseSolFree(SCIP_SPARSESOL **sparsesol)
void SCIPsortDownRealRealRealBoolBoolPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, SCIP_Real *realarray3, SCIP_Bool *boolarray1, SCIP_Bool *boolarray2, void **ptrarray, int len)
void SCIPsortIntReal(int *intarray, SCIP_Real *realarray, int len)
void SCIPprofileFree(SCIP_PROFILE **profile)
void SCIPsortRealRealPtr(SCIP_Real *realarray1, SCIP_Real *realarray2, void **ptrarray, int len)
void SCIPsortDownLongPtrInt(SCIP_Longint *longarray, void **ptrarray, int *intarray, int len)