A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://scip.zib.de/doc/html/pub__misc_8h_source.php below:

SCIP Doxygen Documentation: pub_misc.h Source File

43#ifndef __SCIP_PUB_MISC_H__ 44#define __SCIP_PUB_MISC_H__ 217 const char

* nodetype,

218 const char

* fillcolor,

219 const char

* bordercolor

228 const char

* nodetype,

229 const char

* fillcolor,

230 const char

* bordercolor,

279 const char

* nodetype,

280 const char

* fillcolor,

281 const char

* bordercolor

549#define SCIPhashSignature64(a) (UINT64_C(0x8000000000000000)>>((UINT32_C(0x9e3779b9) * ((uint32_t)(a)))>>26)) 551#define SCIPhashTwo(a, b) ((uint32_t)((((uint32_t)(a) + 0xd37e9a1ce2148403ULL) * ((uint32_t)(b) + 0xe5fcc163aef32782ULL) )>>32)) 553#define SCIPhashThree(a, b, c) ((uint32_t)((((uint32_t)(a) + 0xbd5c89185f082658ULL) * ((uint32_t)(b) + 0xe5fcc163aef32782ULL) + \ 554 (uint32_t)(c) * 0xd37e9a1ce2148403ULL)>>32 )) 556#define SCIPhashFour(a, b, c, d) ((uint32_t)((((uint32_t)(a) + 0xbd5c89185f082658ULL) * ((uint32_t)(b) + 0xe5fcc163aef32782ULL) + \ 557 ((uint32_t)(c) + 0xd37e9a1ce2148403ULL) * ((uint32_t)(d) + 0x926f2d4dc4a67218ULL))>>32 )) 559#define SCIPhashFive(a, b, c, d, e) ((uint32_t)((((uint32_t)(a) + 0xbd5c89185f082658ULL) * ((uint32_t)(b) + 0xe5fcc163aef32782ULL) + \ 560 ((uint32_t)(c) + 0xd37e9a1ce2148403ULL) * ((uint32_t)(d) + 0x926f2d4dc4a67218ULL) + \ 561 (uint32_t)(e) * 0xf48d4cd331e14327ULL)>>32 )) 563#define SCIPhashSix(a, b, c, d, e, f) ((uint32_t)((((uint32_t)(a) + 0xbd5c89185f082658ULL) * ((uint32_t)(b) + 0xe5fcc163aef32782ULL) + \ 564 ((uint32_t)(c) + 0xd37e9a1ce2148403ULL) * ((uint32_t)(d) + 0x926f2d4dc4a67218ULL) + \ 565 ((uint32_t)(e) + 0xf48d4cd331e14327ULL) * ((uint32_t)(f) + 0x80791a4edfc44c75ULL))>>32 )) 567#define SCIPhashSeven(a, b, c, d, e, f, g) ((uint32_t)((((uint32_t)(a) + 0xbd5c89185f082658ULL) * ((uint32_t)(b) + 0xe5fcc163aef32782ULL) + \ 568 ((uint32_t)(c) + 0xd37e9a1ce2148403ULL) * ((uint32_t)(d) + 0x926f2d4dc4a67218ULL) + \ 569 ((uint32_t)(e) + 0xf48d4cd331e14327ULL) * ((uint32_t)(f) + 0x80791a4edfc44c75ULL) + \ 570 (uint32_t)(g) * 0x7f497d9ba3bd83c0ULL)>>32 )) 579 return

(((uint32_t)(uint16_t)(int16_t)ldexp(frexp(

x

, &theexp), 15))<<16) | (uint32_t)(uint16_t)theexp;

1123#define SCIPhashsetIsEmpty(hashset) ((hashset)->nelements == 0) 1124#define SCIPhashsetGetNElements(hashset) ((hashset)->nelements) 1125#define SCIPhashsetGetNSlots(hashset) (1u << (64 - (hashset)->shift)) 1126#define SCIPhashsetGetSlots(hashset) ((hashset)->slots) 1187#define SCIPactivityGetVar(activity) ((activity)->var) 1188#define SCIPactivityGetDuration(activity) ((activity)->duration) 1189#define SCIPactivityGetDemand(activity) ((activity)->demand) 1190#define SCIPactivityGetEnergy(activity) ((activity)->duration * (activity)->demand) 1445 int

