float Marker::getRatio(float o) {
// deprivated
// derivate of old2new
// hardcode the derivate to improve performance
switch (getInterpolationMode()) {
// linear
case 0: {
int i=getAreaOld(o);
if (i<0 || i+1>getLength()-1) return 0;
float dold=(getOld(i+1)-getOld(i));
if (dold<=0) return 0;
return (getNew(i+1)-getNew(i))/dold;
} break;
default: {
// approxmiate ratio
float n=100; // TODO automate this
float o1=o-1/n;
if (o1<0) o1=0;
if (o1>1) return 0;
float o2=o+1/n;
if (o2<0) return 0;
if (o2>1) o2=1;
if (o2-o1<=0) return 0;
return ((old2new(o2)-old2new(o1))/(o2-o1));
}
}
}
struct utmpx *
getutxent(void)
{
if (fp == NULL) {
struct stat st;
if ((fp = fopen(utfile, "re+")) == NULL)
if ((fp = fopen(utfile, "we+")) == NULL) {
if ((fp = fopen(utfile, "re")) == NULL)
goto fail;
else
readonly = 1;
}
/* get file size in order to check if new file */
if (fstat(fileno(fp), &st) == -1)
goto failclose;
if (st.st_size == 0) {
/* new file, add signature record */
(void)memset(&ut, 0, sizeof(ut));
ut.ut_type = SIGNATURE;
(void)memcpy(ut.ut_user, vers, sizeof(vers));
if (fwrite(&ut, sizeof(ut), 1, fp) != 1)
goto failclose;
} else {
/* old file, read signature record */
if (fread(&ut, sizeof(ut), 1, fp) != 1)
goto failclose;
if (memcmp(ut.ut_user, vers, 5) != 0 ||
ut.ut_type != SIGNATURE)
goto failclose;
}
version = ut.ut_user[6] - '0';
}
if (fread(&ut, sizeof(ut), 1, fp) != 1)
goto fail;
if (version == 1)
old2new(&ut);
return &ut;
failclose:
(void)fclose(fp);
fail:
(void)memset(&ut, 0, sizeof(ut));
return NULL;
}
void CNPLCM_CR_Basic_Freq::permute_latent_classes_by_nu(){
//reorder latent classes increasingly according to nuK.
std::vector<int> new2old(par->K), old2new(par->K);
std::vector<_CNPLCM_CR_Basic_Freq_mypair> s_index(par->K);
for (int k = 0; k < par->K; k++){
s_index[k].first = 1.0 - par->nuK[k];
s_index[k].second = k;
}
std::sort(s_index.begin(), s_index.end(), _CNPLCM_CR_Basic_Freq_comparator);
std::vector<int> perm(K);
for (int k = 0; k < par->K; k++){
new2old[k] = s_index[k].second;
} // new2old[a] == b <=> former b-th element is now a-th element.
for (int k = 0; k < par->K; k++){
old2new[ new2old[k] ] = k;
}
CParams_NPLCM_CR_Basic_Freq *tmp = new CParams_NPLCM_CR_Basic_Freq(*par);
//for (int i = 0; i < par->n; i++){
// tmp->zI[i] = old2new[ par->zI[i] ];
//}
for (int m = 0; m < par->M; m++){
for (int k = 0; k < par->K; k++){
tmp->count_zIK[m][k] = par->count_zIK[m][ new2old[k] ];
}
}
for (int j = 0; j < par->J; j++){
for (int k = 0; k < par->K; k++){
tmp->lambdaJK[j][k] = par->lambdaJK[j][ new2old[k] ];
tmp->aux_JK2[j][k][0] = par->aux_JK2[j][ new2old[k] ][0];
tmp->aux_JK2[j][k][1] = par->aux_JK2[j][ new2old[k] ][1];
}
}
for (int k = 0; k < par->K; k++){
tmp->nuK[k] = par->nuK[new2old[k]];
tmp->log_nuK[k] = par->log_nuK[new2old[k]];
tmp->countK[k] = par->countK[new2old[k]];
tmp->count0K[k] = par->count0K[new2old[k]];
}
//std::copy(tmp->zI, tmp->zI + par->n, par->zI);
std::copy(tmp->count_zIK[0], tmp->count_zIK[0] + par->M * par->J, par->count_zIK[0]);
std::copy(tmp->lambdaJK[0], tmp->lambdaJK[0] + par->J * par->K, par->lambdaJK[0]);
std::copy(tmp->aux_JK2[0][0], tmp->aux_JK2[0][0] + par->J * par->K * 2, par->aux_JK2[0][0]);
std::copy(tmp->nuK, tmp->nuK + par->K, par->nuK);
std::copy(tmp->log_nuK, tmp->log_nuK + par->K, par->log_nuK);
std::copy(tmp->countK, tmp->countK + par->K, par->countK);
std::copy(tmp->count0K, tmp->count0K + par->K, par->count0K);
delete tmp;
}
Tree Tree::reorderNodes (const vguard<TreeNodeIndex>& newOrder) const {
Tree newTree;
newTree.node.reserve (nodes());
vguard<TreeNodeIndex> old2new (nodes(), -1);
for (auto oldIdx : newOrder) {
old2new[oldIdx] = newTree.node.size();
newTree.node.push_back (node[oldIdx]);
}
for (auto& n : newTree.node) {
if (n.parent >= 0)
n.parent = old2new[n.parent];
for (auto& c : n.child)
c = old2new[c];
}
return newTree;
}
float Marker::new2old(float n) {
// inverse of old2new
// hardcode the derivate to improve performance
switch (getInterpolationMode()) {
// linear
case 0: {
int i=getAreaNew(n);
if (i<0 || i+1>getLength()-1) return 0;
return (n-getNew(i))/(getNew(i+1)-getNew(i))*(getOld(i+1)-getOld(i))+getOld(i);
} break;
default: {
// TODO
// approximate o;
float o=n;
for (int i=1; i<10; ++i) {
o+=(n-old2new(o))/i;
}
return o;
}
}
}
void Tree::reorderSeqs (vguard<FastSeq>& seq) const {
Assert (seq.size() == nodes(), "Number of sequences doesn't match number of nodes in tree");
map<string,size_t> name2seq;
for (size_t n = 0; n < seq.size(); ++n) {
Assert (name2seq.find (seq[n].name) == name2seq.end(), "Duplicate sequence name: %s", seq[n].name.c_str());
name2seq[seq[n].name] = n;
}
vguard<size_t> new2old (seq.size()), old2new (seq.size());
for (TreeNodeIndex n = 0; n < nodes(); ++n) {
Assert (name2seq.find (seqName(n)) != name2seq.end(), "Tree node %s is absent from sequence dataset", seqName(n).c_str());
const size_t old_n = name2seq[seqName(n)];
new2old[n] = old_n;
old2new[old_n] = n;
}
for (size_t n = 0; n < new2old.size(); ++n) {
const size_t o = new2old[n], m = old2new[n];
swap (seq[n], seq[o]);
swap (old2new[n], old2new[o]);
swap (new2old[n], new2old[m]);
}
}
