static int enqueue_sibling(diagnostic_problem problem,
priority_queue opened,
gotcha_node current,
const_tv_term_list_list systems)
{
register unsigned int ix;
gotcha_node sibling;
if (current->depth == 0) {
return 1;
}
ix = current->depth - 1;
if (NULL == (sibling = gotcha_node_copy(current, systems->sz))) {
return 0;
}
while (sibling->offsets[ix] < systems->arr[ix]->sz - 1) {
sibling->offsets[ix] += 1;
if (is_consistent(problem, sibling, systems)) {
update_cardinality(problem, sibling);
if (!priority_queue_push(opened, sibling)) {
gotcha_node_free(sibling);
return 0;
}
increase_int_counter("pushed");
maximize_int_counter("max", priority_queue_size(opened));
return 1;
}
increase_int_counter("inconsistent");
}
gotcha_node_free(sibling);
return 1;
}
static int enqueue_next_best_state(diagnostic_problem problem,
priority_queue opened,
gotcha_node current,
const_tv_term_list_list systems)
{
register unsigned int ix;
current->depth += 1;
ix = current->depth - 1;
while (current->offsets[ix] < systems->arr[ix]->sz) {
if (is_consistent(problem, current, systems)) {
update_cardinality(problem, current);
if (!priority_queue_push(opened, current)) {
return 0;
}
increase_int_counter("pushed");
maximize_int_counter("max", priority_queue_size(opened));
return 1;
}
current->offsets[ix] += 1;
increase_int_counter("inconsistent");
}
gotcha_node_free(current);
return 1;
}
/*=export_func optionProcess
*
* what: this is the main option processing routine
*
* arg: + tOptions* + opts + program options descriptor +
* arg: + int + a_ct + program arg count +
* arg: + char** + a_v + program arg vector +
*
* ret_type: int
* ret_desc: the count of the arguments processed
*
* doc:
*
* This is the main entry point for processing options. It is intended
* that this procedure be called once at the beginning of the execution of
* a program. Depending on options selected earlier, it is sometimes
* necessary to stop and restart option processing, or to select completely
* different sets of options. This can be done easily, but you generally
* do not want to do this.
*
* The number of arguments processed always includes the program name.
* If one of the arguments is "--", then it is counted and the processing
* stops. If an error was encountered and errors are to be tolerated, then
* the returned value is the index of the argument causing the error.
* A hyphen by itself ("-") will also cause processing to stop and will
* @emph{not} be counted among the processed arguments. A hyphen by itself
* is treated as an operand. Encountering an operand stops option
* processing.
*
* err: Errors will cause diagnostics to be printed. @code{exit(3)} may
* or may not be called. It depends upon whether or not the options
* were generated with the "allow-errors" attribute, or if the
* ERRSKIP_OPTERR or ERRSTOP_OPTERR macros were invoked.
=*/
int
optionProcess(tOptions * opts, int a_ct, char ** a_v)
{
if (! SUCCESSFUL(validate_struct(opts, a_v[0])))
ao_bug(zbad_data_msg);
/*
* Establish the real program name, the program full path,
* and do all the presetting the first time thru only.
*/
if (! ao_initialize(opts, a_ct, a_v))
return 0;
/*
* IF we are (re)starting,
* THEN reset option location
*/
if (opts->curOptIdx <= 0) {
opts->curOptIdx = 1;
opts->pzCurOpt = NULL;
}
if (! SUCCESSFUL(regular_opts(opts)))
return (int)opts->origArgCt;
/*
* IF there were no errors
* AND we have RC/INI files
* AND there is a request to save the files
* THEN do that now before testing for conflicts.
* (conflicts are ignored in preset options)
*/
switch (opts->specOptIdx.save_opts) {
case 0:
case NO_EQUIVALENT:
break;
default:
{
tOptDesc * od = opts->pOptDesc + opts->specOptIdx.save_opts;
if (SELECTED_OPT(od)) {
optionSaveFile(opts);
option_exits(EXIT_SUCCESS);
}
}
}
/*
* IF we are checking for errors,
* THEN look for too few occurrences of required options
*/
if (((opts->fOptSet & OPTPROC_ERRSTOP) != 0)
&& (! is_consistent(opts)))
(*opts->pUsageProc)(opts, EXIT_FAILURE);
return (int)opts->curOptIdx;
}
int is_consistent (node* n, int parentKey) {
int key = n->key;
int item_key = n->item->key;
if (key != item_key) {
printf("ERROR: item key not set!!!");
return 0;
}
if (key < parentKey) {
printf("ERROR: child key smaller than parent key!!!");
return 0;
}
node* parent_pointer = n->parent;
node* sibling = n;
node* prev_sibling = n->left_sibling;
do{
if (sibling->parent != parent_pointer) {
printf("ERROR: parent pointer not set!!!");
return 0;
}
is_consistent(sibling, sibling->key);
if (sibling->left_sibling != prev_sibling) {
printf("ERROR: left sibling not set for right sibling!!!");
return 0;
}
prev_sibling = sibling;
sibling = sibling->right_sibling;
} while (sibling != n);
return 1;
}
void MSConnectivityRestraint::ExperimentalTree::finalize() {
if (finalized_) return;
for (unsigned int i = 0; i < nodes_.size(); ++i) {
if (nodes_[i].is_root()) {
if (root_ == static_cast<unsigned int>(-1))
root_ = i;
else
IMP_THROW("Experimental tree has multiple roots",
IMP::ValueException);
}
}
if (find_cycle(root_))
IMP_THROW("Experimental tree has a cycle", IMP::ValueException);
for (unsigned int i = 0; i < nodes_.size(); ++i)
if (!is_consistent(i)) {
IMP_THROW(
"Experimental tree is inconsistent: a child has to "
"have fewer proteins than its parent",
IMP::ValueException);
}
finalized_ = true;
}
/**
* For one network phi and one experiment extracted from the total data matrix X,
* for one experiments states Gx use the viterbi algorithm
* N: number of nodes
* T: number of time points
* R: number of replicates
* X: data matrix (N x TxR)
* GS: optim state matrix (N x TxR), initialised in R and given as argument
* G: state matrix (N x sum_s(M_s)); for each stimulus s, there are M_s states
* Glen:
* TH: theta parameter matrix (N x 4)
* tps: timepoint vector (T)
* stimgrps: vector containing the stimulus indices
* numexperimentsx: number of experiments (equals length of R and Ms)
* hmmit: number of hmmiterations
* Ms: number of system states for each experiment
*/
double hmmsearch(int *phi, const int N, const int *Tx, const int *Rx,
const double *X, int *GS,
int *G, int Glen, double *TH,
const int *tps,
const int *stimids, const int *stimgrps,
const int numexperiments, const int hmmit, int *Ms)
{
// fixed for the moment, number of iterations in the em-algorithm
int ncol_GS=0;
int numstims, idstart=0, Gstart=0;
for(int i=0; i!=numexperiments; ++i) {
ncol_GS += Tx[i]*Rx[i];
}
// printf("~~~~~ \n ncol_GS: %d\n",ncol_GS);
// init A, TH and L
// sort of a hack for getting the - infinity value
double temp = 1.0;
double infinity = -1 * (temp / (temp - 1.0));
int M = Glen/N; // total number of system states
// allocate the transition probability matrix, for all experiments
int A_sz = 0;
for(int i=0; i!=numexperiments; ++i) {
A_sz += pow(Ms[i],2);
}
// make a vector of doubles, holding the transition probabilities
double *A = malloc(A_sz * sizeof(double));
init_A(A, Ms, numexperiments); // init transition probabilities (sparse MxM matrix)
/* main loop: for each iteration in hmmiterations:
* perform viterbi for each experiment separately
* get the parameters TH and updates for A and GS for all experiments combined
*/
int Mexp, T, R;
int startA=0, startX=0, startG=0;
double *Aexp = NULL;
double *Xexp = NULL;
int *Gexp = NULL;
int *GSexp = NULL;
int allR, allT;
double Lik = -1*infinity;
double Likold = -1*infinity;
int nLikEqual = 0;
// keep track of the last 5 likelihood differences
// if switching behaviour occurs, it can be seen here
// take differences
int K = 6;
double diff, difftmp;
//double *diffvec = calloc(K-1, sizeof(double));
double *diffvec = malloc(K * sizeof(double));
int *toswitch = calloc(N, sizeof(int));
int nsw=0, maxsw=10;
// new state matrix object
for(int it=0; it!=hmmit; ++it) {
allR=0;
allT=0;
startA=0;
startX=0;
startG=0;
// find switchable rows in TH
nsw = find_switchable(TH, N, toswitch);
if(nsw>0) {
maxsw = min(nsw, maxsw);
}
/* here the experiment loop
* extract each experiment from X according to R and stimgrps and run the hmm
* indices of columns of X to be selected:
* expind is equivalent to the experiment index
* this defines the stimuli to take from stimgrps
*/
for(int expind=0; expind!=numexperiments; expind++) {
//print_intmatrix(toswitch, 1, N);
// if inconsistencies occur in the gamma matrix,
// try switching the theta parameters upto
// maxsw times to reduce the number of inconsitencies
//maxsw = min(nsw, N);
T = Tx[expind];
R = Rx[expind];
allR += R;
allT += T;
Mexp = Ms[expind];
for(int swind=0; swind!=maxsw; ++swind) {
// extract the sub-transition matrix:
Aexp = realloc(Aexp, Mexp*Mexp * sizeof(double));
extract_transitionmatrix(A, Aexp, Mexp, startA);
// extract the sub-data matrix
Xexp = realloc(Xexp, N*T*R*sizeof(double));
extract_datamatrix(X, Xexp, N, T, R, startX);
// extract the sub-state matrix
Gexp = realloc(Gexp, N*Mexp*sizeof(int));
extract_statematrix(G, Gexp, N, Mexp, startG);
// extract the sub-optimstate matrix
GSexp = realloc(GSexp, N*T*R*sizeof(int));
extract_statematrix(GS, GSexp, N, T*R, startX);
// run the viterbi
viterbi(T, Mexp, Xexp, Gexp, TH, N, R, Aexp, GSexp);
// consitency check
int inc = is_consistent(phi, GSexp, Gexp, N, T, R);
if(inc>0 && nsw>0) {
//printf("Inconsitensies in state series. Repeat HMM with modified thetaprime.\n");
// select a row to switch randomly
int rnum = rand() % nsw; // a random number between 1 and nsw
int hit = 0, ii=0;
for(ii=0; ii!=N; ++ii) {
if(toswitch[ii]!=0) {
if(hit==rnum) {
break;
}
hit++;
}
}
switch_theta_row(TH, ii, N);
// remove node as possible switch node
toswitch[ii] = 0;
nsw--;
} else {
// update the GSnew matrix
update_statematrix(GS, GSexp, startX, N, T, R);
// update the new transition prob matrix
update_transitionmatrix(A, Aexp, Mexp, startA);
break;
}
} // switch loop end
// increment the experiment start indices
startA += pow(Mexp, 2);
startX += N*T*R;
startG += N*Mexp;
} // experiment loop end
// number of replicates are the same in each experiment, since
// pad-columns containing NAs were added
allR = allR/numexperiments;
// M-step
// update the theta matrix
estimate_theta(X, GS, TH, N, allT, allR);
// calculate the new likelihood
Lik = calculate_likelihood(X, GS, TH, N, allT, allR); //Liktmp$L
diff = fabs((fabs(Lik) - fabs(Likold)));
// count number of equal differences in the last 10 likelihoods
// if all 5 differences are equal, then stop
int stopit=0, count = 0; // if all diffs are equal, stopit remains 1 and the loop is aborted
// check if diffvec is filled
if(it>=K) {
// check elements in diffvec
for(int k=0; k!=(K-1); ++k) {
if(k>0) {
if(fabs(diffvec[k]-difftmp)<=0.001) {
count++;
//stopit = 0;
}
}
// remember the original value at current position
difftmp = diffvec[k];
// shift next value left one position
if(k<K) {
diffvec[k] = diffvec[k+1];
} else {
// update the new difference at last position
diffvec[k] = diff;
}
}
if(count==(K-1)) {
stopit = 1;
// make sure that the higher likelihood is taken
// if switching occurs
if(Likold>Lik) {
stopit = 0;
}
}
} else {
// if not filled then add elements
diffvec[it] = diff;
}
// another termination criterion: count if liklihood terms do not change
if(Lik==Likold) {
nLikEqual++;
} else {
nLikEqual = 0;
Likold = Lik;
}
// abort baum-welch, if Lik does not change anymore
if(nLikEqual>=10 || stopit==1) {
break;
}
}
free(toswitch);
free(diffvec);
free(GSexp);
free(Gexp);
free(Xexp);
free(Aexp);
free(A);
return Lik;
}
/*=export_func optionProcess
*
* what: this is the main option processing routine
*
* arg: + tOptions* + pOpts + program options descriptor +
* arg: + int + argc + program arg count +
* arg: + char** + argv + program arg vector +
*
* ret_type: int
* ret_desc: the count of the arguments processed
*
* doc:
*
* This is the main entry point for processing options. It is intended
* that this procedure be called once at the beginning of the execution of
* a program. Depending on options selected earlier, it is sometimes
* necessary to stop and restart option processing, or to select completely
* different sets of options. This can be done easily, but you generally
* do not want to do this.
*
* The number of arguments processed always includes the program name.
* If one of the arguments is "--", then it is counted and the processing
* stops. If an error was encountered and errors are to be tolerated, then
* the returned value is the index of the argument causing the error.
* A hyphen by itself ("-") will also cause processing to stop and will
* @emph{not} be counted among the processed arguments. A hyphen by itself
* is treated as an operand. Encountering an operand stops option
* processing.
*
* err: Errors will cause diagnostics to be printed. @code{exit(3)} may
* or may not be called. It depends upon whether or not the options
* were generated with the "allow-errors" attribute, or if the
* ERRSKIP_OPTERR or ERRSTOP_OPTERR macros were invoked.
=*/
int
optionProcess(tOptions * pOpts, int argCt, char ** argVect)
{
if (! SUCCESSFUL(validate_struct(pOpts, argVect[0])))
exit(EX_SOFTWARE);
/*
* Establish the real program name, the program full path,
* and do all the presetting the first time thru only.
*/
if ((pOpts->fOptSet & OPTPROC_INITDONE) == 0) {
pOpts->origArgCt = (unsigned int)argCt;
pOpts->origArgVect = argVect;
pOpts->fOptSet |= OPTPROC_INITDONE;
if (HAS_pzPkgDataDir(pOpts))
program_pkgdatadir = pOpts->pzPkgDataDir;
if (! SUCCESSFUL(doPresets(pOpts)))
return 0;
/*
* IF option name conversion was suppressed but it is not suppressed
* for the command line, then it's time to translate option names.
* Usage text will not get retranslated.
*/
if ( ((pOpts->fOptSet & OPTPROC_TRANSLATE) != 0)
&& (pOpts->pTransProc != NULL)
&& ((pOpts->fOptSet & OPTPROC_NO_XLAT_MASK)
== OPTPROC_NXLAT_OPT_CFG) ) {
pOpts->fOptSet &= ~OPTPROC_NXLAT_OPT_CFG;
(*pOpts->pTransProc)();
}
if ((pOpts->fOptSet & OPTPROC_REORDER) != 0)
optionSort(pOpts);
pOpts->curOptIdx = 1;
pOpts->pzCurOpt = NULL;
}
/*
* IF we are (re)starting,
* THEN reset option location
*/
else if (pOpts->curOptIdx <= 0) {
pOpts->curOptIdx = 1;
pOpts->pzCurOpt = NULL;
}
if (! SUCCESSFUL(regular_opts(pOpts)))
return pOpts->origArgCt;
/*
* IF there were no errors
* AND we have RC/INI files
* AND there is a request to save the files
* THEN do that now before testing for conflicts.
* (conflicts are ignored in preset options)
*/
if ( (pOpts->specOptIdx.save_opts != NO_EQUIVALENT)
&& (pOpts->specOptIdx.save_opts != 0)) {
tOptDesc* pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts;
if (SELECTED_OPT(pOD)) {
optionSaveFile(pOpts);
exit(EXIT_SUCCESS);
}
}
/*
* IF we are checking for errors,
* THEN look for too few occurrences of required options
*/
if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
if (! is_consistent(pOpts))
(*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
}
return pOpts->curOptIdx;
}
int is_consistent(heap* h) {
if (h->min_node != NULL) {
return is_consistent(h->min_node, 0);
}
return 1;
}
