static char *eventTree_makeNewickStringP(Event *event) {
int64_t i;
char *cA = NULL;
char *cA3;
if(event_getChildNumber(event) > 0) {
for(i=0;i<event_getChildNumber(event); i++) {
char *cA2 = eventTree_makeNewickStringP(event_getChild(event, i));
if(i > 0) {
cA3 = st_malloc(sizeof(char)*(strlen(cA)+strlen(cA2)+2));
sprintf(cA3, "%s,%s", cA, cA2);
free(cA);
cA = cA3;
}
else {
cA = st_malloc(sizeof(char)*(strlen(cA2)+2));
sprintf(cA, "(%s", cA2);
}
free(cA2);
}
cA3 = st_malloc(sizeof(char)*(strlen(cA) + strlen(event_getHeader(event)) + 30));
sprintf(cA3, "%s)%s:%g", cA, event_getHeader(event), event_getBranchLength(event));
free(cA);
cA = cA3;
}
else {
cA = st_malloc(sizeof(char)*(strlen(event_getHeader(event)) + 30));
sprintf(cA, "%s:%g", event_getHeader(event), event_getBranchLength(event));
}
return cA;
}
Hmm *hmm_constructEmpty(double pseudoExpectation, StateMachineType type) {
Hmm *hmm = st_malloc(sizeof(Hmm));
hmm->type = type;
switch (type) {
case fiveState:
case fiveStateAsymmetric:
hmm->stateNumber = 5;
break;
case threeState:
case threeStateAsymmetric:
hmm->stateNumber = 3;
break;
default:
st_errAbort("Unrecognised state type: %i\n", type);
}
hmm->transitions = st_malloc(hmm->stateNumber * hmm->stateNumber * sizeof(double));
for (int64_t i = 0; i < hmm->stateNumber * hmm->stateNumber; i++) {
hmm->transitions[i] = pseudoExpectation;
}
hmm->emissions = st_malloc(hmm->stateNumber * SYMBOL_NUMBER_NO_N * SYMBOL_NUMBER_NO_N * sizeof(double));
for (int64_t i = 0; i < hmm->stateNumber * SYMBOL_NUMBER_NO_N * SYMBOL_NUMBER_NO_N; i++) {
hmm->emissions[i] = pseudoExpectation;
}
hmm->likelihood = 0.0;
return hmm;
}
Block *block_construct2(Name name, int64_t length,
End *leftEnd, End *rightEnd,
Flower *flower) {
Block *block;
block = st_malloc(sizeof(Block));
block->rBlock = st_malloc(sizeof(Block));
block->rBlock->rBlock = block;
block->blockContents = st_malloc(sizeof(BlockContents));
block->rBlock->blockContents = block->blockContents;
block->orientation = 1;
block->rBlock->orientation = 0;
block->blockContents->name = name;
block->blockContents->segments = stSortedSet_construct3(blockConstruct_constructP, NULL);
block->blockContents->length = length;
block->blockContents->flower = flower;
block->leftEnd = leftEnd;
end_setBlock(leftEnd, block);
block->rBlock->leftEnd = end_getReverse(rightEnd);
end_setBlock(rightEnd, block);
flower_addBlock(flower, block);
return block;
}
static void test_stSet_getUnion(CuTest* testCase) {
testSetup();
// Check union of empty sets is empty
stSet *set2 = stSet_construct();
stSet *set3 = stSet_construct();
stSet *set4 = stSet_getUnion(set2, set3);
CuAssertTrue(testCase, stSet_size(set4) == 0);
stSet_destruct(set2);
stSet_destruct(set3);
stSet_destruct(set4);
// Check union of non empty set and empty set is non-empty
set2 = stSet_construct();
set3 = stSet_getUnion(set0, set2);
CuAssertTrue(testCase, stSet_size(set3) == 6);
stSet_destruct(set2);
stSet_destruct(set3);
// Check union of two non-empty overlapping sets is correct
set2 = stSet_construct();
set3 = stSet_construct();
stIntTuple **uniqs = (stIntTuple **) st_malloc(sizeof(*uniqs) * 4);
uniqs[0] = stIntTuple_construct2(9, 0);
uniqs[1] = stIntTuple_construct2(9, 1);
uniqs[2] = stIntTuple_construct2(9, 2);
uniqs[3] = stIntTuple_construct2(9, 3);
stIntTuple **common = (stIntTuple **) st_malloc(sizeof(*uniqs) * 5);
common[0] = stIntTuple_construct2(5, 0);
common[1] = stIntTuple_construct2(5, 1);
common[2] = stIntTuple_construct2(5, 2);
common[3] = stIntTuple_construct2(5, 3);
common[4] = stIntTuple_construct2(5, 4);
for (int i = 0; i < 5; ++i) {
stSet_insert(set2, common[i]);
stSet_insert(set3, common[i]);
}
stSet_insert(set2, uniqs[0]);
stSet_insert(set2, uniqs[1]);
stSet_insert(set3, uniqs[2]);
stSet_insert(set3, uniqs[3]);
set4 = stSet_getUnion(set2, set3);
CuAssertTrue(testCase, stSet_size(set4) == 9);
for (int i = 0; i < 4; ++i) {
CuAssertTrue(testCase, stSet_search(set4, uniqs[i]) != NULL);
}
for (int i = 0; i < 5; ++i) {
CuAssertTrue(testCase, stSet_search(set4, common[i]) != NULL);
}
stSet_destruct(set2);
stSet_destruct(set3);
stSet_destruct(set4);
// Check we get an exception with sets with different functions.
stTry {
stSet_getUnion(set0, set1);
} stCatch(except) {
CuAssertTrue(testCase, stExcept_getId(except) == SET_EXCEPTION_ID);
} stTryEnd
testTeardown();
}
stSortedSet *stSortedSet_construct3(int (*compareFn)(const void *, const void *),
void (*destructElementFn)(void *)) {
stSortedSet *sortedSet = st_malloc(sizeof(stSortedSet));
struct _stSortedSet_construct3Fn *i = st_malloc(sizeof(struct _stSortedSet_construct3Fn));
i->compareFn = compareFn == NULL ? st_sortedSet_cmpFn : compareFn; //this is a total hack to make the function pass ISO C compatible.
sortedSet->sortedSet = avl_create((int (*)(const void *, const void *, void *))st_sortedSet_construct3P, i, NULL);
sortedSet->destructElementFn = destructElementFn;
sortedSet->numberOfLiveIterators = 0;
return sortedSet;
}
stPosetAlignment *stPosetAlignment_construct(int64_t sequenceNumber) {
stPosetAlignment *posetAlignment = st_malloc(sizeof(stPosetAlignment));
posetAlignment->sequenceNumber = sequenceNumber;
posetAlignment->constraintLists = st_malloc(sizeof(stSortedSet *) * sequenceNumber * sequenceNumber);
for(int64_t i=0; i<posetAlignment->sequenceNumber; i++) {
for(int64_t j=0; j<posetAlignment->sequenceNumber; j++) {
if(i != j) {
posetAlignment->constraintLists[i*posetAlignment->sequenceNumber + j] =
stSortedSet_construct3((int (*)(const void *, const void *))comparePositions,
(void (*)(void *))stIntTuple_destruct);
}
}
}
return posetAlignment;
}
static Flower *flower_construct3(Name name, CactusDisk *cactusDisk) {
Flower *flower;
flower = st_malloc(sizeof(Flower));
flower->name = name;
flower->sequences = stSortedSet_construct3(flower_constructSequencesP, NULL);
flower->caps = stSortedSet_construct3(flower_constructCapsP, NULL);
flower->ends = stSortedSet_construct3(flower_constructEndsP, NULL);
flower->segments = stSortedSet_construct3(flower_constructSegmentsP, NULL);
flower->blocks = stSortedSet_construct3(flower_constructBlocksP, NULL);
flower->groups = stSortedSet_construct3(flower_constructGroupsP, NULL);
flower->chains = stSortedSet_construct3(flower_constructChainsP, NULL);
flower->faces = stSortedSet_construct3(flower_constructFacesP, NULL);
flower->parentFlowerName = NULL_NAME;
flower->cactusDisk = cactusDisk;
flower->faceIndex = 0;
flower->chainIndex = 0;
flower->builtBlocks = 0;
flower->builtFaces = 0;
flower->builtTrees = 0;
cactusDisk_addFlower(flower->cactusDisk, flower);
flower->eventTree = NULL;
return flower;
}
static char *
filter_double_bangs (const char *chunk)
{
st_uint size, i = 0, count = 0;
const char *p = chunk;
char *buf;
size = strlen (chunk);
if (size < 2)
return st_strdup (chunk);
/* count number of redundant bangs */
while (p[0] && p[1]) {
if (ST_UNLIKELY (p[0] == '!' && p[1] == '!'))
count++;
p++;
}
buf = st_malloc (size - count + 1);
/* copy over text skipping over redundant bangs */
p = chunk;
while (*p) {
if (*p == '!')
p++;
buf[i++] = *p;
p++;
}
buf[i] = 0;
return buf;
}
char *cStr_getStringFromIntArray(int64_t *array, int64_t size, const char sep) {
int64_t i;
int numChars = 0;
char *string = NULL;
char buffer[64];
for (i = 0; i < size; i++) {
numChars += cStr_getIntLength(array[i]);
}
numChars += (size - 1);
string = st_malloc(sizeof(char) * (numChars + 1));
string[0] = '\0';
cStr_itoa(array[0], buffer);
strcat(string, buffer);
for (i = 1; i < size; i++) {
cStr_appendChar(string, sep);
cStr_itoa(array[i], buffer);
strcat(string, buffer);
}
i = strlen(string);
string[i+1] = '\0';
return string;
}
Block_InstanceIterator *block_copyInstanceIterator(Block_InstanceIterator *iterator) {
Block_InstanceIterator *iterator2;
iterator2 = st_malloc(sizeof(struct _block_instanceIterator));
iterator2->block = iterator->block;
iterator2->iterator = stSortedSet_copyIterator(iterator->iterator);
return iterator2;
}
Block_InstanceIterator *block_getInstanceIterator(Block *block) {
Block_InstanceIterator *iterator;
iterator = st_malloc(sizeof(struct _block_instanceIterator));
iterator->block = block;
iterator->iterator = stSortedSet_getIterator(block->blockContents->segments);
return iterator;
}
struct hashtable_itr *
hashtable_iterator(struct hashtable *h)
{
unsigned int i, tablelength;
struct hashtable_itr *itr = (struct hashtable_itr *)
st_malloc(sizeof(struct hashtable_itr));
if (NULL == itr) return NULL;
itr->h = h;
itr->e = NULL;
itr->parent = NULL;
tablelength = h->tablelength;
itr->index = tablelength;
if (0 == h->entrycount) return itr;
for (i = 0; i < tablelength; i++)
{
if (NULL != h->table[i])
{
itr->e = h->table[i];
itr->index = i;
break;
}
}
return itr;
}
StateMachine *stateMachine3_construct(StateMachineType type) {
StateMachine3 *sM3 = st_malloc(sizeof(StateMachine3));
sM3->TRANSITION_MATCH_CONTINUE = -0.030064059121770816; //0.9703833696510062f
sM3->TRANSITION_MATCH_FROM_GAP_X = -1.272871422049609; //1.0 - gapExtend - gapSwitch = 0.280026392297485
sM3->TRANSITION_MATCH_FROM_GAP_Y = -1.272871422049609; //1.0 - gapExtend - gapSwitch = 0.280026392297485
sM3->TRANSITION_GAP_OPEN_X = -4.21256642; //0.0129868352330243
sM3->TRANSITION_GAP_OPEN_Y = -4.21256642; //0.0129868352330243
sM3->TRANSITION_GAP_EXTEND_X = -0.3388262689231553; //0.7126062401851738f;
sM3->TRANSITION_GAP_EXTEND_Y = -0.3388262689231553; //0.7126062401851738f;
sM3->TRANSITION_GAP_SWITCH_TO_X = -4.910694825551255; //0.0073673675173412815f;
sM3->TRANSITION_GAP_SWITCH_TO_Y = -4.910694825551255; //0.0073673675173412815f;
emissions_setMatchProbsToDefaults(sM3->EMISSION_MATCH_PROBS);
emissions_setGapProbsToDefaults(sM3->EMISSION_GAP_X_PROBS);
emissions_setGapProbsToDefaults(sM3->EMISSION_GAP_Y_PROBS);
if (type != threeState && type != threeStateAsymmetric) {
st_errAbort("Tried to create a three state state-machine with the wrong type");
}
sM3->model.type = type;
sM3->model.stateNumber = 3;
sM3->model.matchState = match;
sM3->model.startStateProb = stateMachine3_startStateProb;
sM3->model.endStateProb = stateMachine3_endStateProb;
sM3->model.raggedStartStateProb = stateMachine3_raggedStartStateProb;
sM3->model.raggedEndStateProb = stateMachine3_raggedEndStateProb;
sM3->model.cellCalculate = stateMachine3_cellCalculate;
return (StateMachine *) sM3;
}
static void test_st_randomInt64_distribution_0(CuTest *testCase) {
/*
* check the distribution of the randomInt64 function
*/
double med, var, mu = 0.0;
uint64_t n = 1000000;
uint64_t reps = 50;
int64_t min = 0;
int64_t max = 101;
int64_t *array = NULL;
for (uint64_t j = 0; j < reps; ++j) {
array = (int64_t *) st_malloc(sizeof(*array) * n);
for (int64_t i = 0; i < n; i++) {
array[i] = st_randomInt64(min, max);
mu = runningMean64(mu, array[i], i);
}
var = sv64(array, n, mu);
med = median64(array, n); // median() will sort array
CuAssertTrue(testCase, array[0] <= array[n - 1]);
CuAssertTrue(testCase, array[0] < max);
CuAssertTrue(testCase, array[n - 1] < max);
// median of discrete uniform is
// median = (a + b) / 2
CuAssertTrue(testCase, med == 50.0);
// mean of discrete uniform is
// mu = (a + b) / 2
CuAssertTrue(testCase, mu > 0.9 * (max - 1) / 2.0);
CuAssertTrue(testCase, mu < 1.1 * (max - 1) / 2.0);
// variance of discrete uniform is
// var = ((b - a + 1)^2 - 1) / 12
CuAssertTrue(testCase, var < 1.1 * (((max - min + 1) * (max - min + 1) - 1) / 12.0));
CuAssertTrue(testCase, var > 0.9 * (((max - min + 1) * (max - min + 1) - 1) / 12.0));
free(array);
}
}
static Substring *substring_construct(Name name, int64_t start, int64_t length) {
Substring *substring = st_malloc(sizeof(Substring));
substring->name = name;
substring->start = start;
substring->length = length;
return substring;
}
char *eventTree_makeNewickString(EventTree *eventTree) {
Event *rootEvent = eventTree_getRootEvent(eventTree);
char *cA = eventTree_makeNewickStringP(rootEvent);
char *cA2 = st_malloc(sizeof(char)*(strlen(cA) + 2));
sprintf(cA2, "%s;", cA);
free(cA);
return cA2;
}
Sequence *sequence_construct(MetaSequence *metaSequence, Flower *flower) {
Sequence *sequence;
sequence = st_malloc(sizeof(Sequence));
sequence->metaSequence = metaSequence;
sequence->flower = flower;
flower_addSequence(flower, sequence);
return sequence;
}
struct List *parseTrioFile(char *trioFile) {
FILE *fileHandle = fopen(trioFile, "r");
int bytesRead;
int nBytes = 100;
char *cA;
int j;
char *species[3];
struct List *speciesList = NULL;
speciesList = constructEmptyList(0, freeTrioNames);
cA = st_malloc(nBytes + 1);
bytesRead = benLine(&cA, &nBytes, fileHandle);
while(bytesRead != -1) {
if (bytesRead > 0) {
species[0] = st_malloc(sizeof(char) * (1 + (bytesRead)));
species[1] = st_malloc(sizeof(char) * (1 + (bytesRead)));
species[2] = st_malloc(sizeof(char) * (1 + (bytesRead)));
j = sscanf(cA, "%s\t%s\t%s", species[0], species[1], species[2]);
if (j != 3) {
fprintf(stderr, "Invalid triple line '%s' in '%s'\n", cA, trioFile);
exit(1);
}
cStr_lowerCase(species[0]);
cStr_lowerCase(species[1]);
cStr_lowerCase(species[2]);
qsort(species, 3, sizeof(char *), cStr_compare);
TrioNames *trio = st_malloc(sizeof(TrioNames));
trio->speciesA = species[0];
trio->speciesB = species[1];
trio->speciesC = species[2];
listAppend(speciesList, trio);
}
bytesRead = benLine(&cA, &nBytes, fileHandle);
}
fclose(fileHandle);
free(cA);
return speciesList;
}
stSortedSetIterator *stSortedSet_copyIterator(stSortedSetIterator *iterator) {
stSortedSetIterator *copyIterator;
copyIterator = st_malloc(sizeof(stSortedSetIterator));
copyIterator->sortedSet = iterator->sortedSet;
copyIterator->sortedSet->numberOfLiveIterators++;
avl_t_copy(©Iterator->traverser, &iterator->traverser);
return copyIterator;
}
stSortedSetIterator *stSortedSet_getIterator(stSortedSet *items) {
stSortedSetIterator *iterator;
iterator = st_malloc(sizeof(stSortedSetIterator));
iterator->sortedSet = items;
avl_t_init(&iterator->traverser, items->sortedSet);
items->numberOfLiveIterators++;
return iterator;
}
CapCodeParameters *capCodeParameters_construct(int64_t minimumNCount,
int64_t maxInsertionLength, int64_t maxDeletionLength) {
CapCodeParameters *capCodeParameters = st_malloc(sizeof(CapCodeParameters));
capCodeParameters->minimumNCount = minimumNCount;
capCodeParameters->maxInsertionLength = maxInsertionLength;
capCodeParameters->maxDeletionLength = maxDeletionLength;
return capCodeParameters;
}
stTree *stTree_construct(void) {
stTree *tree = st_malloc(sizeof(stTree));
tree->branchLength = INFINITY;
tree->nodes = stList_construct3(0, (void (*)(void *))stTree_destruct);
tree->label = NULL;
tree->parent = NULL;
tree->clientData = NULL;
return tree;
}
EventTree *eventTree_construct(CactusDisk *cactusDisk, Name rootEventName) {
EventTree *eventTree;
eventTree = st_malloc(sizeof(EventTree));
eventTree->cactusDisk = cactusDisk;
cactusDisk_setEventTree(cactusDisk, eventTree);
eventTree->events = stSortedSet_construct3(eventTree_constructP, NULL);
eventTree->rootEvent = event_construct(rootEventName, "ROOT", INT64_MAX, NULL, eventTree); //do this last as reciprocal call made to add the event to the events.
return eventTree;
}
SegmentHolder *segmentHolder_construct(Segment *segment, int64_t offset, char base1, char base2, char base3) {
SegmentHolder *segmentHolder = st_malloc(sizeof(SegmentHolder));
segmentHolder->segment = segment;
segmentHolder->offset = offset;
segmentHolder->base1 = base1;
segmentHolder->base2 = base2;
segmentHolder->base3 = base3;
return segmentHolder;
}
static void testBinaryRepresentation_resizeObjectAsPowerOf2(CuTest* testCase) {
for(int64_t i=0; i<100000; i++) {
int64_t recordSize = i;
void *vA = st_malloc(recordSize);
vA = binaryRepresentation_resizeObjectAsPowerOf2(vA, &recordSize);
CuAssertTrue(testCase, i <= recordSize);
CuAssertTrue(testCase, i == 0 || i*2 >= recordSize);
free(vA);
}
}
stTreap *stTreap_construct(void *value) {
//strand(time(0));
stTreap *node = st_malloc(sizeof(stTreap));
node->key = 0;
node->priority = rand();
node->left = node->right = node->parent = NULL;
node->count = 1;
node->value = value;
return(node);
}
static char *formatSequenceHeader(Sequence *sequence) {
const char *sequenceHeader = sequence_getHeader(sequence);
if (strlen(sequenceHeader) > 0) {
char *cA = st_malloc(sizeof(char) * (1 + strlen(sequenceHeader)));
sscanf(sequenceHeader, "%s", cA);
return cA;
} else {
return cactusMisc_nameToString(sequence_getName(sequence));
}
}
AlignedPair *alignedPair_construct(int64_t subsequenceIdentifier1, int64_t position1, bool strand1,
int64_t subsequenceIdentifier2, int64_t position2, bool strand2, int64_t score, int64_t rScore) {
AlignedPair *alignedPair = st_malloc(sizeof(AlignedPair));
alignedPair->subsequenceIdentifier = subsequenceIdentifier1;
alignedPair->position = position1;
alignedPair->strand = strand1;
alignedPair->reverse = st_malloc(sizeof(AlignedPair));
alignedPair->reverse->reverse = alignedPair;
alignedPair->reverse->subsequenceIdentifier = subsequenceIdentifier2;
alignedPair->reverse->position = position2;
alignedPair->reverse->strand = strand2;
alignedPair->score = score;
alignedPair->reverse->score = rScore;
return alignedPair;
}
/*
* 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;
}
STNODE* st_createEmptyNode(NODETYPE type){
STNODE *temp = NULL;
temp = (STNODE*)st_malloc(sizeof(STNODE));
if(temp != NULL){
temp->type = type;
temp->value.semType = SEM_UNDEF;
temp->value.vint = 0;
temp->nops = 0;
temp->op = NULL;
} else fatal(STR_OUT_OF_MEMORY);
return temp;
}
