point triangle::calc_center( triangle* t ) { arma::vec Pa(3); Pa(0) = (t->m_vertex_list[0].x); Pa(1) = (t->m_vertex_list[0].y); Pa(2) = 0; arma::vec Pb(3); Pb(0) = (t->m_vertex_list[1].x); Pb(1) = (t->m_vertex_list[1].y); Pb(2) = 0; arma::vec Pc(3); Pc(0) = (t->m_vertex_list[2].x); Pc(1) = (t->m_vertex_list[2].y); Pc(2) = 0; arma::vec AB = Pb - Pa; arma::vec AC = Pc - Pa; arma::vec BC = Pc - Pb; //circumcenter // arma::vec N = arma::cross(AC,AB); // arma::vec L1 = arma::cross(AB,N); // arma::vec L2 = arma::cross(BC,N); // arma::vec P21 = (Pc - Pa)/2; // arma::vec P1 = (Pa + Pb)/2; //incenter arma::vec uab = AB / arma::norm(AB,1); arma::vec uac = AC / arma::norm(AC,1); arma::vec ubc = BC / arma::norm(BC,1); arma::vec uba = -uab; arma::vec L1 = uab + uac; arma::vec L2 = uba + ubc; arma::vec P21 = Pb-Pa; arma::vec P1 = Pa; arma::mat ML1(L1); arma::mat ML2(L2); arma::mat ML = arma::join_rows(ML1,-ML2); arma::vec lambda = arma::solve(ML,P21); arma::vec pos = P1+lambda(0)*L1; point p; p.x = pos(0); p.y = pos(1); return p; }
int main() { using SolverType = invlib::ConjugateGradient<>; using MinimizerType = invlib::GaussNewton<double, SolverType>; using PrecisionMatrix = invlib::PrecisionMatrix<MatrixType>; using MAPType = invlib::MAP<LinearModel, MatrixType, PrecisionMatrix, PrecisionMatrix>; // Load data. MatrixType K = invlib::read_matrix_arts("STR_VALUE(MATS_DATA)/K.xml"); MatrixType SaInv = invlib::read_matrix_arts("STR_VALUE(MATS_DATA)/SaInv.xml"); MatrixType SeInv = invlib::read_matrix_arts("STR_VALUE(MATS_DATA)/SeInv.xml"); PrecisionMatrix Pa(SaInv); PrecisionMatrix Pe(SeInv); VectorType y = invlib::read_vector_arts("STR_VALUE(MATS_DATA)/y.vec"); VectorType xa = invlib::read_vector_arts("STR_VALUE(MATS_DATA)/xa.vec"); // Setup OEM. SolverType cg(1e-6, 1); MinimizerType gn(1e-6, 1, cg); LinearModel F(K, xa); MAPType oem(F, xa, Pa, Pe); // Run OEM. VectorType x; oem.compute(x, y, gn, 0); invlib::write_vector_arts("x.xml", (invlib::VectorData<double>) x, invlib::Format::ASCII); return 0.0; }
int Pa(int low,int high,int length,char *str) { if(length == 0 || length == 1) return 1; if(str[low] != str[high]) return 0; Pa(low+1,high-1,length-2,str); }
void x_PredictAGSites(const Seq& seq, CAntigenic::TLocVec& results, int min_len) { // First build vector giving local average of Pa (over 7 residues). // Along the way, calculate the average for the whole protein. vector<double> Pa(seq.size()); double local_sum = 0, global_sum = 0; for (int i = 0; i < 7; i++) { local_sum += CAntigenic::sm_Pa_table[static_cast<unsigned>(seq[i])]; global_sum += CAntigenic::sm_Pa_table[static_cast<unsigned>(seq[i])]; } Pa[3] = local_sum / 7; for (unsigned int i = 4; i < seq.size() - 3; i++) { local_sum -= CAntigenic::sm_Pa_table[static_cast<unsigned>(seq[i-4])]; local_sum += CAntigenic::sm_Pa_table[static_cast<unsigned>(seq[i+3])]; global_sum += CAntigenic::sm_Pa_table[static_cast<unsigned>(seq[i+3])]; Pa[i] = local_sum / 7; } double global_mean = global_sum / seq.size(); double thresh = min(global_mean, 1.0); // now look for runs of Pa >= thresh of length >= min_len int count = 0; int begin = 0; // initialize to avoid compiler warning // NOTE: we go one extra residue, in the knowledge that // its Pa entry will be zero, so it will end any run for (unsigned int i = 3; i < seq.size() - 2; i++) { if (Pa[i] >= thresh) { if (count == 0) { begin = i; // the beginning of a run } count++; } else { // the end of a (possibly empty) run if (count >= min_len) { // an antigenic site int end = i - 1; CRef<objects::CSeq_loc> loc(new objects::CSeq_loc()); loc->SetInt().SetFrom(begin); loc->SetInt().SetTo(end); results.push_back(loc); } count = 0; } } }
int main(int argc,char *argv[]) { int Pa(int low,int high,int length,char *str); int iseven(int n); int isodd(int n); char str[]="aabaa"; int len; len = strlen(str); if(Pa(0,len-1,len,str)) { printf("this string is a Pa string\n"); } printf("3:%d 4:%d\n",iseven(0),iseven(4)); }
//---------------------------------------------------------------------- Mat & AccumulatorTransitionMatrix::add_to(Mat &P)const { int state_dim = transition_matrix_->nrow(); if(P.nrow() != state_dim+2 || P.ncol() != state_dim+2) { report_error("wrong sizes in AccumulatorTransitionMatrix::add_to"); } SubMatrix Pa(P, 0, state_dim-1, 0, state_dim-1); transition_matrix_->add_to_submatrix(Pa); Vec tmp = transition_matrix_->Tmult(observation_vector_.dense()); VectorView(P.row(state_dim), 0, state_dim) += tmp; double a = 1 - fraction_in_initial_period_ * contains_end_; int b = !contains_end_; P(state_dim+1, state_dim) += a; P(state_dim+1, state_dim+1) += b; return P; }
/** * @function setGlCamera * Set OpenGL camera parameters. * The off-axis projection is what gives * the feeling of augmented reality. */ void setGlCamera() { if(bProjectionMode) { /* SKEWED FRUSTRUM / OFF-AXIS PROJECTION ** My implementation is based on the following paper: ** Name: Generalized Perspective Projection ** Author: Robert Kooima ** Date: August 2008, revised June 2009 */ //-- space corners coordinates float pa[3]={-cx,-cy,0}; float pb[3]={cx,-cy,0}; float pc[3]={-cx,cy,0}; float pe[3]={glCamX,glCamY,glCamZ}; //-- space points cv::Vec3f Pa(pa); cv::Vec3f Pb(pb); cv::Vec3f Pc(pc); cv::Vec3f Pe(pe); //-- Compute an orthonormal basis for the screen. cv::Vec3f Vr = Pb-Pa; Vr /= cv::norm(Vr); cv::Vec3f Vu = Pc-Pa; Vu /= cv::norm(Vu); cv::Vec3f Vn = Vr.cross(Vu); Vn /= cv::norm(Vn); //-- Compute the screen corner vectors. cv::Vec3f Va = Pa-Pe; cv::Vec3f Vb = Pb-Pe; cv::Vec3f Vc = Pc-Pe; //-- Find the distance from the eye to screen plane. float d = -Va.dot(Vn); //-- Find the extent of the perpendicular projection. float l = Va.dot(Vr) * near / d; float r = Vr.dot(Vb) * near / d; float b = Vu.dot(Va) * near / d; float t = Vu.dot(Vc) * near / d; //-- Load the perpendicular projection. glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(l, r, b, t, near, far+d); //-- Rotate the projection to be non-perpendicular. float M[16]; memset(M, 0, 16 * sizeof (float)); M[0] = Vr[0]; M[1] = Vu[0]; M[2] = Vn[0]; M[4] = Vr[1]; M[5] = Vu[1]; M[6] = Vn[1]; M[8] = Vr[2]; M[9] = Vu[2]; M[10] = Vn[2]; M[15] = 1.0f; glMultMatrixf(M); //-- Move the apex of the frustum to the origin. glTranslatef(-pe[0], -pe[1], -pe[2]); //-- Reset modelview matrix glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } else { //-- intrinsic camera params glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60, (float)windowWidth/(float)windowHeight, 1, 250); //-- extrinsic camera params glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(glCamX, glCamY, glCamZ, 0, 0, 0, 0, 1, 0); } }
void sha512_update(sha512_ctx_t *ctx, void *data, size_t dlen) { uint16_t avail; /* space available in the context message block */ uint16_t pos; /* position to write data into the message block */ uint64_t x[80]; while (dlen) { pos = CTX_POS(ctx); avail = CTX_AVAIL(ctx); if (avail > dlen) avail = dlen; /* Copy input data into the context's message block. */ memcpy(ctx->block + pos, data, avail); data += avail; dlen -= avail; ctx->len += avail; if ((ctx->len % 128) == 0) { uint64_t a = ctx->hash[0]; uint64_t b = ctx->hash[1]; uint64_t c = ctx->hash[2]; uint64_t d = ctx->hash[3]; uint64_t e = ctx->hash[4]; uint64_t f = ctx->hash[5]; uint64_t g = ctx->hash[6]; uint64_t h = ctx->hash[7]; uint64_t t; Pa(t, a, b, c, d, e, f, g, h, x, 0, 0x428a2f98d728ae22); Pa(t, h, a, b, c, d, e, f, g, x, 1, 0x7137449123ef65cd); Pa(t, g, h, a, b, c, d, e, f, x, 2, 0xb5c0fbcfec4d3b2f); Pa(t, f, g, h, a, b, c, d, e, x, 3, 0xe9b5dba58189dbbc); Pa(t, e, f, g, h, a, b, c, d, x, 4, 0x3956c25bf348b538); Pa(t, d, e, f, g, h, a, b, c, x, 5, 0x59f111f1b605d019); Pa(t, c, d, e, f, g, h, a, b, x, 6, 0x923f82a4af194f9b); Pa(t, b, c, d, e, f, g, h, a, x, 7, 0xab1c5ed5da6d8118); Pa(t, a, b, c, d, e, f, g, h, x, 8, 0xd807aa98a3030242); Pa(t, h, a, b, c, d, e, f, g, x, 9, 0x12835b0145706fbe); Pa(t, g, h, a, b, c, d, e, f, x, 10, 0x243185be4ee4b28c); Pa(t, f, g, h, a, b, c, d, e, x, 11, 0x550c7dc3d5ffb4e2); Pa(t, e, f, g, h, a, b, c, d, x, 12, 0x72be5d74f27b896f); Pa(t, d, e, f, g, h, a, b, c, x, 13, 0x80deb1fe3b1696b1); Pa(t, c, d, e, f, g, h, a, b, x, 14, 0x9bdc06a725c71235); Pa(t, b, c, d, e, f, g, h, a, x, 15, 0xc19bf174cf692694); Pb(t, a, b, c, d, e, f, g, h, x, 16, 0xe49b69c19ef14ad2); Pb(t, h, a, b, c, d, e, f, g, x, 17, 0xefbe4786384f25e3); Pb(t, g, h, a, b, c, d, e, f, x, 18, 0x0fc19dc68b8cd5b5); Pb(t, f, g, h, a, b, c, d, e, x, 19, 0x240ca1cc77ac9c65); Pb(t, e, f, g, h, a, b, c, d, x, 20, 0x2de92c6f592b0275); Pb(t, d, e, f, g, h, a, b, c, x, 21, 0x4a7484aa6ea6e483); Pb(t, c, d, e, f, g, h, a, b, x, 22, 0x5cb0a9dcbd41fbd4); Pb(t, b, c, d, e, f, g, h, a, x, 23, 0x76f988da831153b5); Pb(t, a, b, c, d, e, f, g, h, x, 24, 0x983e5152ee66dfab); Pb(t, h, a, b, c, d, e, f, g, x, 25, 0xa831c66d2db43210); Pb(t, g, h, a, b, c, d, e, f, x, 26, 0xb00327c898fb213f); Pb(t, f, g, h, a, b, c, d, e, x, 27, 0xbf597fc7beef0ee4); Pb(t, e, f, g, h, a, b, c, d, x, 28, 0xc6e00bf33da88fc2); Pb(t, d, e, f, g, h, a, b, c, x, 29, 0xd5a79147930aa725); Pb(t, c, d, e, f, g, h, a, b, x, 30, 0x06ca6351e003826f); Pb(t, b, c, d, e, f, g, h, a, x, 31, 0x142929670a0e6e70); Pb(t, a, b, c, d, e, f, g, h, x, 32, 0x27b70a8546d22ffc); Pb(t, h, a, b, c, d, e, f, g, x, 33, 0x2e1b21385c26c926); Pb(t, g, h, a, b, c, d, e, f, x, 34, 0x4d2c6dfc5ac42aed); Pb(t, f, g, h, a, b, c, d, e, x, 35, 0x53380d139d95b3df); Pb(t, e, f, g, h, a, b, c, d, x, 36, 0x650a73548baf63de); Pb(t, d, e, f, g, h, a, b, c, x, 37, 0x766a0abb3c77b2a8); Pb(t, c, d, e, f, g, h, a, b, x, 38, 0x81c2c92e47edaee6); Pb(t, b, c, d, e, f, g, h, a, x, 39, 0x92722c851482353b); Pb(t, a, b, c, d, e, f, g, h, x, 40, 0xa2bfe8a14cf10364); Pb(t, h, a, b, c, d, e, f, g, x, 41, 0xa81a664bbc423001); Pb(t, g, h, a, b, c, d, e, f, x, 42, 0xc24b8b70d0f89791); Pb(t, f, g, h, a, b, c, d, e, x, 43, 0xc76c51a30654be30); Pb(t, e, f, g, h, a, b, c, d, x, 44, 0xd192e819d6ef5218); Pb(t, d, e, f, g, h, a, b, c, x, 45, 0xd69906245565a910); Pb(t, c, d, e, f, g, h, a, b, x, 46, 0xf40e35855771202a); Pb(t, b, c, d, e, f, g, h, a, x, 47, 0x106aa07032bbd1b8); Pb(t, a, b, c, d, e, f, g, h, x, 48, 0x19a4c116b8d2d0c8); Pb(t, h, a, b, c, d, e, f, g, x, 49, 0x1e376c085141ab53); Pb(t, g, h, a, b, c, d, e, f, x, 50, 0x2748774cdf8eeb99); Pb(t, f, g, h, a, b, c, d, e, x, 51, 0x34b0bcb5e19b48a8); Pb(t, e, f, g, h, a, b, c, d, x, 52, 0x391c0cb3c5c95a63); Pb(t, d, e, f, g, h, a, b, c, x, 53, 0x4ed8aa4ae3418acb); Pb(t, c, d, e, f, g, h, a, b, x, 54, 0x5b9cca4f7763e373); Pb(t, b, c, d, e, f, g, h, a, x, 55, 0x682e6ff3d6b2b8a3); Pb(t, a, b, c, d, e, f, g, h, x, 56, 0x748f82ee5defb2fc); Pb(t, h, a, b, c, d, e, f, g, x, 57, 0x78a5636f43172f60); Pb(t, g, h, a, b, c, d, e, f, x, 58, 0x84c87814a1f0ab72); Pb(t, f, g, h, a, b, c, d, e, x, 59, 0x8cc702081a6439ec); Pb(t, e, f, g, h, a, b, c, d, x, 60, 0x90befffa23631e28); Pb(t, d, e, f, g, h, a, b, c, x, 61, 0xa4506cebde82bde9); Pb(t, c, d, e, f, g, h, a, b, x, 62, 0xbef9a3f7b2c67915); Pb(t, b, c, d, e, f, g, h, a, x, 63, 0xc67178f2e372532b); Pb(t, a, b, c, d, e, f, g, h, x, 64, 0xca273eceea26619c); Pb(t, h, a, b, c, d, e, f, g, x, 65, 0xd186b8c721c0c207); Pb(t, g, h, a, b, c, d, e, f, x, 66, 0xeada7dd6cde0eb1e); Pb(t, f, g, h, a, b, c, d, e, x, 67, 0xf57d4f7fee6ed178); Pb(t, e, f, g, h, a, b, c, d, x, 68, 0x06f067aa72176fba); Pb(t, d, e, f, g, h, a, b, c, x, 69, 0x0a637dc5a2c898a6); Pb(t, c, d, e, f, g, h, a, b, x, 70, 0x113f9804bef90dae); Pb(t, b, c, d, e, f, g, h, a, x, 71, 0x1b710b35131c471b); Pb(t, a, b, c, d, e, f, g, h, x, 72, 0x28db77f523047d84); Pb(t, h, a, b, c, d, e, f, g, x, 73, 0x32caab7b40c72493); Pb(t, g, h, a, b, c, d, e, f, x, 74, 0x3c9ebe0a15c9bebc); Pb(t, f, g, h, a, b, c, d, e, x, 75, 0x431d67c49c100d4c); Pb(t, e, f, g, h, a, b, c, d, x, 76, 0x4cc5d4becb3e42b6); Pb(t, d, e, f, g, h, a, b, c, x, 77, 0x597f299cfc657e2a); Pb(t, c, d, e, f, g, h, a, b, x, 78, 0x5fcb6fab3ad6faec); Pb(t, b, c, d, e, f, g, h, a, x, 79, 0x6c44198c4a475817); ctx->hash[0] += a; ctx->hash[1] += b; ctx->hash[2] += c; ctx->hash[3] += d; ctx->hash[4] += e; ctx->hash[5] += f; ctx->hash[6] += g; ctx->hash[7] += h; } } }