** articulations,

1446 int

* narticulations

1476 int

* strongcomponents,

1478 int

* strongcompstartidx,

1480 int

* nstrongcomponents

1633#define SCIPbtnodeGetData(node) ((node)->dataptr) 1634#define SCIPbtnodeGetParent(node) ((node)->parent) 1635#define SCIPbtnodeGetLeftchild(node) ((node)->left) 1636#define SCIPbtnodeGetRightchild(node) ((node)->right) 1637#define SCIPbtnodeGetSibling(node) ((node)->parent == NULL ? NULL : \ 1638 (node)->parent->left == (node) ? (node)->parent->right : (node)->parent->left) 1639#define SCIPbtnodeIsRoot(node) ((node)->parent == NULL) 1640#define SCIPbtnodeIsLeaf(node) ((node)->left == NULL && (node)->right == NULL) 1641#define SCIPbtnodeIsLeftchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->left == (node) ? TRUE : FALSE) 1642#define SCIPbtnodeIsRightchild(node) ((node)->parent == NULL ? FALSE : (node)->parent->right == (node) ? TRUE : FALSE) 1727#define SCIPbtIsEmpty(tree) (tree->root == NULL) 1728#define SCIPbtGetRoot(tree) (tree->root) 1849#define SCIPcalcFibHash(v) ((v) >= 0 ? ((unsigned long long)((v) * 2654435769)) % UINT_MAX : ((unsigned long long)(-(v) * 683565275)) % UINT_MAX ) 1926#if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L || defined(__APPLE__) 1927#define SCIPisFinite isfinite 1928#elif defined(_BSD_SOURCE) || defined(__sun) 1929#define SCIPisFinite finite 1930#elif defined(_MSC_VER) 1931#define SCIPisFinite _finite 1933#define SCIPisFinite(x) ((x) == (x)) 1953#define SCIPrelDiff(val1, val2) ( ((val1)-(val2))/(MAX3(1.0,REALABS(val1),REALABS(val2))) ) 1988 unsigned int

* seedp

2028 unsigned int

* seedp

2042 unsigned int

randseed

2092 unsigned int

* randseed

2134 unsigned int

* randseed

2162 int

* intersectarray,

2164 int

* nintersectarray

2175 int

* intersectarray,

2177 int

* nintersectarray

2189 void

** intersectarray,

2191 int

* nintersectarray

2205 int

* setminusarray,

2207 int

* nsetminusarray

2218 int

* setminusarray,

2220 int

* nsetminusarray

2258 const char

* message

2380 const char

* filename

common defines and data types used in all packages of SCIP

void SCIPcomputeArraysIntersectionPtr(void **array1, int narray1, void **array2, int narray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void **intersectarray, int *nintersectarray)

void SCIPcomputeArraysSetminusInt(int *array1, int narray1, int *array2, int narray2, int *setminusarray, int *nsetminusarray)

SCIP_RETCODE SCIPcomputeArraysIntersection(int *array1, int narray1, int *array2, int narray2, int *intersectarray, int *nintersectarray)

SCIP_RETCODE SCIPcomputeArraysSetminus(int *array1, int narray1, int *array2, int narray2, int *setminusarray, int *nsetminusarray)

void SCIPcomputeArraysIntersectionInt(int *array1, int narray1, int *array2, int narray2, int *intersectarray, int *nintersectarray)

void SCIPbtnodeSetRightchild(SCIP_BTNODE *node, SCIP_BTNODE *right)

SCIP_BTNODE * SCIPbtnodeGetRightchild(SCIP_BTNODE *node)

SCIP_Bool SCIPbtIsEmpty(SCIP_BT *tree)

SCIP_RETCODE SCIPbtCreate(SCIP_BT **tree, BMS_BLKMEM *blkmem)

void SCIPbtnodeFree(SCIP_BT *tree, SCIP_BTNODE **node)

