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 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; }
static void test_st_random(CuTest *testCase) { /* * Excercies the random int function. */ for(int32_t i = 0; i < 10000; i++) { CuAssertTrue(testCase, st_random() >= 0); CuAssertTrue(testCase, st_random() < 1.0); } }
static void testCalculateZScore(CuTest *testCase) { for(int64_t i=0; i<100; i++) { int64_t n = st_randomInt(0, 100); int64_t m = st_randomInt(0, 100); int64_t k = st_randomInt(1, 10000); double theta = st_random() > 0.05 ? st_random() : 0.0; double zScore = calculateZScore(n, m, k, theta); double zScoreSlow = calculateZScoreSlow(n, m, k, theta); st_logDebug("The slow computed score: %f the fast computed score: %f, n: %" PRIi64 " m: %" PRIi64 " k: %" PRIi64 ", theta: %lf\n", zScoreSlow, zScore, n, m, k, theta); CuAssertDblEquals(testCase, zScoreSlow, zScore, 0.000001); } }
static void testBreakUpPinchGraphAdjacencyComponentsGreedily(CuTest *testCase) { //return; for (int64_t test = 0; test < 10000; test++) { st_logInfo("Starting break up giant pinch graph components random test %" PRIi64 "\n", test); stPinchThreadSet *threadSet = stPinchThreadSet_getRandomGraph(); int64_t totalNodes = 2 * stPinchThreadSet_getTotalBlockNumber(threadSet); float maximumAdjacencyComponentSizeRatio = st_random() * 10; int64_t maximumAdjacencyComponentSize = log(maximumAdjacencyComponentSizeRatio) * totalNodes; if (maximumAdjacencyComponentSize < 2) { maximumAdjacencyComponentSize = 2; } stList *adjacencyComponents = stPinchThreadSet_getAdjacencyComponents(threadSet); int64_t largestAdjacencyComponentSizeInGraph = getSizeOfLargestAdjacencyComponent(adjacencyComponents); st_logInfo( "We have a random pinch graph with %" PRIi64 " nodes and %" PRIi64 " adjacency components, the largest adjacency component has %" PRIi64 " nodes, with a ratio of %f we will break up adjacency components larger than %" PRIi64 " in size, this will result in a breakup: %" PRIi64 "\n", totalNodes, stList_length(adjacencyComponents), largestAdjacencyComponentSizeInGraph, maximumAdjacencyComponentSizeRatio, maximumAdjacencyComponentSize, largestAdjacencyComponentSizeInGraph > maximumAdjacencyComponentSize); stList_destruct(adjacencyComponents); //Now do the actual breaking up stCaf_breakupComponentsGreedily(threadSet, maximumAdjacencyComponentSizeRatio); adjacencyComponents = stPinchThreadSet_getAdjacencyComponents(threadSet); int64_t largestAdjacencyComponentSizeInGraphAfterBreakup = getSizeOfLargestAdjacencyComponent(adjacencyComponents); totalNodes = 2 * stPinchThreadSet_getTotalBlockNumber(threadSet); st_logInfo( "After splitting we have a pinch graph with %" PRIi64 " nodes and %" PRIi64 " adjacency components, the largest adjacency component has %" PRIi64 " nodes, with a ratio of %f that broke up adjacency components larger than %" PRIi64 " in size\n", totalNodes, stList_length(adjacencyComponents), largestAdjacencyComponentSizeInGraphAfterBreakup, maximumAdjacencyComponentSizeRatio, maximumAdjacencyComponentSize); //Cleanup stList_destruct(adjacencyComponents); stPinchThreadSet_destruct(threadSet); } }
void hmm_randomise(Hmm *hmm) { //Transitions for (int64_t from = 0; from < hmm->stateNumber; from++) { for (int64_t to = 0; to < hmm->stateNumber; to++) { hmm_setTransition(hmm, from, to, st_random()); } } //Emissions for (int64_t state = 0; state < hmm->stateNumber; state++) { for (int64_t x = 0; x < SYMBOL_NUMBER_NO_N; x++) { for (int64_t y = 0; y < SYMBOL_NUMBER_NO_N; y++) { hmm_setEmissionsExpectation(hmm, state, x, y, st_random()); } } } hmm_normalise(hmm); }
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 void partialRecordRetrieval(CuTest *testCase) { setup(); //Make some number of large records stList *records = stList_construct3(0, free); stList *recordSizes = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct); for (int32_t i = 0; i < 300; i++) { int32_t size = st_randomInt(0, 80); size = size * size * size; //Use cubic size distribution char *randomRecord = st_malloc(size * sizeof(char)); for (int32_t j = 0; j < size; j++) { randomRecord[j] = (char) st_randomInt(0, 100); } stList_append(records, randomRecord); stList_append(recordSizes, stIntTuple_construct(1, size)); CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, i)); stKVDatabase_insertRecord(database, i, randomRecord, size * sizeof(char)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, i)); //st_uglyf("I am creating the record %i %i\n", i, size); } while (st_random() > 0.001) { int32_t recordKey = st_randomInt(0, stList_length(records)); CuAssertTrue(testCase, stKVDatabase_containsRecord(database, recordKey)); char *record = stList_get(records, recordKey); int32_t size = stIntTuple_getPosition(stList_get(recordSizes, recordKey), 0); //Get partial record int32_t start = size > 0 ? st_randomInt(0, size) : 0; int32_t partialSize = size - start > 0 ? st_randomInt(start, size) - start : 0; assert(start >= 0); assert(partialSize >= 0); assert(partialSize + start <= size); //st_uglyf("I am getting record %i %i %i %i\n", recordKey, start, partialSize, size); char *partialRecord = stKVDatabase_getPartialRecord(database, recordKey, start * sizeof(char), partialSize * sizeof(char), size * sizeof(char)); //Check they are equivalent.. for (int32_t i = 0; i < partialSize; i++) { if (record[start + i] != partialRecord[i]) { st_uglyf("There was a difference %i %i for record %i %i\n", record[start + i], partialRecord[i], i, partialSize); } //CuAssertTrue(testCase, record[start + i] == partialRecord[i]); } //Check we can not get out of bounds.. (start less than zero) stTry { stKVDatabase_getPartialRecord(database, recordKey, -1, 1, size * sizeof(char)); }stCatch(except) { CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID); }stTryEnd; //Check we can not get out of bounds.. (start greater than index start) stTry { stKVDatabase_getPartialRecord(database, recordKey, size, 1, size * sizeof(char)); }stCatch(except) { CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID); }stTryEnd; //Check we can not get out of bounds.. (total size if greater than record length) stTry { stKVDatabase_getPartialRecord(database, recordKey, 0, size + 1, size * sizeof(char)); }stCatch(except) { CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID); }stTryEnd; //Check we can not get non existent record stTry { stKVDatabase_getPartialRecord(database, 1000000, 0, size, size * sizeof(char)); }stCatch(except) { CuAssertTrue(testCase, stExcept_getId(except) == ST_KV_DATABASE_EXCEPTION_ID); }stTryEnd; } stList_destruct(records); stList_destruct(recordSizes); teardown(); }