static void checkIsValidReference(CuTest *testCase, stList *reference, double totalScore) { stList *chosenEdges = convertReferenceToAdjacencyEdges(reference); //Check that everyone has a partner. CuAssertIntEquals(testCase, nodeNumber, stList_length(chosenEdges) * 2); stSortedSet *nodes = stSortedSet_construct3((int(*)(const void *, const void *)) stIntTuple_cmpFn, (void(*)(void *)) stIntTuple_destruct); for (int64_t i = 0; i < nodeNumber; i++) { stSortedSet_insert(nodes, stIntTuple_construct1( i)); } checkEdges(chosenEdges, nodes, 1, 0); //Check that the score is correct double totalScore2 = calculateZScoreOfReference(reference, nodeNumber, zMatrix); CuAssertDblEquals(testCase, totalScore2, totalScore, 0.000001); //Check that the stubs are properly connected. stList *allEdges = stList_copy(chosenEdges, NULL); stList_appendAll(allEdges, stubs); stList_appendAll(allEdges, chains); stList *components = getComponents(allEdges); CuAssertIntEquals(testCase, stList_length(stubs), stList_length(reference)); CuAssertIntEquals(testCase, stList_length(stubs), stList_length(components)); //Cleanup stList_destruct(components); stSortedSet_destruct(nodes); stList_destruct(allEdges); stList_destruct(chosenEdges); }
static stSortedSet *getSetOfMergedLists(stList *list1, stList *list2) { /* * Returns a sorted set of two input lists. */ stList *list3 = stList_copy(list1, NULL); stList_appendAll(list3, list2); stSortedSet *set = stList_getSortedSet(list3, NULL); stList_destruct(list3); return set; }
stList *splitMultipleStubCycles(stList *chosenEdges, stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges, stList *stubEdges, stList *chainEdges) { /* * Returns an updated list of adjacency edges, such that each stub edge is a member of exactly one cycle. */ /* * Calculate components. */ stList *cycles = getComponents2(chosenEdges, stubEdges, chainEdges); /* * Find components with multiple stub edges. */ stList *singleStubEdgeCycles = stList_construct3(0, (void(*)(void *)) stList_destruct); for (int64_t i = 0; i < stList_length(cycles); i++) { stList *subCycle = stList_get(cycles, i); stList *subAdjacencyEdges; stList *subStubEdges; stList *subChainEdges; splitIntoAdjacenciesStubsAndChains(subCycle, nonZeroWeightAdjacencyEdges, stubEdges, chainEdges, &subAdjacencyEdges, &subStubEdges, &subChainEdges); stList *splitCycles = splitMultipleStubCycle(subCycle, subAdjacencyEdges, allAdjacencyEdges, subStubEdges, subChainEdges); stList_appendAll(singleStubEdgeCycles, splitCycles); stList_setDestructor(splitCycles, NULL); //Do this to avoid destroying the underlying lists stList_destruct(splitCycles); stList_destruct(subAdjacencyEdges); stList_destruct(subStubEdges); stList_destruct(subChainEdges); } stList_destruct(cycles); /* * Remove the stub/chain edges from the components. */ stSortedSet *stubAndChainEdgesSet = getSetOfMergedLists(stubEdges, chainEdges); stList *adjacencyOnlyComponents = filterListsToExclude( singleStubEdgeCycles, stubAndChainEdgesSet); stList_destruct(singleStubEdgeCycles); stSortedSet_destruct(stubAndChainEdgesSet); /* * Merge the adjacency edges in the components into a single list. */ stList *updatedChosenEdges = stList_join(adjacencyOnlyComponents); stList_destruct(adjacencyOnlyComponents); return updatedChosenEdges; }
stList *getComponents2(stList *adjacencyEdges, stList *stubEdges, stList *chainEdges) { /* * Gets a list of connected components for a set of adjacency, stub and chain edges. * If adjacencyEdges, stubEdges or chainEdges are NULL then they are ignored. */ stList *allEdges = stList_construct(); //Build a concatenated list of all the chain, stub and adjacency edges. if (adjacencyEdges != NULL) { stList_appendAll(allEdges, adjacencyEdges); } if (stubEdges != NULL) { stList_appendAll(allEdges, stubEdges); } if (chainEdges != NULL) { stList_appendAll(allEdges, chainEdges); } stList *components = getComponents(allEdges); //Gets the graph components. stList_destruct(allEdges); //Cleanup the all edges. return components; }
void test_stList_appendAll(CuTest *testCase) { setup(); stList *list2 = stList_copy(list, NULL); stList_appendAll(list, list2); CuAssertTrue(testCase, stList_length(list) == stringNumber * 2); int64_t i; for(i=0; i<stringNumber*2; i++) { CuAssertTrue(testCase, stList_get(list, i) == strings[i % stringNumber]); } stList_destruct(list2); teardown(); }
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; }
void checkInputs(stSortedSet *nodes, stList *adjacencyEdges, stList *stubEdges, stList *chainEdges) { /* * Checks the inputs to the algorithm are as expected. */ int64_t nodeNumber = stSortedSet_size(nodes); assert(nodeNumber % 2 == 0); if (nodeNumber > 0) { assert(stList_length(stubEdges) > 0); } assert( stList_length(stubEdges) + stList_length(chainEdges) == (nodeNumber / 2)); checkEdges(stubEdges, nodes, 0, 0); checkEdges(chainEdges, nodes, 0, 0); stList *stubsAndChainEdges = stList_copy(stubEdges, NULL); stList_appendAll(stubsAndChainEdges, chainEdges); checkEdges(stubsAndChainEdges, nodes, 1, 0); stList_destruct(stubsAndChainEdges); checkEdges(adjacencyEdges, nodes, 1, 1); }
static stList *splitMultipleStubCycle(stList *cycle, stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges, stList *stubEdges, stList *chainEdges) { /* * Takes a simple cycle containing k stub edges and splits into k cycles, each containing 1 stub edge. */ /* * Get sub-components containing only adjacency and chain edges. */ stSortedSet *stubAndChainEdgesSet = getSetOfMergedLists(stubEdges, chainEdges); stList *adjacencyEdgeMatching = stList_filterToExclude(cycle, stubAndChainEdgesSet); //Filter out the the non-adjacency edges //Make it only the chain edges present in the original component stList *stubFreePaths = getComponents2(adjacencyEdgeMatching, NULL, chainEdges); stList_destruct(adjacencyEdgeMatching); assert(stList_length(stubFreePaths) >= 1); stList *splitCycles = stList_construct3(0, (void(*)(void *)) stList_destruct); //The list to return. if (stList_length(stubFreePaths) > 1) { /* * Build the list of adjacency edges acceptable in the merge */ stSortedSet *oddNodes = getOddNodes(cycle); stList *oddToEvenNonZeroWeightAdjacencyEdges = getOddToEvenAdjacencyEdges(oddNodes, nonZeroWeightAdjacencyEdges); stSortedSet *oddToEvenAllAdjacencyEdges = getOddToEvenAdjacencyEdges2(oddNodes, allAdjacencyEdges); /* * Merge together the best two components. */ stList *l = filterListsToExclude(stubFreePaths, stubAndChainEdgesSet); doBestMergeOfTwoSimpleCycles(l, oddToEvenNonZeroWeightAdjacencyEdges, oddToEvenAllAdjacencyEdges); //This is inplace. stList *l2 = stList_join(l); stList_destruct(l); l = getComponents2(l2, stubEdges, chainEdges); assert(stList_length(l) == 2); stList_destruct(l2); /* * Cleanup */ stSortedSet_destruct(oddNodes); stList_destruct(oddToEvenNonZeroWeightAdjacencyEdges); stSortedSet_destruct(oddToEvenAllAdjacencyEdges); /* * Call procedure recursively. */ for (int64_t i = 0; i < stList_length(l); i++) { /* * Split into adjacency edges, stub edges and chain edges. */ stList *subCycle = stList_get(l, i); stList *subAdjacencyEdges; stList *subStubEdges; stList *subChainEdges; splitIntoAdjacenciesStubsAndChains(subCycle, nonZeroWeightAdjacencyEdges, stubEdges, chainEdges, &subAdjacencyEdges, &subStubEdges, &subChainEdges); /* * Call recursively. */ l2 = splitMultipleStubCycle(subCycle, subAdjacencyEdges, allAdjacencyEdges, subStubEdges, subChainEdges); stList_appendAll(splitCycles, l2); /* * Clean up */ stList_setDestructor(l2, NULL); stList_destruct(l2); stList_destruct(subAdjacencyEdges); stList_destruct(subStubEdges); stList_destruct(subChainEdges); } stList_destruct(l); } else { stList_append(splitCycles, stList_copy(cycle, NULL)); } stSortedSet_destruct(stubAndChainEdgesSet); stList_destruct(stubFreePaths); return splitCycles; }