SCIP_Bool SCIPbtnodeIsLeaf(SCIP_BTNODE *node)

void SCIPbtnodeSetData(SCIP_BTNODE *node, void *dataptr)

void * SCIPbtnodeGetData(SCIP_BTNODE *node)

SCIP_RETCODE SCIPbtnodeCreate(SCIP_BT *tree, SCIP_BTNODE **node, void *dataptr)

SCIP_Bool SCIPbtnodeIsRightchild(SCIP_BTNODE *node)

void SCIPbtnodeSetParent(SCIP_BTNODE *node, SCIP_BTNODE *parent)

SCIP_BTNODE * SCIPbtnodeGetSibling(SCIP_BTNODE *node)

SCIP_Bool SCIPbtnodeIsLeftchild(SCIP_BTNODE *node)

void SCIPbtnodeSetLeftchild(SCIP_BTNODE *node, SCIP_BTNODE *left)

SCIP_BTNODE * SCIPbtnodeGetParent(SCIP_BTNODE *node)

void SCIPbtFree(SCIP_BT **tree)

SCIP_BTNODE * SCIPbtnodeGetLeftchild(SCIP_BTNODE *node)

void SCIPbtSetRoot(SCIP_BT *tree, SCIP_BTNODE *root)

SCIP_Bool SCIPbtnodeIsRoot(SCIP_BTNODE *node)

SCIP_BTNODE * SCIPbtGetRoot(SCIP_BT *tree)

void SCIPbtPrintGml(SCIP_BT *tree, FILE *file)

void SCIPdigraphPrintComponents(SCIP_DIGRAPH *digraph, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

void ** SCIPdigraphGetSuccessorsData(SCIP_DIGRAPH *digraph, int node)

void SCIPdigraphFreeComponents(SCIP_DIGRAPH *digraph)

int SCIPdigraphGetNSuccessors(SCIP_DIGRAPH *digraph, int node)

SCIP_RETCODE SCIPdigraphComputeUndirectedComponents(SCIP_DIGRAPH *digraph, int minsize, int *components, int *ncomponents)

int SCIPdigraphGetNNodes(SCIP_DIGRAPH *digraph)

void SCIPdigraphPrintGml(SCIP_DIGRAPH *digraph, FILE *file)

void SCIPdigraphGetComponent(SCIP_DIGRAPH *digraph, int compidx, int **nodes, int *nnodes)

SCIP_RETCODE SCIPdigraphAddArc(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)

SCIP_RETCODE SCIPdigraphTopoSortComponents(SCIP_DIGRAPH *digraph)

SCIP_RETCODE SCIPdigraphSetSizes(SCIP_DIGRAPH *digraph, int *sizes)

SCIP_RETCODE SCIPdigraphComputeDirectedComponents(SCIP_DIGRAPH *digraph, int compidx, int *strongcomponents, int *strongcompstartidx, int *nstrongcomponents)

SCIP_RETCODE SCIPdigraphAddArcSafe(SCIP_DIGRAPH *digraph, int startnode, int endnode, void *data)

void SCIPdigraphFree(SCIP_DIGRAPH **digraph)

int SCIPdigraphGetNArcs(SCIP_DIGRAPH *digraph)

void SCIPdigraphPrint(SCIP_DIGRAPH *digraph, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

void * SCIPdigraphGetNodeData(SCIP_DIGRAPH *digraph, int node)

void SCIPdigraphSetNodeData(SCIP_DIGRAPH *digraph, void *dataptr, int node)

SCIP_RETCODE SCIPdigraphSetNSuccessors(SCIP_DIGRAPH *digraph, int node, int nsuccessors)

int * SCIPdigraphGetSuccessors(SCIP_DIGRAPH *digraph, int node)

int SCIPdigraphGetNComponents(SCIP_DIGRAPH *digraph)

SCIP_RETCODE SCIPdigraphResize(SCIP_DIGRAPH *digraph, int nnodes)

SCIP_RETCODE SCIPdigraphGetArticulationPoints(SCIP_DIGRAPH *digraph, int **articulations, int *narticulations)

int SCIPdisjointsetGetSize(SCIP_DISJOINTSET *djset)

void SCIPdisjointsetClear(SCIP_DISJOINTSET *djset)

int SCIPdisjointsetGetComponentCount(SCIP_DISJOINTSET *djset)

int SCIPdisjointsetFind(SCIP_DISJOINTSET *djset, int element)

void SCIPdisjointsetUnion(SCIP_DISJOINTSET *djset, int p, int q, SCIP_Bool forcerepofp)

SCIP_Bool SCIPfileExists(const char *filename)

void SCIPsplitFilename(char *filename, char **path, char **name, char **extension, char **compression)

void SCIPdotWriteOpening(FILE *file)

void SCIPdotWriteClosing(FILE *file)

void SCIPdotWriteArc(FILE *file, int source, int target, const char *color)

void SCIPgmlWriteNodeWeight(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor, SCIP_Real weight)

void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)

void SCIPgmlWriteClosing(FILE *file)

void SCIPdotWriteNode(FILE *file, int node, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)

void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)

