static void testBulkSetRecords(CuTest *testCase) { /* * Tests doing a bulk update of a set of records. */ setup(); int64_t i = 100, j = 110, k = 120, l = 130; stKVDatabase_insertRecord(database, 1, &i, sizeof(int64_t)); stList *requests = stList_construct3(0, (void(*)(void *)) stKVDatabaseBulkRequest_destruct); stList_append(requests, stKVDatabaseBulkRequest_constructInsertRequest(2, &j, sizeof(int64_t))); stList_append(requests, stKVDatabaseBulkRequest_constructSetRequest(3, &k, sizeof(int64_t))); stList_append(requests, stKVDatabaseBulkRequest_constructUpdateRequest(1, &l, sizeof(int64_t))); stKVDatabase_bulkSetRecords(database, requests); stList_destruct(requests); int64_t *m = stKVDatabase_getRecord(database, 1); CuAssertTrue(testCase, m != NULL); CuAssertTrue(testCase, l == *m); free(m); m = stKVDatabase_getRecord(database, 2); CuAssertTrue(testCase, m != NULL); CuAssertTrue(testCase, j == *m); free(m); m = stKVDatabase_getRecord(database, 3); CuAssertTrue(testCase, m != NULL); CuAssertTrue(testCase, k == *m); free(m); teardown(); }
static void splitIntoAdjacenciesStubsAndChains(stList *subCycle, stList *adjacencyEdges, stList *stubEdges, stList *chainEdges, stList **subAdjacencyEdges, stList **subStubEdges, stList **subChainEdges) { /* * Splits run into cycles and chains.. */ *subStubEdges = stList_construct(); *subChainEdges = stList_construct(); for (int64_t j = 0; j < stList_length(subCycle); j++) { stIntTuple *edge = stList_get(subCycle, j); if (stList_contains(stubEdges, edge)) { stList_append(*subStubEdges, edge); } else if (stList_contains(chainEdges, edge)) { stList_append(*subChainEdges, edge); } } *subAdjacencyEdges = stList_construct(); stSortedSet *nodes = getNodeSetOfEdges(subCycle); for (int64_t j = 0; j < stList_length(adjacencyEdges); j++) { stIntTuple *edge = stList_get(adjacencyEdges, j); if (nodeInSet(nodes, stIntTuple_get(edge, 0)) && nodeInSet( nodes, stIntTuple_get(edge, 1))) { stList_append(*subAdjacencyEdges, edge); } } stSortedSet_destruct(nodes); }
static stList *mergeSubstrings(stList *substrings, int64_t proximityToMerge) { /* * Merge set of substrings into fewer substrings, if they overlap by less than proximityToMerge */ stList *mergedSubstrings = stList_construct3(0, (void (*)(void *)) substring_destruct); if (stList_length(substrings) == 0) { return mergedSubstrings; } stList_sort(substrings, (int (*)(const void *, const void *)) substring_cmp); Substring *pSubsequence = substring_clone(stList_get(substrings, 0)); stList_append(mergedSubstrings, pSubsequence); for (int64_t i = 1; i < stList_length(substrings); i++) { Substring *substring = stList_get(substrings, i); if (pSubsequence->name == substring->name && pSubsequence->start + pSubsequence->length + proximityToMerge >= substring->start) { //Merge if (pSubsequence->start + pSubsequence->length < substring->start + substring->length) { pSubsequence->length = substring->start + substring->length - pSubsequence->start; } } else { pSubsequence = substring_clone(substring); stList_append(mergedSubstrings, pSubsequence); } } return mergedSubstrings; }
static void setup() { teardown(); assert(nodeNumber == -1); while(nodeNumber % 2 != 0) { nodeNumber = st_randomInt(0, 100); } assert(nodeNumber >= 0); assert(nodeNumber % 2 == 0); stubs = stList_construct3(0, (void (*)(void *))stIntTuple_destruct); chains = stList_construct3(0, (void (*)(void *))stIntTuple_destruct); for(int64_t i=0; i<nodeNumber/2; i++) { assert(nodeNumber/2 > 0); stIntTuple *edge = stIntTuple_construct2(i, nodeNumber/2 + i); if(stList_length(stubs) == 0 || st_random() > 0.9) { stList_append(stubs, edge); } else { stList_append(chains, edge); } } zMatrix = st_calloc(nodeNumber*nodeNumber, sizeof(float)); for(int64_t i=0; i<nodeNumber; i++) { for(int64_t j=i+1; j<nodeNumber; j++) { double score = st_random(); zMatrix[i * nodeNumber + j] = score; zMatrix[j * nodeNumber + i] = score; } } st_logDebug("To test the adjacency problem we've created a problem with %" PRIi64 " nodes %" PRIi64 " stubs and %" PRIi64 " chains\n", nodeNumber, stList_length(stubs), stList_length(chains)); }
static void doBestMergeOfTwoSimpleCycles(stList *cycles, stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges) { /* * Merge two simple cycles, using the best possible adjacency switch. Modifies components list in place, * destroying two old components and adding a new one. If new adjacency edges are needed then they are * added to the adjacency edges list. */ assert(stList_length(cycles) > 1); /* * Get the best adjacency switch. */ AdjacencySwitch *adjacencySwitch = getBestAdjacencySwitch(cycles, nonZeroWeightAdjacencyEdges, allAdjacencyEdges); assert(adjacencySwitch != NULL); /* * Find the two components to merge. */ stList *cyclesToMerge = stList_construct3(0, (void(*)(void *)) stList_destruct); for (int64_t i = 0; i < stList_length(cycles); i++) { stList *cycle = stList_get(cycles, i); if (stList_contains(cycle, adjacencySwitch->oldEdge1)) { assert(!stList_contains(cycle, adjacencySwitch->oldEdge2)); stList_append(cyclesToMerge, cycle); } else if (stList_contains(cycle, adjacencySwitch->oldEdge2)) { stList_append(cyclesToMerge, cycle); } } /* * Now construct the new component and modify the list of components in place. */ assert(stList_length(cyclesToMerge) == 2); stList *newComponent = stList_join(cyclesToMerge); assert(!stList_contains(newComponent, NULL)); //Cleanup the old components assert(stList_contains(cycles, stList_get(cyclesToMerge, 0))); stList_removeItem(cycles, stList_get(cyclesToMerge, 0)); assert(stList_contains(cycles, stList_get(cyclesToMerge, 1))); stList_removeItem(cycles, stList_get(cyclesToMerge, 1)); stList_destruct(cyclesToMerge); //Now remove the old edges and add the new ones assert(stList_contains(newComponent, adjacencySwitch->oldEdge1)); stList_removeItem(newComponent, adjacencySwitch->oldEdge1); assert(stList_contains(newComponent, adjacencySwitch->oldEdge2)); stList_removeItem(newComponent, adjacencySwitch->oldEdge2); assert(!stList_contains(newComponent, adjacencySwitch->newEdge1)); stList_append(newComponent, adjacencySwitch->newEdge1); assert(!stList_contains(newComponent, adjacencySwitch->newEdge2)); stList_append(newComponent, adjacencySwitch->newEdge2); adjacencySwitch_destruct(adjacencySwitch); //Clean the adjacency switch. //Finally add the component to the list of components stList_append(cycles, newComponent); }
static stList *mergeSimpleCycles2(stList *chosenEdges, stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges, stList *stubEdges, stList *chainEdges) { /* * Returns a new set of chosen edges, modified by adjacency switches such that every simple cycle * contains at least one stub edge. */ /* * Calculate components. */ stList *components = getComponents2(chosenEdges, stubEdges, chainEdges); /* * Divide the components by the presence of one or more stub edges. */ stSortedSet *stubEdgesSet = stList_getSortedSet(stubEdges, (int(*)(const void *, const void *)) stIntTuple_cmpFn); stList *stubContainingComponents = stList_construct(); stList *stubFreeComponents = stList_construct(); for (int64_t i = 0; i < stList_length(components); i++) { stList *component = stList_get(components, i); stList_append( intersectionSize(stubEdgesSet, component) > 0 ? stubContainingComponents : stubFreeComponents, component); } assert(stList_length(stubContainingComponents) > 0); stSortedSet_destruct(stubEdgesSet); /* * Merge the stub containing components into one 'global' component */ stList *globalComponent = stList_join(stubContainingComponents); stList_destruct(stubContainingComponents); /* * Remove the stub/chain edges from the components. */ stList_append(stubFreeComponents, globalComponent); stList *adjacencyOnlyComponents = getStubAndChainEdgeFreeComponents( stubFreeComponents, stubEdges, chainEdges); stList_destruct(stubFreeComponents); stList_destruct(globalComponent); stList_destruct(components); //We only clean this up now, as this frees the components it contains. /* * Merge stub free components into the others. */ stList *updatedChosenEdges = mergeSimpleCycles(adjacencyOnlyComponents, nonZeroWeightAdjacencyEdges, allAdjacencyEdges); stList_destruct(adjacencyOnlyComponents); return updatedChosenEdges; }
static void test_stPosetAlignment_addAndIsPossible(CuTest *testCase) { for(int64_t trial=0; trial<100; trial++) { setup(); //Make random number of sequences. stList *sequenceLengths = stList_construct3(0, (void (*)(void *))stIntTuple_destruct); for(int64_t i=0; i<sequenceNumber; i++) { stList_append(sequenceLengths, stIntTuple_construct1( st_randomInt(0, MAX_SEQUENCE_SIZE))); } //Propose random alignment pairs... stList *pairs = stList_construct3(0, (void(*)(void *))stIntTuple_destruct); int64_t maxAlignedPairs = st_randomInt(0, MAX_ALIGNMENTS); if(sequenceNumber > 0) { for(int64_t i=0; i<maxAlignedPairs; i++) { int64_t seq1 = st_randomInt(0, sequenceNumber); int64_t seqLength1 = stIntTuple_get(stList_get(sequenceLengths, seq1), 0); if(seqLength1 == 0) { continue; } int64_t position1 = st_randomInt(0, seqLength1); int64_t seq2 = st_randomInt(0, sequenceNumber); int64_t seqLength2 = stIntTuple_get(stList_get(sequenceLengths, seq1), 0); if(seqLength2 == 0) { continue; } int64_t position2 = st_randomInt(0, seqLength2); if(seq1 != seq2) { stList_append(pairs, stIntTuple_construct4( seq1, position1, seq2, position2)); if(stPosetAlignment_isPossible(posetAlignment, seq1, position1, seq2, position2)) { st_logInfo("In %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 " \n", seq1, position1, seq2, position2); //For each accepted pair check it doesn't create a cycle. CuAssertTrue(testCase, !containsACycle(pairs, sequenceNumber)); CuAssertTrue(testCase, stPosetAlignment_add(posetAlignment, seq1, position1, seq2, position2)); } else { st_logInfo("Out %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 " \n", seq1, position1, seq2, position2); //For each rejected pair check it creates a cycle.. CuAssertTrue(testCase, containsACycle(pairs, sequenceNumber)); CuAssertTrue(testCase, !stPosetAlignment_isPossible(posetAlignment, seq1, position1, seq2, position2)); stIntTuple_destruct(stList_pop(pairs)); //remove the pair which created the cycle. CuAssertTrue(testCase, !containsACycle(pairs, sequenceNumber)); //Check we're back to being okay.. } } } } //Cleanup stList_destruct(sequenceLengths); stList_destruct(pairs); teardown(); st_logInfo("Passed a random ordering test with %" PRIi64 " sequences and %" PRIi64 " aligned pairs\n", sequenceNumber, maxAlignedPairs); } }
/* * Fill in a hashtable which to every node associates * alist of lifted edges */ static stHash *buildFaces_computeLiftedEdges(Flower * flower) { stHash *liftedEdgesTable = stHash_construct3(buildFaces_hashfunction, buildFaces_key_eq_fn, NULL, buildFaces_destructValue); Flower_CapIterator *iter = flower_getCapIterator(flower); Cap *cap, *attachedAncestor; Cap *adjacency, *adjacencyAncestor; stList *liftedEdges; LiftedEdge *liftedEdge; // Iterate through potential bottom nodes while ((cap = flower_getNextCap(iter))) { // ... check if connected if ((adjacency = cap_getAdjacency(cap))) { // ... lift attachedAncestor = cap_getTopCap(cap); adjacencyAncestor = cap_getTopCap(cap_getPositiveOrientation( adjacency)); #ifndef NDEBUG assert((attachedAncestor && adjacencyAncestor) || (!attachedAncestor && !adjacencyAncestor)); #endif // If root node if (attachedAncestor == NULL) continue; // ... create lifted edge liftedEdge = st_malloc(sizeof(LiftedEdge)); liftedEdge->destination = adjacencyAncestor; liftedEdge->bottomNode = cap; #ifndef NDEBUG // Self loop if (adjacencyAncestor == attachedAncestor) abort(); #endif // ... add it to the hashtable if ((liftedEdges = stHash_search(liftedEdgesTable, attachedAncestor))) { stList_append(liftedEdges, liftedEdge); } else { liftedEdges = stList_construct3(2, buildFaces_stList_destructElem); stList_append(liftedEdges, liftedEdge); stHash_insert(liftedEdgesTable, attachedAncestor, liftedEdges); } } } flower_destructCapIterator(iter); return liftedEdgesTable; }
static void makeMatchingPerfect(stList *chosenEdges, stList *adjacencyEdges, stSortedSet *nodes) { /* * While the the number of edges is less than a perfect matching add random edges. */ stSortedSet *attachedNodes = getNodeSetOfEdges(chosenEdges); stHash *nodesToAdjacencyEdges = getNodesToEdgesHash(adjacencyEdges); stIntTuple *pNode = NULL; stSortedSetIterator *it = stSortedSet_getIterator(nodes); stIntTuple *node; while((node = stSortedSet_getNext(it)) != NULL) { if (stSortedSet_search(attachedNodes, node) == NULL) { if (pNode == NULL) { pNode = node; } else { stList_append(chosenEdges, getEdgeForNodes(stIntTuple_get(pNode, 0), stIntTuple_get(node, 0), nodesToAdjacencyEdges)); pNode = NULL; } } } stSortedSet_destructIterator(it); assert(pNode == NULL); stSortedSet_destruct(attachedNodes); assert(stList_length(chosenEdges) * 2 == stSortedSet_size(nodes)); stHash_destruct(nodesToAdjacencyEdges); }
stList *chooseMatching_greedy(stList *edges, int64_t nodeNumber) { /* * Greedily picks the edge from the list such that each node has at most one edge. */ //First clone the list.. edges = stList_copy(edges, NULL); stSortedSet *seen = getEmptyNodeOrEdgeSetWithCleanup(); stList *matching = stList_construct(); //Sort the adjacency pairs.. stList_sort(edges, chooseMatching_greedyP); double strength = INT64_MAX; while (stList_length(edges) > 0) { stIntTuple *edge = stList_pop(edges); double d = stIntTuple_get(edge, 2); assert(d <= strength); strength = d; if(!nodeInSet(seen, stIntTuple_get(edge, 0)) && !nodeInSet(seen, stIntTuple_get(edge, 1))) { addNodeToSet(seen, stIntTuple_get(edge, 0)); addNodeToSet(seen, stIntTuple_get(edge, 1)); stList_append(matching,edge); } } assert(stList_length(edges) == 0); stList_destruct(edges); stSortedSet_destruct(seen); return matching; }
static stList *readMatching(FILE *fileHandle, stList *originalEdges) { /* * Reads the matching created by Blossum. */ stHash *originalEdgesHash = putEdgesInHash(originalEdges); char *line = stFile_getLineFromFile(fileHandle); assert(line != NULL); int64_t nodeNumber, edgeNumber; int64_t i = sscanf(line, "%" PRIi64 " %" PRIi64 "\n", &nodeNumber, &edgeNumber); assert(i == 2); free(line); stList *chosenEdges = stList_construct(); for(int64_t j=0; j<edgeNumber; j++) { line = stFile_getLineFromFile(fileHandle); int64_t node1, node2; i = sscanf(line, "%" PRIi64 " %" PRIi64 "", &node1, &node2); assert(i == 2); free(line); assert(node1 >= 0); assert(node1 < nodeNumber); assert(node2 >= 0); assert(node2 < nodeNumber); stIntTuple *edge = constructEdge(node1, node2); stIntTuple *originalEdge = stHash_search(originalEdgesHash, edge); if(originalEdge != NULL) { stList_append(chosenEdges, originalEdge); } stIntTuple_destruct(edge); } stHash_destruct(originalEdgesHash); return chosenEdges; }
/* * Recursive function which fills a givenlist with the * connected nodes within a module */ static void buildFaces_fillTopNodeList(Cap * cap, stList *list, stHash *liftedEdgesTable) { stList *liftedEdges; int64_t index; // Limit of recursion if (stList_contains(list, cap)) return; // Actual filling st_logInfo("Adding cap %p to face\n", cap); stList_append(list, cap); // Recursion through lifted edges if ((liftedEdges = stHash_search(liftedEdgesTable, cap))) for (index = 0; index < stList_length(liftedEdges); index++) buildFaces_fillTopNodeList( ((LiftedEdge *) stList_get(liftedEdges, index))->destination, list, liftedEdgesTable); // Recursion through adjacency if (cap_getAdjacency(cap)) buildFaces_fillTopNodeList(cap_getAdjacency(cap),list, liftedEdgesTable); }
static stList *getRandomPairwiseAlignments() { stList *pairwiseAlignments = stList_construct3(0, (void(*)(void *)) destructPairwiseAlignment); int64_t randomAlignmentNumber = st_randomInt(0, 10); for (int64_t i = 0; i < randomAlignmentNumber; i++) { char *contig1 = stString_print("%" PRIi64 "", i); char *contig2 = stString_print("%" PRIi64 "", i * 10); int64_t start1 = st_randomInt(100000, 1000000); int64_t start2 = st_randomInt(100000, 1000000); int64_t strand1 = st_random() > 0.5; int64_t strand2 = st_random() > 0.5; int64_t end1 = start1; int64_t end2 = start2; struct List *operationList = constructEmptyList(0, NULL); while (st_random() > 0.1) { int64_t length = st_randomInt(0, 10); int64_t type = st_randomInt(0, 3); assert(type < 3); listAppend(operationList, constructAlignmentOperation(type, length, 0)); if (type != PAIRWISE_INDEL_Y) { end1 += strand1 ? length : -length; } if (type != PAIRWISE_INDEL_X) { end2 += strand2 ? length : -length; } } stList_append(pairwiseAlignments, constructPairwiseAlignment(contig1, start1, end1, strand1, contig2, start2, end2, strand2, 0.0, operationList)); free(contig1); free(contig2); } return pairwiseAlignments; }
void stCaf_addAdjacencies(Flower *flower) { //Build a list of caps. stList *list = stList_construct(); Flower_EndIterator *endIterator = flower_getEndIterator(flower); End *end; while ((end = flower_getNextEnd(endIterator)) != NULL) { End_InstanceIterator *instanceIterator = end_getInstanceIterator(end); Cap *cap; while ((cap = end_getNext(instanceIterator)) != NULL) { if (!cap_getStrand(cap)) { cap = cap_getReverse(cap); } stList_append(list, cap); } end_destructInstanceIterator(instanceIterator); } flower_destructEndIterator(endIterator); assert(stList_length(list) % 2 == 0); //Sort the list of caps. stList_sort(list, (int(*)(const void *, const void *)) addAdjacenciesPP); //Now make the adjacencies. for (int64_t i = 1; i < stList_length(list); i += 2) { Cap *cap = stList_get(list, i - 1); Cap *cap2 = stList_get(list, i); cap_makeAdjacent(cap, cap2); } //Clean up. stList_destruct(list); }
static stList *getSubstringsForFlowerSegments(stList *flowers) { /* * Get the set of substrings representing the strings in the segments of the given flowers. */ stList *substrings = stList_construct3(0, (void (*)(void *)) substring_destruct); for (int64_t i = 0; i < stList_length(flowers); i++) { Flower *flower = stList_get(flowers, i); Flower_EndIterator *blockIt = flower_getBlockIterator(flower); Block *block; while ((block = flower_getNextBlock(blockIt)) != NULL) { Block_InstanceIterator *instanceIt = block_getInstanceIterator(block); Segment *segment; while ((segment = block_getNext(instanceIt)) != NULL) { Sequence *sequence; if ((sequence = segment_getSequence(segment)) != NULL) { segment = segment_getStrand(segment) ? segment : segment_getReverse(segment); assert(segment_getLength(segment) > 0); stList_append(substrings, substring_construct(sequence_getMetaSequence(sequence)->stringName, segment_getStart(segment) - sequence_getStart(sequence), segment_getLength(segment))); } } block_destructInstanceIterator(instanceIt); } flower_destructBlockIterator(blockIt); } return substrings; }
void test_stList_append(CuTest *testCase) { setup(); stList_append(list, NULL); CuAssertTrue(testCase, stList_length(list) == stringNumber+1); CuAssertTrue(testCase, stList_get(list, stringNumber) == NULL); teardown(); }
static void setup() { teardown(); list = stList_construct(); int64_t i; for(i=0; i<stringNumber; i++) { stList_append(list, strings[i]); } }
void stTree_setParent(stTree *tree, stTree *parent) { if(stTree_getParent(tree) != NULL) { stList_removeItem(stTree_getParent(tree)->nodes, tree); } tree->parent = parent; if(parent != NULL) { stList_append(parent->nodes, tree); } }
stList *stSet_getKeys(stSet *set) { stList *list = stList_construct(); stSetIterator *iterator = stSet_getIterator(set); void *item; while ((item = stSet_getNext(iterator)) != NULL) { stList_append(list, item); } stSet_destructIterator(iterator); return list; }
static AdjacencySwitch *getBest2EdgeAdjacencySwitch(stList *components, stSortedSet *allAdjacencyEdges) { /* * Look for the two lowest value adjacency edges in all current edges that are in a separate component and returns them as an adjacency switch * with now new adjacency edges. */ /* * Get lowest scoring edge for each component. */ stList *lowestScoringEdgeFromEachComponent = stList_construct(); for (int64_t i = 0; i < stList_length(components); i++) { stList_append(lowestScoringEdgeFromEachComponent, getLowestScoringEdge(stList_get(components, i))); } /* * Get two lowest scoring edges. */ stList_sort(lowestScoringEdgeFromEachComponent, getBest2EdgeAdjacencySwitchP); stIntTuple *lowestScoreEdge1 = stList_get( lowestScoringEdgeFromEachComponent, 0); stIntTuple *lowestScoreEdge2 = stList_get( lowestScoringEdgeFromEachComponent, 1); assert(lowestScoreEdge1 != lowestScoreEdge2); stList_destruct(lowestScoringEdgeFromEachComponent); //Cleanup stIntTuple *newEdge1 = getWeightedEdgeFromSet( stIntTuple_get(lowestScoreEdge1, 0), stIntTuple_get(lowestScoreEdge2, 0), allAdjacencyEdges); stIntTuple *newEdge2 = getWeightedEdgeFromSet( stIntTuple_get(lowestScoreEdge1, 1), stIntTuple_get(lowestScoreEdge2, 1), allAdjacencyEdges); if (newEdge1 == NULL) { assert(newEdge2 == NULL); newEdge1 = getWeightedEdgeFromSet( stIntTuple_get(lowestScoreEdge1, 0), stIntTuple_get(lowestScoreEdge2, 1), allAdjacencyEdges); newEdge2 = getWeightedEdgeFromSet( stIntTuple_get(lowestScoreEdge1, 1), stIntTuple_get(lowestScoreEdge2, 0), allAdjacencyEdges); } assert(newEdge1 != NULL); assert(newEdge2 != NULL); return adjacencySwitch_construct( lowestScoreEdge1, lowestScoreEdge2, newEdge1, newEdge2, stIntTuple_get(lowestScoreEdge1, 2) + stIntTuple_get(lowestScoreEdge2, 2)); }
/* build a list of blocks, sorted by the root components */ static stList *buildRootSorted(struct malnSet *malnSet) { stList *sorted = stList_construct(); struct malnBlkSetIterator *iter = malnBlkSet_getIterator(malnSet->blks); struct malnBlk *blk; while ((blk = malnBlkSetIterator_getNext(iter)) != NULL) { stList_append(sorted, blk); } malnBlkSetIterator_destruct(iter); stList_sort(sorted, blkCmpRootComp); return sorted; }
static void testBulkRemoveRecords(CuTest *testCase) { /* * Tests doing a bulk update of a set of records. */ setup(); int64_t i = 100, j = 110, k = 120, l = 130; stKVDatabase_insertRecord(database, 1, &i, sizeof(int64_t)); stKVDatabase_insertRecord(database, 2, &j, sizeof(int64_t)); stKVDatabase_insertRecord(database, 3, &k, sizeof(int64_t)); stKVDatabase_insertRecord(database, 4, &l, sizeof(int64_t)); stKVDatabase_insertRecord(database, 5, &i, 0); //Test null record addition CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 1)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 2)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 3)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 4)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 5)); CuAssertTrue(testCase, stKVDatabase_getNumberOfRecords(database) == 5); stList *requests = stList_construct3(0, (void(*)(void *)) stInt64Tuple_destruct); // test empty request list stKVDatabase_bulkRemoveRecords(database, requests); stList_append(requests, stInt64Tuple_construct(1, (int64_t)1)); stList_append(requests, stInt64Tuple_construct(1, (int64_t)2)); stList_append(requests, stInt64Tuple_construct(1, (int64_t)3)); stList_append(requests, stInt64Tuple_construct(1, (int64_t)4)); stList_append(requests, stInt64Tuple_construct(1, (int64_t)5)); stKVDatabase_bulkRemoveRecords(database, requests); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 1)); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 2)); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 3)); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 4)); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 5)); CuAssertTrue(testCase, stKVDatabase_getNumberOfRecords(database) == 0); stList_destruct(requests); teardown(); }
void cactusDisk_addUpdateRequest(CactusDisk *cactusDisk, Flower *flower) { int64_t recordSize; void *vA = binaryRepresentation_makeBinaryRepresentation(flower, (void (*)(void *, void (*)(const void * ptr, size_t size, size_t count))) flower_writeBinaryRepresentation, &recordSize); //Compression vA = compress(vA, &recordSize); if (containsRecord(cactusDisk, flower_getName(flower))) { int64_t recordSize2; void *vA2 = stCache_getRecord(cactusDisk->cache, flower_getName(flower), 0, INT64_MAX, &recordSize2); if (!stCache_recordsIdentical(vA, recordSize, vA2, recordSize2)) { //Only rewrite if we actually did something stList_append(cactusDisk->updateRequests, stKVDatabaseBulkRequest_constructUpdateRequest(flower_getName(flower), vA, recordSize)); } free(vA2); } else { stList_append(cactusDisk->updateRequests, stKVDatabaseBulkRequest_constructInsertRequest(flower_getName(flower), vA, recordSize)); } free(vA); }
static stList *filterListsToExclude(stList *listOfLists, stSortedSet *set) { /* * Takes a list of lists and returns a new list of lists whose elements are the product of applying * filterToExclude to each member of listOfLists in the same order. */ stList *listOfLists2 = stList_construct3(0, (void(*)(void *)) stList_destruct); for (int64_t i = 0; i < stList_length(listOfLists); i++) { stList_append(listOfLists2, stList_filterToExclude(stList_get(listOfLists, i), set)); } return listOfLists2; }
int main(int argc, char *argv[]) { ////////////////////////////////////////////// //Parse the inputs ////////////////////////////////////////////// parseBasicArguments(argc, argv, "linkageStats"); /////////////////////////////////////////////////////////////////////////// // Get the intervals /////////////////////////////////////////////////////////////////////////// stList *haplotypeEventStrings = getEventStrings( treatHaplotype1AsContamination ? NULL : hap1EventString, treatHaplotype2AsContamination ? NULL : hap2EventString); stList *assemblyEventStringInList = stList_construct(); stList_append(assemblyEventStringInList, assemblyEventString); stList *intervals = stList_construct3(0, (void (*)(void *))sequenceInterval_destruct); for(int64_t i=0; i<stList_length(haplotypeEventStrings); i++) { const char *hapEventString = stList_get(haplotypeEventStrings, i); st_logInfo("Getting contig paths for haplotype: %s", hapEventString); stList *contigPaths = getContigPaths(flower, hapEventString, assemblyEventStringInList); stList *hapIntervals = getSplitContigPathIntervals(flower, contigPaths, hapEventString, assemblyEventStringInList); stList_destruct(contigPaths); st_logInfo("Getting contig paths\n"); stList_appendAll(intervals, hapIntervals); stList_setDestructor(hapIntervals, NULL); stList_destruct(hapIntervals); } st_logDebug("Got a total of %" PRIi64 " intervals\n", stList_length(intervals)); /////////////////////////////////////////////////////////////////////////// // Write it out. /////////////////////////////////////////////////////////////////////////// FILE *fileHandle = fopen(outputFile, "w"); for (int64_t i = 0; i < stList_length(intervals); i++) { SequenceInterval *sequenceInterval = stList_get(intervals, i); st_logDebug("We have a path interval %s %" PRIi64 " %" PRIi64 "\n", sequenceInterval->sequenceName, sequenceInterval->start, sequenceInterval->end); fprintf(fileHandle, "%s %" PRIi64 " %" PRIi64 "\n", sequenceInterval->sequenceName, sequenceInterval->start, sequenceInterval->end); } st_logInfo("Finished writing out the stats.\n"); fclose(fileHandle); return 0; }
static void setup() { teardown(); //Make nodes nodes = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct); int64_t nodeNumber = st_randomInt(0, 1000); for (int64_t i = 0; i < nodeNumber; i++) { stList_append(nodes, stIntTuple_construct1( i)); } //Make edges edges = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct); float edgeProb = st_random(); for (int64_t i = 0; i < nodeNumber; i++) { for (int64_t j = i; j < nodeNumber; j++) { if (st_random() <= edgeProb) { stList_append(edges, stIntTuple_construct3( st_randomInt(1, 100), i, j)); } } } //Max component size maxComponentSize = 1 + log(nodeNumber) * 10; //(st_randomInt(0, nodeNumber+1); }
static stList *getOddToEvenAdjacencyEdges(stSortedSet *oddNodes, stList *adjacencyEdges) { /* * Gets edges that include one node in the set of oddNodes, but not both. */ stList *oddToEvenAdjacencyEdges = stList_construct(); for (int64_t i = 0; i < stList_length(adjacencyEdges); i++) { stIntTuple *edge = stList_get(adjacencyEdges, i); if (nodeInSet(oddNodes, stIntTuple_get(edge, 0)) ^ nodeInSet( oddNodes, stIntTuple_get(edge, 1))) { stList_append(oddToEvenAdjacencyEdges, edge); } } return oddToEvenAdjacencyEdges; }
static void getMaximalHaplotypePathsP3(Segment *segment, stList *maximalHaplotypePath, stSortedSet *segmentSet, stList *eventStrings) { stList_append(maximalHaplotypePath, segment); assert(stSortedSet_search(segmentSet, segment) == NULL); assert(stSortedSet_search(segmentSet, segment_getReverse(segment)) == NULL); stSortedSet_insert(segmentSet, segment); Cap *_3Cap = segment_get3Cap(segment); if (trueAdjacency(_3Cap, eventStrings)) { //Continue on.. Segment *otherSegment = getAdjacentCapsSegment(_3Cap); if (otherSegment != NULL) { getMaximalHaplotypePathsP3(otherSegment, maximalHaplotypePath, segmentSet, eventStrings); } } }
static void test_stSet_removeAndFreeKey(CuTest* testCase) { stSet *set2 = stSet_construct2(free); stList *keys = stList_construct(); int64_t keyNumber = 1000; for (int64_t i = 0; i < keyNumber; i++) { int64_t *key = st_malloc(sizeof(*key)); stList_append(keys, key); stSet_insert(set2, key); } for (int64_t i = 0; i < keyNumber; i++) { int64_t *key = stList_get(keys, i); CuAssertPtrEquals(testCase, key, stSet_removeAndFreeKey(set2, key)); } CuAssertIntEquals(testCase, 0, stSet_size(set2)); stSet_destruct(set2); stList_destruct(keys); }
/* * Fill uplist with bottom nodes for top node */ static void buildFaces_computeLiftedEdgesAtTopNode(Cap * cap, stList * liftedEdges) { int64_t childIndex; LiftedEdge * liftedEdge; // Termination if (cap_getAdjacency(cap)) { liftedEdge = st_malloc(sizeof(LiftedEdge)); liftedEdge->bottomNode = cap_getPositiveOrientation(cap); liftedEdge->destination = cap_getPositiveOrientation(cap_getTopCap(cap_getAdjacency(cap))); stList_append(liftedEdges, liftedEdge); return; } // Recursion through children for (childIndex = 0; childIndex < cap_getChildNumber(cap); childIndex++) buildFaces_computeLiftedEdgesAtTopNode(cap_getChild(cap, childIndex), liftedEdges); }