void parserPushTok (Parser *parser, int tok) {
int old_len, j, i, k;
Cell *j_cell, **new_cell;
int *new_tokseq;
Rule *rule, *rule_end;
old_len = parser->len;
j = old_len + 1;
if (j >= parser->alloc) {
parser->alloc *= 2;
new_cell = SafeCalloc (parser->alloc, sizeof(Cell) + 1);
new_tokseq = SafeCalloc (parser->alloc, sizeof(int));
for (i = 0; i <= old_len; ++i)
new_cell[i] = parser->cell[i];
for (i = 0; i < old_len; ++i)
new_tokseq[i] = parser->tokseq[i];
SafeFree (parser->cell);
SafeFree (parser->tokseq);
parser->cell = new_cell;
parser->tokseq = new_tokseq;
}
parser->tokseq[old_len] = tok;
j_cell = cellNewTok (parser, j, tok);
parser->cell[j] = j_cell;
parser->len = j;
rule_end = parser->rule + parser->rules;
for (i = old_len; i >= 0; --i)
for (rule = parser->rule; rule != rule_end; ++rule) {
for (k = i; k <= j; ++k) {
cell_inc_p
(j_cell, i, j, rule->lhs_sym,
parser_get_p(parser,i,k,rule->rhs1_sym) * parser_get_p(parser,k,j,rule->rhs2_sym) * rule->rule_prob);
if (parser->debug)
printf ("%g --> p(%d,%d,%d) += p(%d,%d,%d) * p(%d,%d,%d) * %g;\n",
parser_get_p(parser,i,j,rule->lhs_sym),
i,j,rule->lhs_sym, i,k,rule->rhs1_sym, k,j,rule->rhs2_sym, rule->rule_prob);
cell_inc_q
(j_cell, i, j, rule->lhs_sym,
parser_get_p(parser,i,k,rule->rhs1_sym) * parser_get_q(parser,k,rule->rhs2_sym) * rule->rule_prob);
if (parser->debug)
printf ("%g --> q(%d,%d) += p(%d,%d,%d) * q(%d,%d) * %g;\n",
parser_get_q(parser,i,rule->lhs_sym),
i,rule->lhs_sym, i,k,rule->rhs1_sym, k,rule->rhs2_sym, rule->rule_prob);
}
cell_inc_q
(j_cell, i, j, rule->lhs_sym,
parser_get_q(parser,i,rule->rhs1_sym) * rule->rule_prob);
if (parser->debug)
printf ("%g --> q(%d,%d) += q(%d,%d) * %g;\n",
parser_get_q(parser,i,rule->lhs_sym),
i,rule->lhs_sym, i,rule->rhs1_sym, rule->rule_prob);
}
}
Cell* cellNew (Parser *parser, int j) {
Cell *cell;
int sym;
cell = SafeMalloc (sizeof (Cell));
cell->p = SafeCalloc (parser->symbols * (j+1), sizeof (double));
cell->q = SafeCalloc (parser->symbols * (j+1), sizeof (double));
for (sym = 0; sym < parser->symbols; ++sym) {
cell_get_p(cell,j,j,sym) = parser->p_empty[sym];
cell_get_q(cell,j,j,sym) = 1. - parser->p_empty[sym];
}
return cell;
}
/* CopyResults: copy results from one file to another up to lastGen*/
int CopyResults (FILE *toFile, char *fromFileName, int lastGen)
{
int longestLine;
char *strBuf, *strCpy, *word;
FILE *fromFile;
if ((fromFile = OpenBinaryFileR(fromFileName)) == NULL)
return ERROR;
longestLine = LongestLine(fromFile)+10;
SafeFclose(&fromFile);
strBuf = (char *) SafeCalloc (2*(longestLine+2),sizeof(char));
strCpy = strBuf + longestLine + 2;
if ((fromFile = OpenTextFileR(fromFileName)) == NULL)
return ERROR;
while (fgets(strBuf,longestLine,fromFile)!=NULL)
{
strncpy(strCpy,strBuf,longestLine);
word = strtok(strCpy," ");
/* atoi returns 0 when word is not integer number */
if (atoi(word)>lastGen)
break;
fprintf (toFile,"%s",strBuf);
fflush (toFile);
}
SafeFclose(&fromFile);
free(strBuf);
return (NO_ERROR);
}
static int* GetIntListToArray(PyObject* pyList, int* size,
const int minVal, const int maxVal) {
int i;
int* result;
PyObject* item;
assert(PyList_Check(pyList));
*size = PyList_GET_SIZE(pyList);
result = SafeCalloc(*size,sizeof(int));
for (i=0; i<*size; i++) {
item = PyList_GET_ITEM(pyList,i);
if (! PyInt_Check(item)) {
PyErr_Format(PyExc_TypeError,"element %i not an integer",i);
free(result);
return NULL;
}
result[i]=PyInt_AsLong(item);
if (result[i] > maxVal || result[i] < minVal) {
PyErr_Format(PyExc_TypeError,"element %i = %i not in [%i,%i]",
i,result[i],minVal,maxVal);
free(result);
return NULL;
}
}
return result;
}
/* GetIntSummary: Get summary statistics for a number of runs (int version) */
void GetIntSummary (int **vals, int nRows, int *rowCount, Stat *theStats, int HPD)
{
int i, j, nVals;
MrBFlt *theValues, *p;
nVals = 0;
for (i=0; i<nRows; i++)
nVals += rowCount[i];
theValues = (MrBFlt *) SafeCalloc (nVals, sizeof(MrBFlt));
/* extract values */
p = theValues;
for (i=0; i<nRows; i++)
{
for (j=0; j<rowCount[i]; j++)
{
(*p++) = (MrBFlt) (vals[i][j]);
}
}
/* get statistics */
MeanVariance (theValues, nVals, &(theStats->mean), &(theStats->var));
if (HPD == YES)
LowerUpperMedian (theValues, nVals, &(theStats->lower), &(theStats->upper), &(theStats->median));
else
LowerUpperMedian (theValues, nVals, &(theStats->lower), &(theStats->upper), &(theStats->median));
free (theValues);
}
/*
============
=
= initFromFile:
=
============
*/
void initFromFile(void)
{
wadinfo_t wad;
lumpinfo_t *lumps;
int i;
/* read in the header */
fread(&wad, sizeof(wad), 1, wad_i.handle);
if (strncmp(wad.identification, "PWAD", 4))
{
Error("initFromFile: specified WAD is not a PWAD");
}
/* read in the lumpinfo */
fseek(wad_i.handle, wad.infotableofs, SEEK_SET);
wad_i.info = (STORAGE *) SafeMalloc(sizeof(STORAGE));
wad_i.info->data = (lumpinfo_t *) SafeCalloc(wad.numlumps,
sizeof(lumpinfo_t));
wad_i.info->count = wad.numlumps;
wad_i.info->size = sizeof(lumpinfo_t);
lumps = wad_i.info->data;
fread(lumps, sizeof(lumpinfo_t), wad.numlumps, wad_i.handle);
for (i = 0; i < wad.numlumps; i++, lumps++)
{
lumps->filepos = bswapl(lumps->filepos);
lumps->size = bswapl(lumps->size);
}
return;
}
/* SafeStrcat: Allocate or reallocate target to fit result; assumes ptr is NULL if not allocated */
char *SafeStrcat (char **target, const char *source)
{
if (*target == NULL)
*target = (char *) SafeCalloc (strlen(source)+1, sizeof(char));
else
*target = (char *) SafeRealloc ((void *)*target, (size_t)(strlen(source)+strlen(*target)+1)*sizeof(char));
if (*target)
strcat(*target,source);
return (*target);
}
Parser* parserNew (int symbols, int rules) {
Parser* parser;
parser = SafeMalloc (sizeof (Parser));
parser->symbols = symbols;
parser->rules = rules;
parser->len = 0;
parser->alloc = 1;
parser->debug = 0;
parser->rule = SafeMalloc (rules * sizeof (Rule));
parser->p_empty = SafeCalloc (symbols, sizeof (double));
parser->cell = SafeMalloc (sizeof (Cell*));
parser->tokseq = NULL;
parser->cell[0] = NULL;
return parser;
}
/* CopyTreeResults: copy tree results upto lastGen from one file to another. numTrees is return containing number of trees that were copied. */
int CopyTreeResults (FILE *toFile, char *fromFileName, int lastGen, int *numTrees)
{
int longestLine;
char *strBuf, *strCpy, *word;
FILE *fromFile;
(*numTrees) = 0;
if ((fromFile = OpenBinaryFileR(fromFileName)) == NULL)
return ERROR;
longestLine = LongestLine(fromFile)+10;
SafeFclose(&fromFile);
strBuf = (char *) SafeCalloc (2*(longestLine+2),sizeof(char));
strCpy = strBuf + longestLine + 2;
if ((fromFile = OpenTextFileR(fromFileName)) == NULL)
return ERROR;
while (fgets(strBuf,longestLine,fromFile)!=NULL)
{
strncpy(strCpy,strBuf,longestLine);
word = strtok(strCpy," ");
if (strcmp(word,"tree")==0)
{
word = strtok(NULL," ");
/* atoi returns 0 when word is not integer number,
4 is offset to get rid of "rep." in tree name */
if (atoi(word+4)>lastGen)
break;
(*numTrees)++;
fprintf (toFile,"%s",strBuf);
}
else if (*numTrees == 0) /* do not print the end statement */
fprintf (toFile,"%s",strBuf);
fflush (toFile);
}
SafeFclose(&fromFile);
free(strBuf);
return (NO_ERROR);
}
static double* GetPyFloatListToArrayOfDoubles(const char*const argName,
const int requiredSize,
const double minVal,
const double maxVal,
PyObject* pyList) {
int i, size;
double* result;
PyObject* item;
assert(PyList_Check(pyList));
size = PyList_GET_SIZE(pyList);
if (requiredSize != size) {
PyErr_Format(PyExc_TypeError,"%s:list size should be %i not %i",
argName,requiredSize,size);
return NULL;
}
result = SafeCalloc(requiredSize,sizeof(double));
for (i=0; i<requiredSize; i++) {
item = PyList_GET_ITEM(pyList,i);
if (PyInt_Check(item)) result[i] = PyInt_AsLong(item);
else if (PyFloat_Check(item)) result[i]=PyFloat_AsDouble(item);
else {
PyErr_Format(PyExc_TypeError,"%s:element %i not an int or float",
argName,i);
free(result);
return NULL;
}
if (result[i] > maxVal || result[i] < minVal) {
PyErr_Format(PyExc_TypeError,"%s:element %i not in required range",
argName,i);
free(result);
return NULL;
}
}
return result;
}
/* The numChecks field must already be set */
void InitVarNode(VariableNode*const vn) {
vn->edges = SafeCalloc(vn->numChecks,sizeof(GraphEdge*));
}
void InitCheckNode(CheckNode*const cn, const int numVars) {
cn->numVars = numVars;
cn->edges = SafeCalloc(numVars,sizeof(GraphEdge*));
}
/* CopyProcessSsFile: copy results from one file to another up to lastStep. Also marginalLnLSS is collected for processed steps*/
int CopyProcessSsFile (FILE *toFile, char *fromFileName, int lastStep, MrBFlt *marginalLnLSS, MrBFlt * splitfreqSS)
{
int longestLine, run, curStep, i;
double tmp;
char *strBuf, *strCpy, *word, *tmpcp;
FILE *fromFile;
if ((fromFile = OpenBinaryFileR(fromFileName)) == NULL)
return ERROR;
longestLine = LongestLine(fromFile)+10;
SafeFclose(&fromFile);
strBuf = (char *) SafeCalloc (2*(longestLine+2),sizeof(char));
strCpy = strBuf + longestLine + 2;
if ((fromFile = OpenTextFileR(fromFileName)) == NULL)
return ERROR;
while (fgets(strBuf,longestLine,fromFile)!=NULL)
{
strncpy(strCpy,strBuf,longestLine);
word = strtok(strCpy," \t\n");
/* atoi returns 0 when word is not integer number */
if (atoi(word)>lastStep)
break;
fprintf (toFile,"%s",strBuf);
fflush (toFile);
curStep = atoi(word);
if ( curStep > 0 )
{
strtok(NULL,"\t\n"); /*skip power*/
for (run=0; run<chainParams.numRuns; run++)
{
tmpcp = strtok(NULL,"\t\n");
if(tmpcp == NULL )
{
MrBayesPrint ("%s Error: In .ss file not enough ellements on the string :%s \n", spacer, strBuf);
return ERROR;
}
tmp = atof(tmpcp);
if(tmp == 0.0 )
{
MrBayesPrint ("%s Error: Value of some step contribution is 0.0 or not a number in .ss file. Sting:%s \n", spacer, strBuf);
return ERROR;
}
marginalLnLSS[run]+=tmp;
}
for (i=0; i<numTopologies; i++)
{
tmpcp = strtok(NULL,"\t\n");
if(tmpcp == NULL )
{
MrBayesPrint ("%s Error: In .ss file not enough ellements on the string :%s \n", spacer, strBuf);
return ERROR;
}
tmp = atof(tmpcp);
splitfreqSS[i*chainParams.numStepsSS + curStep-1] = tmp;
}
}
}
SafeFclose(&fromFile);
free(strBuf);
return (NO_ERROR);
}
/*------------------------------------------------------------------------
|
| InitBeagleInstance: create and initialize a beagle instance
|
-------------------------------------------------------------------------*/
int InitBeagleInstance (ModelInfo *m, int division)
{
int i, j, k, c, s, *inStates, numPartAmbigTips;
double *inPartials;
SafeLong *charBits;
BeagleInstanceDetails details;
long preferedFlags, requiredFlags;
int resource;
if (m->useBeagle == NO)
return ERROR;
/* at least one eigen buffer needed */
if (m->nCijkParts == 0)
m->nCijkParts = 1;
/* allocate memory used by beagle */
m->logLikelihoods = (MrBFlt *) SafeCalloc ((numLocalChains)*m->numChars, sizeof(MrBFlt));
m->inRates = (MrBFlt *) SafeCalloc (m->numGammaCats, sizeof(MrBFlt));
m->branchLengths = (MrBFlt *) SafeCalloc (2*numLocalTaxa, sizeof(MrBFlt));
m->tiProbIndices = (int *) SafeCalloc (2*numLocalTaxa, sizeof(int));
m->inWeights = (MrBFlt *) SafeCalloc (m->numGammaCats*m->nCijkParts, sizeof(MrBFlt));
m->bufferIndices = (int *) SafeCalloc (m->nCijkParts, sizeof(int));
m->eigenIndices = (int *) SafeCalloc (m->nCijkParts, sizeof(int));
m->childBufferIndices = (int *) SafeCalloc (m->nCijkParts, sizeof(int));
m->childTiProbIndices = (int *) SafeCalloc (m->nCijkParts, sizeof(int));
m->cumulativeScaleIndices = (int *) SafeCalloc (m->nCijkParts, sizeof(int));
numPartAmbigTips = 0;
if (m->numStates != m->numModelStates)
numPartAmbigTips = numLocalTaxa;
else
{
for (i=0; i<numLocalTaxa; i++)
{
if (m->isPartAmbig[i] == YES)
numPartAmbigTips++;
}
}
if (beagleResourceCount == 0)
{
preferedFlags = beagleFlags;
}
else
{
resource = beagleResource[beagleInstanceCount % beagleResourceCount];
preferedFlags = beagleFlags;
}
requiredFlags = 0L;
if (beagleScalingScheme == MB_BEAGLE_SCALE_ALWAYS)
requiredFlags |= BEAGLE_FLAG_SCALERS_LOG; //BEAGLE_FLAG_SCALERS_RAW;
/* TODO: allocate fewer buffers when nCijkParts > 1 */
/* create beagle instance */
m->beagleInstance = beagleCreateInstance(numLocalTaxa,
m->numCondLikes * m->nCijkParts,
numLocalTaxa - numPartAmbigTips,
m->numModelStates,
m->numChars,
(numLocalChains + 1) * m->nCijkParts,
m->numTiProbs*m->nCijkParts,
m->numGammaCats,
m->numScalers * m->nCijkParts,
(beagleResourceCount == 0 ? NULL : &resource),
(beagleResourceCount == 0 ? 0 : 1),
preferedFlags,
requiredFlags,
&details);
if (m->beagleInstance < 0)
{
MrBayesPrint ("%s Failed to start BEAGLE instance\n", spacer);
return (ERROR);
}
else
{
MrBayesPrint( "\n%s Using BEAGLE resource %i for division %d:", spacer, details.resourceNumber, division+1);
#if defined (THREADS_ENABLED)
MrBayesPrint( " (%s)\n", (tryToUseThreads ? "threaded" : "non-threaded"));
#else
MrBayesPrint( " (non-threaded)\n");
#endif
MrBayesPrint( "%s Rsrc Name : %s\n", spacer, details.resourceName);
MrBayesPrint( "%s Impl Name : %s\n", spacer, details.implName);
MrBayesPrint( "%s Flags:", spacer);
BeaglePrintFlags(details.flags);
MrBayesPrint( "\n");
beagleInstanceCount++;
}
/* initialize tip data */
inStates = (int *) SafeMalloc (m->numChars * sizeof(int));
if (!inStates)
return ERROR;
inPartials = (double *) SafeMalloc (m->numChars * m->numModelStates * sizeof(double));
if (!inPartials)
return ERROR;
for (i=0; i<numLocalTaxa; i++)
{
if (m->isPartAmbig[i] == NO)
{
charBits = m->parsSets[i];
for (c=0; c<m->numChars; c++)
{
for (s=j=0; s<m->numModelStates; s++)
{
if (IsBitSet(s, charBits))
{
inStates[c] = s;
j++;
}
}
if (j == m->numModelStates)
inStates[c] = j;
else
assert(j==1);
charBits += m->nParsIntsPerSite;
}
beagleSetTipStates(m->beagleInstance, i, inStates);
}
else /* if (m->isPartAmbig == YES) */
{
k = 0;
charBits = m->parsSets[i];
for (c=0; c<m->numChars; c++)
{
for (s=0; s<m->numModelStates; s++)
{
if (IsBitSet(s%m->numStates, charBits))
inPartials[k++] = 1.0;
else
inPartials[k++] = 0.0;
}
charBits += m->nParsIntsPerSite;
}
beagleSetTipPartials(m->beagleInstance, i, inPartials);
}
}
free (inStates);
free (inPartials);
return NO_ERROR;
}