void SCIPgmlWriteEdge(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)

void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void * SCIPhashmapEntryGetImage(SCIP_HASHMAPENTRY *entry)

SCIP_Real SCIPhashmapGetImageReal(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertReal(SCIP_HASHMAP *hashmap, void *origin, SCIP_Real image)

void SCIPhashmapPrintStatistics(SCIP_HASHMAP *hashmap, SCIP_MESSAGEHDLR *messagehdlr)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapSetImageReal(SCIP_HASHMAP *hashmap, void *origin, SCIP_Real image)

void SCIPhashmapEntrySetImageInt(SCIP_HASHMAPENTRY *entry, int image)

SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)

SCIP_RETCODE SCIPhashmapSetImage(SCIP_HASHMAP *hashmap, void *origin, void *image)

int SCIPhashmapGetNElements(SCIP_HASHMAP *hashmap)

int SCIPhashmapEntryGetImageInt(SCIP_HASHMAPENTRY *entry)

void SCIPhashmapEntrySetImageReal(SCIP_HASHMAPENTRY *entry, SCIP_Real image)

int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)

SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)

void SCIPhashmapEntrySetImage(SCIP_HASHMAPENTRY *entry, void *image)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

void * SCIPhashmapEntryGetOrigin(SCIP_HASHMAPENTRY *entry)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)

SCIP_Bool SCIPhashmapIsEmpty(SCIP_HASHMAP *hashmap)

SCIP_RETCODE SCIPhashmapRemoveAll(SCIP_HASHMAP *hashmap)

SCIP_Real SCIPhashmapEntryGetImageReal(SCIP_HASHMAPENTRY *entry)

SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapSetImageInt(SCIP_HASHMAP *hashmap, void *origin, int image)

void SCIPhashsetFree(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem)

void SCIPhashsetPrintStatistics(SCIP_HASHSET *hashset, SCIP_MESSAGEHDLR *messagehdlr)

SCIP_Bool SCIPhashsetExists(SCIP_HASHSET *hashset, void *element)

void ** SCIPhashsetGetSlots(SCIP_HASHSET *hashset)

int SCIPhashsetGetNElements(SCIP_HASHSET *hashset)

int SCIPhashsetGetNSlots(SCIP_HASHSET *hashset)

void SCIPhashsetRemoveAll(SCIP_HASHSET *hashset)

SCIP_Bool SCIPhashsetIsEmpty(SCIP_HASHSET *hashset)

SCIP_RETCODE SCIPhashsetInsert(SCIP_HASHSET *hashset, BMS_BLKMEM *blkmem, void *element)

SCIP_RETCODE SCIPhashsetCreate(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem, int size)

SCIP_RETCODE SCIPhashsetRemove(SCIP_HASHSET *hashset, void *element)

void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)

SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)

int SCIPhashtableGetNEntries(SCIP_HASHTABLE *hashtable)

void SCIPhashtableClear(SCIP_HASHTABLE *hashtable)

