tril& tril::operator=(const uncertainty& rhs)
{
/* We only copy the uncertainty state, so as to preserve the
* boolean bit and allow reverting with `certain()`. */
set_u(rhs.data);
return *this;
}
int
main(int argc, char **argv)
{
static xyc *Z; static nde *N;
static double **A, *u;
initop(argc, argv);
fp2mesh(stdfp(),Z,N);
ary2(A,dim1(Z)+1, dim1(Z)+1); ary1(u,dim1(Z)+1);
set_A(Z,N,A); set_u(Z,u);
esolver(A,u);
plt(NULL,NULL,Z,N,u); sleep(1000);
return 0;
}
Edge3D::Edge3D(Node3D* u, Node3D* v): m_u(0), m_v(0)
{
set_u(u);
set_v(v);
}
/*
The topology of the profile HMM:
/\ /\ /\ /\
I[1] I[k-1] I[k] I[L]
^ \ \ ^ \ ^ \ \ ^
| \ \ | \ | \ \ |
M[0] M[1] -> ... -> M[k-1] -> M[k] -> ... -> M[L] M[L+1]
\ \/ \/ \/ /
\ /\ /\ /\ /
-> D[k-1] -> D[k] ->
M[0] points to every {M,I}[k] and every {M,I}[k] points M[L+1].
On input, _ref is the reference sequence and _query is the query
sequence. Both are sequences of 0/1/2/3/4 where 4 stands for an
ambiguous residue. iqual is the base quality. c sets the gap open
probability, gap extension probability and band width.
On output, state and q are arrays of length l_query. The higher 30
bits give the reference position the query base is matched to and the
lower two bits can be 0 (an alignment match) or 1 (an
insertion). q[i] gives the phred scaled posterior probability of
state[i] being wrong.
*/
int kpa_glocal(const uint8_t *_ref, int l_ref, const uint8_t *_query, int l_query, const uint8_t *iqual,
const kpa_par_t *c, int *state, uint8_t *q)
{
double **f, **b = 0, *s, m[9], sI, sM, bI, bM, pb;
float *qual, *_qual;
const uint8_t *ref, *query;
int bw, bw2, i, k, is_diff = 0, is_backward = 1, Pr;
if ( l_ref<=0 || l_query<=0 ) return 0; // FIXME: this may not be an ideal fix, just prevents sefgault
/*** initialization ***/
is_backward = state && q? 1 : 0;
ref = _ref - 1; query = _query - 1; // change to 1-based coordinate
bw = l_ref > l_query? l_ref : l_query;
if (bw > c->bw) bw = c->bw;
if (bw < abs(l_ref - l_query)) bw = abs(l_ref - l_query);
bw2 = bw * 2 + 1;
// allocate the forward and backward matrices f[][] and b[][] and the scaling array s[]
f = calloc(l_query+1, sizeof(void*));
if (is_backward) b = calloc(l_query+1, sizeof(void*));
for (i = 0; i <= l_query; ++i) { // FIXME: this will lead in segfault for l_query==0
f[i] = calloc(bw2 * 3 + 6, sizeof(double)); // FIXME: this is over-allocated for very short seqs
if (is_backward) b[i] = calloc(bw2 * 3 + 6, sizeof(double));
}
s = calloc(l_query+2, sizeof(double)); // s[] is the scaling factor to avoid underflow
// initialize qual
_qual = calloc(l_query, sizeof(float));
if (g_qual2prob[0] == 0)
for (i = 0; i < 256; ++i)
g_qual2prob[i] = pow(10, -i/10.);
for (i = 0; i < l_query; ++i) _qual[i] = g_qual2prob[iqual? iqual[i] : 30];
qual = _qual - 1;
// initialize transition probability
sM = sI = 1. / (2 * l_query + 2); // the value here seems not to affect results; FIXME: need proof
m[0*3+0] = (1 - c->d - c->d) * (1 - sM); m[0*3+1] = m[0*3+2] = c->d * (1 - sM);
m[1*3+0] = (1 - c->e) * (1 - sI); m[1*3+1] = c->e * (1 - sI); m[1*3+2] = 0.;
m[2*3+0] = 1 - c->e; m[2*3+1] = 0.; m[2*3+2] = c->e;
bM = (1 - c->d) / l_ref; bI = c->d / l_ref; // (bM+bI)*l_ref==1
/*** forward ***/
// f[0]
set_u(k, bw, 0, 0);
f[0][k] = s[0] = 1.;
{ // f[1]
double *fi = f[1], sum;
int beg = 1, end = l_ref < bw + 1? l_ref : bw + 1, _beg, _end;
for (k = beg, sum = 0.; k <= end; ++k) {
int u;
double e = (ref[k] > 3 || query[1] > 3)? 1. : ref[k] == query[1]? 1. - qual[1] : qual[1] * EM;
set_u(u, bw, 1, k);
fi[u+0] = e * bM; fi[u+1] = EI * bI;
sum += fi[u] + fi[u+1];
}
// rescale
s[1] = sum;
set_u(_beg, bw, 1, beg); set_u(_end, bw, 1, end); _end += 2;
for (k = _beg; k <= _end; ++k) fi[k] /= sum;
}
// f[2..l_query]
for (i = 2; i <= l_query; ++i) {
double *fi = f[i], *fi1 = f[i-1], sum, qli = qual[i];
int beg = 1, end = l_ref, x, _beg, _end;
uint8_t qyi = query[i];
x = i - bw; beg = beg > x? beg : x; // band start
x = i + bw; end = end < x? end : x; // band end
for (k = beg, sum = 0.; k <= end; ++k) {
int u, v11, v01, v10;
double e;
e = (ref[k] > 3 || qyi > 3)? 1. : ref[k] == qyi? 1. - qli : qli * EM;
set_u(u, bw, i, k); set_u(v11, bw, i-1, k-1); set_u(v10, bw, i-1, k); set_u(v01, bw, i, k-1);
fi[u+0] = e * (m[0] * fi1[v11+0] + m[3] * fi1[v11+1] + m[6] * fi1[v11+2]);
fi[u+1] = EI * (m[1] * fi1[v10+0] + m[4] * fi1[v10+1]);
fi[u+2] = m[2] * fi[v01+0] + m[8] * fi[v01+2];
sum += fi[u] + fi[u+1] + fi[u+2];
// fprintf(stderr, "F (%d,%d;%d): %lg,%lg,%lg\n", i, k, u, fi[u], fi[u+1], fi[u+2]); // DEBUG
}
// rescale
s[i] = sum;
set_u(_beg, bw, i, beg); set_u(_end, bw, i, end); _end += 2;
for (k = _beg, sum = 1./sum; k <= _end; ++k) fi[k] *= sum;
}
{ // f[l_query+1]
double sum;
for (k = 1, sum = 0.; k <= l_ref; ++k) {
int u;
set_u(u, bw, l_query, k);
if (u < 3 || u >= bw2*3+3) continue;
sum += f[l_query][u+0] * sM + f[l_query][u+1] * sI;
}
s[l_query+1] = sum; // the last scaling factor
}
{ // compute likelihood
double p = 1., Pr1 = 0.;
for (i = 0; i <= l_query + 1; ++i) {
p *= s[i];
if (p < 1e-100) Pr1 += -4.343 * log(p), p = 1.;
}
Pr1 += -4.343 * log(p * l_ref * l_query);
Pr = (int)(Pr1 + .499);
if (!is_backward) { // skip backward and MAP
for (i = 0; i <= l_query; ++i) free(f[i]);
free(f); free(s); free(_qual);
return Pr;
}
}
/*** backward ***/
// b[l_query] (b[l_query+1][0]=1 and thus \tilde{b}[][]=1/s[l_query+1]; this is where s[l_query+1] comes from)
for (k = 1; k <= l_ref; ++k) {
int u;
double *bi = b[l_query];
set_u(u, bw, l_query, k);
if (u < 3 || u >= bw2*3+3) continue;
bi[u+0] = sM / s[l_query] / s[l_query+1]; bi[u+1] = sI / s[l_query] / s[l_query+1];
}
// b[l_query-1..1]
for (i = l_query - 1; i >= 1; --i) {
int beg = 1, end = l_ref, x, _beg, _end;
double *bi = b[i], *bi1 = b[i+1], y = (i > 1), qli1 = qual[i+1];
uint8_t qyi1 = query[i+1];
x = i - bw; beg = beg > x? beg : x;
x = i + bw; end = end < x? end : x;
for (k = end; k >= beg; --k) {
int u, v11, v01, v10;
double e;
set_u(u, bw, i, k); set_u(v11, bw, i+1, k+1); set_u(v10, bw, i+1, k); set_u(v01, bw, i, k+1);
e = (k >= l_ref? 0 : (ref[k+1] > 3 || qyi1 > 3)? 1. : ref[k+1] == qyi1? 1. - qli1 : qli1 * EM) * bi1[v11];
bi[u+0] = e * m[0] + EI * m[1] * bi1[v10+1] + m[2] * bi[v01+2]; // bi1[v11] has been foled into e.
bi[u+1] = e * m[3] + EI * m[4] * bi1[v10+1];
bi[u+2] = (e * m[6] + m[8] * bi[v01+2]) * y;
// fprintf(stderr, "B (%d,%d;%d): %lg,%lg,%lg\n", i, k, u, bi[u], bi[u+1], bi[u+2]); // DEBUG
}
// rescale
set_u(_beg, bw, i, beg); set_u(_end, bw, i, end); _end += 2;
for (k = _beg, y = 1./s[i]; k <= _end; ++k) bi[k] *= y;
}
{ // b[0]
int beg = 1, end = l_ref < bw + 1? l_ref : bw + 1;
double sum = 0.;
for (k = end; k >= beg; --k) {
int u;
double e = (ref[k] > 3 || query[1] > 3)? 1. : ref[k] == query[1]? 1. - qual[1] : qual[1] * EM;
set_u(u, bw, 1, k);
if (u < 3 || u >= bw2*3+3) continue;
sum += e * b[1][u+0] * bM + EI * b[1][u+1] * bI;
}
set_u(k, bw, 0, 0);
pb = b[0][k] = sum / s[0]; // if everything works as is expected, pb == 1.0
}
is_diff = fabs(pb - 1.) > 1e-7? 1 : 0;
/*** MAP ***/
for (i = 1; i <= l_query; ++i) {
double sum = 0., *fi = f[i], *bi = b[i], max = 0.;
int beg = 1, end = l_ref, x, max_k = -1;
x = i - bw; beg = beg > x? beg : x;
x = i + bw; end = end < x? end : x;
for (k = beg; k <= end; ++k) {
int u;
double z;
set_u(u, bw, i, k);
z = fi[u+0] * bi[u+0]; if (z > max) max = z, max_k = (k-1)<<2 | 0; sum += z;
z = fi[u+1] * bi[u+1]; if (z > max) max = z, max_k = (k-1)<<2 | 1; sum += z;
}
max /= sum; sum *= s[i]; // if everything works as is expected, sum == 1.0
if (state) state[i-1] = max_k;
if (q) k = (int)(-4.343 * log(1. - max) + .499), q[i-1] = k > 100? 99 : k;
#ifdef _MAIN
fprintf(stderr, "(%.10lg,%.10lg) (%d,%d:%c,%c:%d) %lg\n", pb, sum, i-1, max_k>>2,
"ACGT"[query[i]], "ACGT"[ref[(max_k>>2)+1]], max_k&3, max); // DEBUG
#endif
}
/*** free ***/
for (i = 0; i <= l_query; ++i) {
free(f[i]); free(b[i]);
}
free(f); free(b); free(s); free(_qual);
return Pr;
}
static cigar* banded_sw (const int8_t* ref,
const int8_t* read,
int32_t refLen,
int32_t readLen,
int32_t score,
const uint32_t weight_gapO, /* will be used as - */
const uint32_t weight_gapE, /* will be used as - */
int32_t band_width,
const int8_t* mat, /* pointer to the weight matrix */
int32_t n) {
uint32_t *c = (uint32_t*)malloc(16 * sizeof(uint32_t)), *c1;
int32_t i, j, e, f, temp1, temp2, s = 16, s1 = 8, l, max = 0;
int64_t s2 = 1024;
char op, prev_op;
int32_t width, width_d, *h_b, *e_b, *h_c;
int8_t *direction, *direction_line;
cigar* result = (cigar*)malloc(sizeof(cigar));
h_b = (int32_t*)malloc(s1 * sizeof(int32_t));
e_b = (int32_t*)malloc(s1 * sizeof(int32_t));
h_c = (int32_t*)malloc(s1 * sizeof(int32_t));
direction = (int8_t*)malloc(s2 * sizeof(int8_t));
do {
width = band_width * 2 + 3, width_d = band_width * 2 + 1;
while (width >= s1) {
++s1;
kroundup32(s1);
h_b = (int32_t*)realloc(h_b, s1 * sizeof(int32_t));
e_b = (int32_t*)realloc(e_b, s1 * sizeof(int32_t));
h_c = (int32_t*)realloc(h_c, s1 * sizeof(int32_t));
}
while (width_d * readLen * 3 >= s2) {
++s2;
kroundup32(s2);
if (s2 < 0) {
fprintf(stderr, "Alignment score and position are not consensus.\n");
exit(1);
}
direction = (int8_t*)realloc(direction, s2 * sizeof(int8_t));
}
direction_line = direction;
for (j = 1; LIKELY(j < width - 1); j ++) h_b[j] = 0;
for (i = 0; LIKELY(i < readLen); i ++) {
int32_t beg = 0, end = refLen - 1, u = 0, edge;
j = i - band_width; beg = beg > j ? beg : j; // band start
j = i + band_width; end = end < j ? end : j; // band end
edge = end + 1 < width - 1 ? end + 1 : width - 1;
f = h_b[0] = e_b[0] = h_b[edge] = e_b[edge] = h_c[0] = 0;
direction_line = direction + width_d * i * 3;
for (j = beg; LIKELY(j <= end); j ++) {
int32_t b, e1, f1, d, de, df, dh;
set_u(u, band_width, i, j); set_u(e, band_width, i - 1, j);
set_u(b, band_width, i, j - 1); set_u(d, band_width, i - 1, j - 1);
set_d(de, band_width, i, j, 0);
set_d(df, band_width, i, j, 1);
set_d(dh, band_width, i, j, 2);
temp1 = i == 0 ? -weight_gapO : h_b[e] - weight_gapO;
temp2 = i == 0 ? -weight_gapE : e_b[e] - weight_gapE;
e_b[u] = temp1 > temp2 ? temp1 : temp2;
direction_line[de] = temp1 > temp2 ? 3 : 2;
temp1 = h_c[b] - weight_gapO;
temp2 = f - weight_gapE;
f = temp1 > temp2 ? temp1 : temp2;
direction_line[df] = temp1 > temp2 ? 5 : 4;
e1 = e_b[u] > 0 ? e_b[u] : 0;
f1 = f > 0 ? f : 0;
temp1 = e1 > f1 ? e1 : f1;
temp2 = h_b[d] + mat[ref[j] * n + read[i]];
h_c[u] = temp1 > temp2 ? temp1 : temp2;
if (h_c[u] > max) max = h_c[u];
if (temp1 <= temp2) direction_line[dh] = 1;
else direction_line[dh] = e1 > f1 ? direction_line[de] : direction_line[df];
}
for (j = 1; j <= u; j ++) h_b[j] = h_c[j];
}
band_width *= 2;
} while (LIKELY(max < score));
band_width /= 2;
// trace back
i = readLen - 1;
j = refLen - 1;
e = 0; // Count the number of M, D or I.
l = 0; // record length of current cigar
op = prev_op = 'M';
temp2 = 2; // h
while (LIKELY(i > 0)) {
set_d(temp1, band_width, i, j, temp2);
switch (direction_line[temp1]) {
case 1:
--i;
--j;
temp2 = 2;
direction_line -= width_d * 3;
op = 'M';
break;
case 2:
--i;
temp2 = 0; // e
direction_line -= width_d * 3;
op = 'I';
break;
case 3:
--i;
temp2 = 2;
direction_line -= width_d * 3;
op = 'I';
break;
case 4:
--j;
temp2 = 1;
op = 'D';
break;
case 5:
--j;
temp2 = 2;
op = 'D';
break;
default:
fprintf(stderr, "Trace back error: %d.\n", direction_line[temp1 - 1]);
free(direction);
free(h_c);
free(e_b);
free(h_b);
free(c);
free(result);
return 0;
}
if (op == prev_op) ++e;
else {
++l;
while (l >= s) {
++s;
kroundup32(s);
c = (uint32_t*)realloc(c, s * sizeof(uint32_t));
}
c[l - 1] = to_cigar_int(e, prev_op);
prev_op = op;
e = 1;
}
}
if (op == 'M') {
++l;
while (l >= s) {
++s;
kroundup32(s);
c = (uint32_t*)realloc(c, s * sizeof(uint32_t));
}
c[l - 1] = to_cigar_int(e + 1, op);
}else {
l += 2;
while (l >= s) {
++s;
kroundup32(s);
c = (uint32_t*)realloc(c, s * sizeof(uint32_t));
}
c[l - 2] = to_cigar_int(e, op);
c[l - 1] = to_cigar_int(1, 'M');
}
// reverse cigar
c1 = (uint32_t*)malloc(l * sizeof(uint32_t));
s = 0;
e = l - 1;
while (LIKELY(s <= e)) {
c1[s] = c[e];
c1[e] = c[s];
++ s;
-- e;
}
result->seq = c1;
result->length = l;
free(direction);
free(h_c);
free(e_b);
free(h_b);
free(c);
return result;
}
tril::tril(bool in_b, bool in_u)
:data(0)
{
set_b(in_b);
set_u(in_u);
}
tril& tril::operator=(const bool& rhs)
{
set_b(rhs);
set_u(false);
return *this;
}
bool atomic_base<Base>::rev_sparse_hes(
const vector<Base>& x ,
const local::pod_vector<size_t>& x_index ,
const local::pod_vector<size_t>& y_index ,
const InternalSparsity& for_jac_sparsity ,
bool* rev_jac_flag ,
InternalSparsity& rev_hes_sparsity )
{ CPPAD_ASSERT_UNKNOWN( for_jac_sparsity.end() == rev_hes_sparsity.end() );
size_t q = rev_hes_sparsity.end();
size_t n = x_index.size();
size_t m = y_index.size();
bool ok = false;
size_t thread = thread_alloc::thread_num();
allocate_work(thread);
bool zero_empty = true;
bool input_empty = false;
bool transpose = false;
//
// vx
vector<bool> vx(n);
for(size_t j = 0; j < n; j++)
vx[j] = x_index[j] != 0;
//
// note that s and t are vectors so transpose does not matter for bool case
vector<bool> bool_s( work_[thread]->bool_s );
vector<bool> bool_t( work_[thread]->bool_t );
//
bool_s.resize(m);
bool_t.resize(n);
//
for(size_t i = 0; i < m; i++)
{ if( y_index[i] > 0 )
bool_s[i] = rev_jac_flag[ y_index[i] ];
}
//
std::string msg = ": atomic_base.rev_sparse_hes: returned false";
if( sparsity_ == pack_sparsity_enum )
{ vectorBool& pack_r( work_[thread]->pack_r );
vectorBool& pack_u( work_[thread]->pack_u );
vectorBool& pack_v( work_[thread]->pack_h );
//
pack_v.resize(n * q);
//
local::get_internal_sparsity(
transpose, x_index, for_jac_sparsity, pack_r
);
local::get_internal_sparsity(
transpose, y_index, rev_hes_sparsity, pack_u
);
//
ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v, x);
if( ! ok )
ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v);
if( ! ok )
{ msg = afun_name() + msg + " sparsity = pack_sparsity_enum";
CPPAD_ASSERT_KNOWN(false, msg.c_str());
}
local::set_internal_sparsity(zero_empty, input_empty,
transpose, x_index, rev_hes_sparsity, pack_v
);
}
else if( sparsity_ == bool_sparsity_enum )
{ vector<bool>& bool_r( work_[thread]->bool_r );
vector<bool>& bool_u( work_[thread]->bool_u );
vector<bool>& bool_v( work_[thread]->bool_h );
//
bool_v.resize(n * q);
//
local::get_internal_sparsity(
transpose, x_index, for_jac_sparsity, bool_r
);
local::get_internal_sparsity(
transpose, y_index, rev_hes_sparsity, bool_u
);
//
ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v, x);
if( ! ok )
ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v);
if( ! ok )
{ msg = afun_name() + msg + " sparsity = bool_sparsity_enum";
CPPAD_ASSERT_KNOWN(false, msg.c_str());
}
local::set_internal_sparsity(zero_empty, input_empty,
transpose, x_index, rev_hes_sparsity, bool_v
);
}
else
{ CPPAD_ASSERT_UNKNOWN( sparsity_ == set_sparsity_enum );
vector< std::set<size_t> >& set_r( work_[thread]->set_r );
vector< std::set<size_t> >& set_u( work_[thread]->set_u );
vector< std::set<size_t> >& set_v( work_[thread]->set_h );
//
set_v.resize(n);
//
local::get_internal_sparsity(
transpose, x_index, for_jac_sparsity, set_r
);
local::get_internal_sparsity(
transpose, y_index, rev_hes_sparsity, set_u
);
//
ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v, x);
if( ! ok )
ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v);
if( ! ok )
{ msg = afun_name() + msg + " sparsity = set_sparsity_enum";
CPPAD_ASSERT_KNOWN(false, msg.c_str());
}
local::set_internal_sparsity(zero_empty, input_empty,
transpose, x_index, rev_hes_sparsity, set_v
);
}
for(size_t j = 0; j < n; j++)
{ if( x_index[j] > 0 )
rev_jac_flag[ x_index[j] ] |= bool_t[j];
}
return ok;
}
