DiffSeq
mutationDiff()
{
return snapshot({after(Ref::ATTRIBS) // fast forward to the first child
, find(CHILD_T)
, pick(CHILD_A)
, skip(CHILD_T)
, del(CHILD_T)
, pick(Ref::CHILD) // pick a child anonymously
, mut(Ref::THIS) // mutate the current element (the one just picked)
, ins(ATTRIB3)
, ins(ATTRIB_NODE) // attributes can also be nested objects
, find(CHILD_A)
, del(CHILD_B)
, ins(CHILD_NODE)
, ins(CHILD_T)
, skip(CHILD_A)
, mut(CHILD_NODE)
, ins(TYPE_Y)
, ins(ATTRIB2)
, emu(CHILD_NODE)
, mut(ATTRIB_NODE) // mutation can be out-of order, target found by ID
, ins(CHILD_A)
, ins(CHILD_A)
, ins(CHILD_A)
, emu(ATTRIB_NODE)
, emu(Ref::THIS)
});
}
__c_node*
__libcpp_db::__find_c_and_lock(void* __c) const
{
mut().lock();
if (__cend_ == __cbeg_)
{
mut().unlock();
return nullptr;
}
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
if (p == nullptr)
{
mut().unlock();
return nullptr;
}
while (p->__c_ != __c)
{
p = p->__next_;
if (p == nullptr)
{
mut().unlock();
return nullptr;
}
}
return p;
}
__c_node*
__libcpp_db::__find_c_and_lock(void* __c) const
{
#ifndef _LIBCPP_HAS_NO_THREADS
mut().lock();
#endif
if (__cend_ == __cbeg_)
{
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock();
#endif
return nullptr;
}
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
if (p == nullptr)
{
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock();
#endif
return nullptr;
}
while (p->__c_ != __c)
{
p = p->__next_;
if (p == nullptr)
{
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock();
#endif
return nullptr;
}
}
return p;
}
int mut(int codon_1[], int codon_2[], int *s_all, int s_path, int *n_all, int n_path, int *p)
{
int temp[3], codon;
int i, j;
if(calc_codon(codon_1) == calc_codon(codon_2)) {
*s_all += s_path;
*n_all += n_path;
(*p)++;
return 0;
}
for(i = 0; i < 3; i++) {
if(codon_1[i] != codon_2[i]) {
for(j = 0; j < 3; j++) {
temp[j] = codon_1[j];
}
temp[i] = codon_2[i];
codon = calc_codon(temp);
if(aa[codon] != stopcodon) {
if(aa[calc_codon(codon_1)] == aa[codon]) {
mut(temp, codon_2, s_all, s_path + 1, n_all, n_path, p);
} else {
mut(temp, codon_2, s_all, s_path, n_all, n_path + 1, p);
}
}
}
}
return 0;
}
void getup()
{
for(int i = 0;i<=len+1;++i)
{
a2 = add(a2,mut(a[i],a[i]));
ab = add(ab,mut(a[i],b[i]));
b2 = add(b2,mut(b[i],b[i]));
}
}
void pd()
{
for(int i = 0;i<=len+1;++i)
{
a2 = sub(a2,mut(a[i],a[i]));
ab = sub(ab,mut(a[i],b[i]));
b2 = sub(b2,mut(b[i],b[i]));
int tmpa = add(mut(a[i],c[0]),mut(b[i],c[1]));
int tmpb = add(mut(a[i],c[2]),mut(c[3],b[i]));
a[i] = tmpa;b[i] = tmpb;
a2 = add(a2,mut(a[i],a[i]));
ab = add(ab,mut(a[i],b[i]));
b2 = add(b2,mut(b[i],b[i]));
} c[0] = 1,c[1] = 0 ,c[2] = 0,c[3] = 1;
}
void
__libcpp_db::__iterator_copy(void* __i, const void* __i0)
{
WLock _(mut());
__i_node* i = __find_iterator(__i);
__i_node* i0 = __find_iterator(__i0);
__c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr;
if (i == nullptr && c0 != nullptr)
i = __insert_iterator(__i);
__c_node* c = i != nullptr ? i->__c_ : nullptr;
if (c != c0)
{
if (c != nullptr)
c->__remove(i);
if (i != nullptr)
{
i->__c_ = nullptr;
if (c0 != nullptr)
{
i->__c_ = c0;
i->__c_->__add(i);
}
}
}
}
struct dsresult calc_ds(int length, int seq_index_0, int seq_index_1)
{
int s, n, p, i;
int codon[2][3];
double s_total_0 = 0, s_total_1 = 0;
double sd_total, nd_total;
struct dsresult result;
sd_total = 0.0;
nd_total = 0.0;
i = 0;
readcodon(codon[0], seq_index_0, i);
readcodon(codon[1], seq_index_1, i);
potential_mut(codon[0], &s_total_0);
potential_mut(codon[1], &s_total_1);
s = 0;
n = 0;
p = 0;
mut(codon[0], codon[1], &s, 0, &n, 0, &p);
result.nn = n;
result.np = p;
result.ns = s;
result.s1 = s_total_0;
result.s2 = s_total_1;
return result;
}
bool
__libcpp_db::__decrementable(const void* __i) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
}
void
__libcpp_db::__invalidate_all(void* __c)
{
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut());
#endif
if (__cend_ != __cbeg_)
{
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
if (p == nullptr)
return;
while (p->__c_ != __c)
{
p = p->__next_;
if (p == nullptr)
return;
}
while (p->end_ != p->beg_)
{
--p->end_;
(*p->end_)->__c_ = nullptr;
}
}
}
bool
__libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
}
void
__libcpp_db::__erase_i(void* __i)
{
WLock _(mut());
if (__ibeg_ != __iend_)
{
size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
__i_node* p = __ibeg_[hi];
if (p != nullptr)
{
__i_node* q = nullptr;
while (p->__i_ != __i)
{
q = p;
p = p->__next_;
if (p == nullptr)
return;
}
if (q == nullptr)
__ibeg_[hi] = p->__next_;
else
q->__next_ = p->__next_;
__c_node* c = p->__c_;
free(p);
--__isz_;
if (c != nullptr)
c->__remove(p);
}
}
}
void mpw(int p){
int i;
CLEAR(a,0);
for(i = 1;i<=num;++i) a[i][i] = 1;
for(;p;p>>=1,mut(b,b))
if(p&1) mut(a,b);
}
void
__libcpp_db::swap(void* c1, void* c2)
{
WLock _(mut());
size_t hc = hash<void*>()(c1) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p1 = __cbeg_[hc];
_LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A");
while (p1->__c_ != c1)
{
p1 = p1->__next_;
_LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap B");
}
hc = hash<void*>()(c2) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p2 = __cbeg_[hc];
_LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap C");
while (p2->__c_ != c2)
{
p2 = p2->__next_;
_LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap D");
}
std::swap(p1->beg_, p2->beg_);
std::swap(p1->end_, p2->end_);
std::swap(p1->cap_, p2->cap_);
for (__i_node** p = p1->beg_; p != p1->end_; ++p)
(*p)->__c_ = p1;
for (__i_node** p = p2->beg_; p != p2->end_; ++p)
(*p)->__c_ = p2;
}
void
__libcpp_db::__erase_c(void* __c)
{
WLock _(mut());
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
__c_node* q = nullptr;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
while (p->__c_ != __c)
{
q = p;
p = p->__next_;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c B");
}
if (q == nullptr)
__cbeg_[hc] = p->__next_;
else
q->__next_ = p->__next_;
while (p->end_ != p->beg_)
{
--p->end_;
(*p->end_)->__c_ = nullptr;
}
free(p->beg_);
free(p);
--__csz_;
}
void
__libcpp_db::unlock() const
{
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock();
#endif
}
inline void windows_mutex::unlock(void)
{
sync_handles &handles =
windows_intermodule_singleton<sync_handles>::get();
//This can throw
winapi_mutex_functions mut(handles.obtain_mutex(this->id_));
return mut.unlock();
}
inline bool windows_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
{
sync_handles &handles =
windows_intermodule_singleton<sync_handles>::get();
//This can throw
winapi_mutex_functions mut(handles.obtain_mutex(this->id_));
return mut.timed_lock(abs_time);
}
void*
__libcpp_db::__find_c_from_i(void* __i) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
_LIBCPP_ASSERT(i != nullptr, "iterator not found in debug database.");
return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
}
void
__libcpp_db::__insert_i(void* __i)
{
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut());
#endif
__insert_iterator(__i);
}
void accumulo_writer_add_write(accumulo_writer* obj, const char* row,
const char* colf, const char* colq,
const char* vis, uint64_t timestamp,
const char* val)
{
Mutation mut(row);
mut.put(colf, colq, vis, timestamp, val);
obj->writer.addMutation(mut);
}
bool
__libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
{
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut());
#endif
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
}
bool
__libcpp_db::__decrementable(const void* __i) const
{
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut());
#endif
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
}
void*
__libcpp_db::__find_c_from_i(void* __i) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
_LIBCPP_ASSERT(i != nullptr, "iterator constructed in translation unit with debug mode not enabled."
" #define _LIBCPP_DEBUG2 1 for that translation unit.");
return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
}
int upd()
{
int tmp=0;
tmp = mut(mut(c[0],c[2]),a2);//tmp = ((c[0]*c[2])%modd*a2)%modd;
tmp = add(tmp,mut(add(mut(c[1],c[2]),mut(c[0],c[3])),ab)); //tmp = (tmp+((add(c[1]*c[2],c[0]*c[3]))*ab)%modd)%modd;
tmp = add(tmp,mut(mut(c[1],c[3]),b2));//tmp = (tmp+(((c[1]*c[3])%modd)*b2)%modd)%modd;
return tmp;
}
bool
__libcpp_db::__comparable(const void* __i, const void* __j) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
__i_node* j = __find_iterator(__j);
__c_node* ci = i != nullptr ? i->__c_ : nullptr;
__c_node* cj = j != nullptr ? j->__c_ : nullptr;
return ci != nullptr && ci == cj;
}
void add_seq_error_rate(char *seq, size_t len, float err)
{
size_t i;
int rnd;
for(i = 0; i < len; i++) {
if(toupper(seq[i]) != 'N' && (rnd = rand()) < err * RAND_MAX) {
seq[i] = mut(seq[i], rnd % 3);
// flist->errors[i]++;
}
}
}
bool
__libcpp_db::__less_than_comparable(const void* __i, const void* __j) const
{
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut());
#endif
__i_node* i = __find_iterator(__i);
__i_node* j = __find_iterator(__j);
__c_node* ci = i != nullptr ? i->__c_ : nullptr;
__c_node* cj = j != nullptr ? j->__c_ : nullptr;
return ci != nullptr && ci == cj;
}
__c_node*
__libcpp_db::__find_c_and_lock(void* __c) const
{
mut().lock();
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock A");
while (p->__c_ != __c)
{
p = p->__next_;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock B");
}
return p;
}
void add_seq_error_profile(char *seq, size_t seqlen, FileList *flist)
{
const read_t *r = filelist_read(flist);
int fqoffset = flist->fqoffsets[flist->curr];
filelist_extend_errarr(flist, seqlen);
size_t i, limit = MIN2(seqlen, r->seq.end);
int rnd;
for(i = 0; i < limit; i++) {
if(toupper(seq[i]) == 'N' || toupper(r->seq.b[i]) == 'N') seq[i] = 'N';
else if((rnd = rand()) < qual_prob[r->qual.b[i] - fqoffset] * RAND_MAX) {
seq[i] = mut(seq[i], rnd % 3);
flist->errors[i]++;
}
}
}