SCIP_RETCODE SCIPhashtableSafeInsert(SCIP_HASHTABLE *hashtable, void *element)

void * SCIPhashtableGetEntry(SCIP_HASHTABLE *hashtable, int entryidx)

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 * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)

void SCIPhashtableRemoveAll(SCIP_HASHTABLE *hashtable)

SCIP_Real SCIPhashtableGetLoad(SCIP_HASHTABLE *hashtable)

void SCIPhashtablePrintStatistics(SCIP_HASHTABLE *hashtable, SCIP_MESSAGEHDLR *messagehdlr)

static INLINE uint32_t SCIPrealHashCode(double x)

SCIP_RETCODE SCIPhashtableRemove(SCIP_HASHTABLE *hashtable, void *element)

SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)

SCIP_Longint SCIPhashtableGetNElements(SCIP_HASHTABLE *hashtable)

SCIP_Longint SCIPmultihashGetNElements(SCIP_MULTIHASH *multihash)

void SCIPmultihashFree(SCIP_MULTIHASH **multihash)

SCIP_RETCODE SCIPmultihashInsert(SCIP_MULTIHASH *multihash, void *element)

SCIP_RETCODE SCIPmultihashRemove(SCIP_MULTIHASH *multihash, void *element)

void SCIPmultihashRemoveAll(SCIP_MULTIHASH *multihash)

SCIP_RETCODE SCIPmultihashSafeInsert(SCIP_MULTIHASH *multihash, void *element)

SCIP_DECL_HASHKEYEQ(SCIPhashKeyEqString)

int SCIPcalcMultihashSize(int minsize)

SCIP_Real SCIPmultihashGetLoad(SCIP_MULTIHASH *multihash)

SCIP_RETCODE SCIPmultihashCreate(SCIP_MULTIHASH **multihash, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)

SCIP_DECL_HASHKEYVAL(SCIPhashKeyValString)

void * SCIPmultihashRetrieve(SCIP_MULTIHASH *multihash, void *key)

void * SCIPmultihashRetrieveNext(SCIP_MULTIHASH *multihash, SCIP_MULTIHASHLIST **multihashlist, void *key)

SCIP_Bool SCIPmultihashExists(SCIP_MULTIHASH *multihash, void *element)

void SCIPmultihashPrintStatistics(SCIP_MULTIHASH *multihash, SCIP_MESSAGEHDLR *messagehdlr)

SCIP_DECL_HASHGETKEY(SCIPhashGetKeyStandard)

SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)

SCIP_Longint SCIPcalcBinomCoef(int n, int m)

SCIP_Longint SCIPcalcSmaComMul(SCIP_Longint val1, SCIP_Longint val2)

SCIP_Real SCIPselectSimpleValue(SCIP_Real lb, SCIP_Real ub, SCIP_Longint maxdnom)

SCIP_Real SCIPcomputeGap(SCIP_Real eps, SCIP_Real inf, SCIP_Real primalbound, SCIP_Real dualbound)

SCIP_Bool SCIPfindSimpleRational(SCIP_Real lb, SCIP_Real ub, SCIP_Longint maxdnom, SCIP_Longint *numerator, SCIP_Longint *denominator)

SCIP_Real SCIPcalcRootNewton(SCIP_DECL_NEWTONEVAL((*function)), SCIP_DECL_NEWTONEVAL((*derivative)), SCIP_Real *params, int nparams, SCIP_Real x, SCIP_Real eps, int k)

SCIP_Real SCIPnextafter(SCIP_Real from, SCIP_Real to)

SCIP_Real SCIPcalcMachineEpsilon(void)

unsigned int SCIPcalcFibHash(SCIP_Real v)

SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *numerator, SCIP_Longint *denominator)

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)

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

void SCIPswapInts(int *value1, int *value2)

void SCIPswapPointers(void **pointer1, void **pointer2)

void SCIPpermuteArray(void **array, int begin, int end, unsigned int *randseed)

void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)

void SCIPrandomPermuteIntArray(SCIP_RANDNUMGEN *randgen, int *array, int begin, int end)

void SCIPrandomPermuteArray(SCIP_RANDNUMGEN *randgen, void **array, int begin, int end)

void SCIPpermuteIntArray(int *array, int begin, int end, unsigned int *randseed)

void ** SCIPpqueueElems(SCIP_PQUEUE *pqueue)

void SCIPpqueueDelPos(SCIP_PQUEUE *pqueue, int pos)

void SCIPpqueueClear(SCIP_PQUEUE *pqueue)

int SCIPpqueueFind(SCIP_PQUEUE *pqueue, void *elem)

void SCIPpqueueFree(SCIP_PQUEUE **pqueue)

SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)

int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)

SCIP_RETCODE SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), SCIP_DECL_PQUEUEELEMCHGPOS((*elemchgpos)))

void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)

void * SCIPpqueueFirst(SCIP_PQUEUE *pqueue)

int SCIPqueueNElems(SCIP_QUEUE *queue)

unsigned int SCIPqueueRemoveUInt(SCIP_QUEUE *queue)

void SCIPqueueFree(SCIP_QUEUE **queue)

SCIP_RETCODE SCIPqueueInsertUInt(SCIP_QUEUE *queue, unsigned int elem)

SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)

void SCIPqueueClear(SCIP_QUEUE *queue)

SCIP_RETCODE SCIPqueueInsert(SCIP_QUEUE *queue, void *elem)

SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)

void * SCIPqueueRemove(SCIP_QUEUE *queue)

void * SCIPqueueFirst(SCIP_QUEUE *queue)

unsigned int SCIPqueueFirstUInt(SCIP_QUEUE *queue)

SCIP_RETCODE SCIPgetRandomSubset(void **set, int nelems, void **subset, int nsubelems, unsigned int randseed)

SCIP_RETCODE SCIPrandomGetSubset(SCIP_RANDNUMGEN *randgen, void **set, int nelems, void **subset, int nsubelems)

SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randgen, SCIP_Real minrandval, SCIP_Real maxrandval)

int SCIPrandomGetInt(SCIP_RANDNUMGEN *randgen, int minrandval, int maxrandval)

int SCIPgetRandomInt(int minrandval, int maxrandval, unsigned int *seedp)

SCIP_Real SCIPgetRandomReal(SCIP_Real minrandval, SCIP_Real maxrandval, unsigned int *seedp)

void SCIPregressionRemoveObservation(SCIP_REGRESSION *regression, SCIP_Real x, SCIP_Real y)

void SCIPregressionAddObservation(SCIP_REGRESSION *regression, SCIP_Real x, SCIP_Real y)

SCIP_Real SCIPregressionGetIntercept(SCIP_REGRESSION *regression)

int SCIPregressionGetNObservations(SCIP_REGRESSION *regression)

void SCIPregressionFree(SCIP_REGRESSION **regression)

SCIP_RETCODE SCIPregressionCreate(SCIP_REGRESSION **regression)

void SCIPregressionReset(SCIP_REGRESSION *regression)

SCIP_Real SCIPregressionGetSlope(SCIP_REGRESSION *regression)

SCIP_RETCODE SCIPactivityCreate(SCIP_RESOURCEACTIVITY **activity, SCIP_VAR *var, int duration, int demand)

int SCIPactivityGetDuration(SCIP_RESOURCEACTIVITY *activity)

int SCIPactivityGetEnergy(SCIP_RESOURCEACTIVITY *activity)

SCIP_VAR * SCIPactivityGetVar(SCIP_RESOURCEACTIVITY *activity)

int SCIPactivityGetDemand(SCIP_RESOURCEACTIVITY *activity)

void SCIPactivityFree(SCIP_RESOURCEACTIVITY **activity)

int SCIPprofileGetLatestFeasibleStart(SCIP_PROFILE *profile, int lb, int ub, int duration, int height, SCIP_Bool *infeasible)

int * SCIPprofileGetTimepoints(SCIP_PROFILE *profile)

SCIP_Bool SCIPprofileFindLeft(SCIP_PROFILE *profile, int timepoint, int *pos)

int SCIPprofileGetNTimepoints(SCIP_PROFILE *profile)

void SCIPprofileFree(SCIP_PROFILE **profile)

int SCIPprofileGetLoad(SCIP_PROFILE *profile, int pos)

int * SCIPprofileGetLoads(SCIP_PROFILE *profile)

SCIP_RETCODE SCIPprofileCreate(SCIP_PROFILE **profile, int capacity)

int SCIPprofileGetEarliestFeasibleStart(SCIP_PROFILE *profile, int est, int lst, int duration, int height, SCIP_Bool *infeasible)

int SCIPprofileGetTime(SCIP_PROFILE *profile, int pos)

int SCIPprofileGetCapacity(SCIP_PROFILE *profile)

SCIP_RETCODE SCIPprofileDeleteCore(SCIP_PROFILE *profile, int left, int right, int height)

SCIP_RETCODE SCIPprofileInsertCore(SCIP_PROFILE *profile, int left, int right, int height, int *pos, SCIP_Bool *infeasible)

void SCIPprofilePrint(SCIP_PROFILE *profile, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

SCIP_Real SCIPnormalCDF(SCIP_Real mean, SCIP_Real variance, SCIP_Real value)

SCIP_Real SCIPcomputeTwoSampleTTestValue(SCIP_Real meanx, SCIP_Real meany, SCIP_Real variancex, SCIP_Real variancey, SCIP_Real countx, SCIP_Real county)

SCIP_Real SCIPnormalGetCriticalValue(SCIP_CONFIDENCELEVEL clevel)

SCIP_Real SCIPstudentTGetCriticalValue(SCIP_CONFIDENCELEVEL clevel, int df)

SCIP_Real SCIPerf(SCIP_Real x)

int SCIPsparseSolGetNVars(SCIP_SPARSESOL *sparsesol)

SCIP_Longint * SCIPsparseSolGetLbs(SCIP_SPARSESOL *sparsesol)

void SCIPsparseSolGetFirstSol(SCIP_SPARSESOL *sparsesol, SCIP_Longint *sol, int nvars)

SCIP_RETCODE SCIPsparseSolCreate(SCIP_SPARSESOL **sparsesol, SCIP_VAR **vars, int nvars, SCIP_Bool cleared)

SCIP_Longint * SCIPsparseSolGetUbs(SCIP_SPARSESOL *sparsesol)

void SCIPsparseSolFree(SCIP_SPARSESOL **sparsesol)

SCIP_Bool SCIPsparseSolGetNextSol(SCIP_SPARSESOL *sparsesol, SCIP_Longint *sol, int nvars)

SCIP_VAR ** SCIPsparseSolGetVars(SCIP_SPARSESOL *sparsesol)

SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)

int SCIPstrcasecmp(const char *s1, const char *s2)

int SCIPsnprintf(char *t, int len, const char *s,...)

SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)

void SCIPescapeString(char *t, int bufsize, const char *s)

void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)

void SCIPprintSysError(const char *message)

SCIP_Bool SCIPstrAtStart(const char *s, const char *t, size_t tlen)

SCIP_RETCODE SCIPskipSpace(char **s)

int SCIPstrncpy(char *t, const char *s, int size)

int SCIPstrncasecmp(const char *s1, const char *s2, int length)

char * SCIPstrtok(char *s, const char *delim, char **ptrptr)

int SCIPmemccpy(char *dest, const char *src, char stop, unsigned int cnt)

memory allocation routines

struct BMS_BlkMem BMS_BLKMEM

internal miscellaneous methods for linear constraints

preparation of a linear inequality to become a SCIP_ROW

methods for selecting (weighted) k-medians

methods for sorting joint arrays of various types

miscellaneous datastructures

type definitions for message output methods

type definitions for miscellaneous datastructures

#define SCIP_DECL_PQUEUEELEMCHGPOS(x)

#define SCIP_DECL_SORTPTRCOMP(x)

#define SCIP_DECL_NEWTONEVAL(x)

enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL

type definitions for return codes for SCIP methods

enum SCIP_Retcode SCIP_RETCODE

type definitions for problem variables

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4