int CExpression::Value(double& valoare) { error_code=0; if (m_Arbore == NULL) return -1; valoare=vexp(m_Arbore); return (error_code); }
VN * IR_GVN::comp_sc_by_anon_domdef(IR const* exp, IR const* domdef, bool & change) { IS_TRUE0((IR_type(exp) == IR_LD || IR_type(exp) == IR_PR) && m_du->is_may_def(domdef, exp, false)); SCVNE2VN * vnexp_map = m_def2sctab.get(domdef); UINT dtsz = exp->get_dt_size(m_dm); MD const* md = exp->get_exact_ref(); IS_TRUE0(md); VNE_SC vexp(MD_id(md), exp->get_ofst(), dtsz); /* NOTE: foo(); v1; //s1 goo(); v1; //s2 vn of s1 should not same with s2. */ if (vnexp_map == NULL) { vnexp_map = new SCVNE2VN(m_pool, 16); //bsize to be evaluate. m_def2sctab.set(domdef, vnexp_map); } VN * vn = vnexp_map->get(&vexp); if (vn == NULL) { vn = new_vn(); VN_type(vn) = VN_VAR; vnexp_map->setv((OBJTY)&vexp, vn); } m_ir2vn.set(IR_id(exp), vn); change = true; return vn; }
//Compute VN for array according to anonymous domdef. VN * IR_GVN::comp_array_by_anon_domdef(IR const* arr, VN const* basevn, VN const* ofstvn, IR const* domdef, bool & change) { IS_TRUE0(IR_type(arr) == IR_ARRAY && m_du->is_may_def(domdef, arr, false)); ARR_VNE2VN * vnexp_map = m_def2arrtab.get(domdef); UINT dtsz = arr->get_dt_size(m_dm); VNE_ARR vexp(VN_id(basevn), VN_id(ofstvn), ARR_ofst(arr), dtsz); /* NOTE: foo(); array(v1); //s1 goo(); array(v1); //s2 vn of s1 should not same with s2. */ if (vnexp_map == NULL) { vnexp_map = new ARR_VNE2VN(m_pool, 16); //bsize to be evaluate. m_def2arrtab.set(domdef, vnexp_map); } VN * vn = vnexp_map->get(&vexp); if (vn == NULL) { vn = new_vn(); VN_type(vn) = VN_OP; VN_op(vn) = IR_ARRAY; vnexp_map->setv((OBJTY)&vexp, vn); } m_ir2vn.set(IR_id(arr), vn); change = true; return vn; }
//Compute VN for ild according to anonymous domdef. VN * IR_GVN::comp_ild_by_anon_domdef(IR const* ild, VN const* mlvn, IR const* domdef, bool & change) { IS_TRUE0(IR_type(ild) == IR_ILD && m_du->is_may_def(domdef, ild, false)); ILD_VNE2VN * vnexp_map = m_def2ildtab.get(domdef); UINT dtsz = ild->get_dt_size(m_dm); VNE_ILD vexp(VN_id(mlvn), ILD_ofst(ild), dtsz); /* NOTE: foo(); ild(v1); //s1 goo(); ild(v1); //s2 vn of s1 should not same with s2. */ if (vnexp_map == NULL) { vnexp_map = new ILD_VNE2VN(m_pool, 16); //bsize to be evaluate. m_def2ildtab.set(domdef, vnexp_map); } VN * ildvn = vnexp_map->get(&vexp); if (ildvn == NULL) { ildvn = new_vn(); VN_type(ildvn) = VN_OP; VN_op(ildvn) = IR_ILD; vnexp_map->setv((OBJTY)&vexp, ildvn); } m_ir2vn.set(IR_id(ild), ildvn); change = true; return ildvn; }
double binlogtail(int n, int t, double p, char c) { double *bindis ; double val, base ; ZALLOC(bindis, n+1, double) ; genlogbin(bindis, n, p) ; base = bindis[t] ; vsp(bindis, bindis, -base, n+1) ; if (c=='+') { vexp(bindis+t, bindis+t, n-t+1) ; val = asum(bindis+t, n-t+1) ; } else { vexp(bindis, bindis, t) ; val = asum(bindis, t) ; } free(bindis) ; return (log(val) + base) ; }
double binomtail(int n, int t, double p, char c) { /** c = '+': P(S>=t) c = '-': P(S<t) WARNING <= t use binomtail(n, t+1, ... */ double *bindis ; double val ; ZALLOC(bindis, n+1, double) ; genlogbin(bindis, n, p) ; vexp(bindis, bindis, n+1) ; if (c=='+') val = asum(bindis+t, n-t+1) ; else val = asum(bindis, t) ; free(bindis) ; return val ; }
int main() { double p, val ; int n, t, c, i ; char str[MAXS] ; char line[MAXS] ; char *spt[MAXFIELD] ; int nsplit ; double *a ; while (fgets(line,MAXS,stdin) != NULL) { nsplit = splitup(line, spt, MAXFIELD) ; n = atoi(spt[0]) ; p = atof(spt[1]) ; freeup(spt, nsplit) ; if ((p<=0.0) || (p>=1.0)) fatalx("bad line %s\n",line) ; ZALLOC(a, n+1, double) ; genlogbin(a, n, p) ; vexp(a, a, n+1) ; for (i=0; i<=n; i++) { printf("%3d %15.9f\n",i, a[i]) ; } } }
bool MeshKD::loadObjFromFile ( std::string filename ) { std::vector<Vector3> vectorVector; // SCNR std::vector<Vector3> normalVector; std::cout << "reading " << filename << std::endl; std::ifstream file ( filename.c_str() ); if ( !file.is_open() ) { std::cerr << "Couldn't load mesh " << filename << std::endl; return false; } //build regexes boost::regex vexp ( "^v\\s+(.*?)\\s+(.*?)\\s+(.*?)$" ); boost::regex fexp ( "^f\\s+(.*?)\\s+(.*?)\\s+(.*?)$" ); boost::cmatch match; char line[1024]; while ( !file.eof() ) { file.getline ( line,1024 ); // std::cout << line << std::endl; if ( boost::regex_match ( line, match, vexp ) ) { Vector3 v = Vector3 ( boost::lexical_cast<double> ( match[1] ), boost::lexical_cast<double> ( match[2] ), boost::lexical_cast<double> ( match[3] ) ); vectorVector.push_back ( v ); } else if ( boost::regex_match ( line, match, fexp ) ) { Vector3 a, b, c; int vectorSize = vectorVector.size(); if ( boost::lexical_cast<int> ( match[1] ) < 0 ) a = vectorVector[vectorSize + boost::lexical_cast<int> ( match[1] ) ]; if ( boost::lexical_cast<int> ( match[1] ) > 0 ) a = vectorVector[boost::lexical_cast<int> ( match[1] )-1]; if ( boost::lexical_cast<int> ( match[2] ) < 0 ) b = vectorVector[vectorSize + boost::lexical_cast<int> ( match[2] ) ]; if ( boost::lexical_cast<int> ( match[2] ) > 0 ) b = vectorVector[boost::lexical_cast<int> ( match[2] )-1]; if ( boost::lexical_cast<int> ( match[3] ) < 0 ) c = vectorVector[vectorSize + boost::lexical_cast<int> ( match[3] ) ]; if ( boost::lexical_cast<int> ( match[3] ) > 0 ) c = vectorVector[boost::lexical_cast<int> ( match[3] )-1]; tree.addMeshKDTriangle ( new MeshKDTriangle ( a,b,c ) ); } } /* std::cout << "Finished reading" << std::endl; std::cout << "Loaded " << ( unsigned int ) tris.size() << " faces" << std::endl; std::cout << "Building tree" << std::endl; std::cout << "Finished building tree" << std::endl; tris.dump(); oa <<const_cast<const OctreeNode&> ( tris );*/ this->boundingBoxComputed = true; std::cout << "Building tree" << std::endl; tree.build ( AXIS_X ); std::cout << "Finished building tree" << std::endl; std::cout << "Tree countains " << tree.getMeshKDTriangleCount() << " tris" << std::endl; return true; }
double CExpression::vexp ( arbore a ) { double v; SYSTEMTIME tm; GetSystemTime(&tm); if (a->operatie==NULL) {error_code=10;return 0;} switch(a->operatie){ case '+' : return( vexp(a->left)+vexp(a->right) ); case '-' : return( vexp(a->left)-vexp(a->right) ); case '*' : return( vexp(a->left)*vexp(a->right) ); case '%': { v = vexp(a->right); if(v == 0){ error_code = DIVISION_BY_0; return 0; } return (int)vexp(a->left) % (int)v; } case '/' : v=vexp(a->right) ; if (v==0){ error_code=DIVISION_BY_0; return -vexp(a->left)/0.001; }else{ return(vexp(a->left)/v); } case 150 : return(sin(vexp(a->left))); case 151 : return(cos(vexp(a->left))); case 152 : return(exp(vexp(a->left))); case 153 : v=vexp(a->left) ; if (v<0) {error_code=INVALID_DOMAIN;return 0;} else return(sqrt(v)); case 154 : v=vexp(a->left) ; if (v<=0) {error_code=INVALID_DOMAIN;return 0;} else return(log(v)); case 155 : return (tan (vexp(a->left))); case 156 : return (1 / tan (vexp(a->left))); case 157 : return (asin (vexp(a->left))); case 158 : return (acos (vexp(a->left))); case 159 : return (atan (vexp(a->left))); case 173 : return (fabs (vexp(a->left))); case 160 : return tm.wYear; case 161 : return tm.wMonth; case 162 : return tm.wDay; case 163 : return tm.wHour; case 164 : return tm.wMinute; case 165 : return tm.wSecond; case 166 : return max(vexp(a->left),vexp(a->right)); case 167 : return min(vexp(a->left),vexp(a->right)); case 168 : return rng_rand(0,RAND_MAX)*vexp(a->left)/RAND_MAX; //case '|' : return(fabs(vexp(a->left))); case '^' : return(pow(vexp(a->left),vexp(a->right))); case '@' : return (a->valoare); //logical operations evaluation case '<' : return( vexp(a->left) < vexp(a->right) ); case '>' : return( vexp(a->left) > vexp(a->right) ); case '!' : return(!vexp(a->right)) ; // added by chenj, @2008-5-22 case '=' : return( vexp(a->left) == vexp(a->right) ); case '&' : return (int)(vexp(a->left)) & (int)(vexp(a->right)); case '|' : return (int)(vexp(a->left)) | (int)(vexp(a->right)); case 169: { RTK_TIME t; rtk_time_mark(&t); return (double)(__int64)t.Data / 1e7; } case 170: { /* last update time */ PRTK_TAG tte; __r8 retval = 0; tte = (PRTK_TAG)a->left->pvObj; if(!tte){ error_code=UNDEFINED_VARIABLE; retval = 0; }else{ if(!(tte->d.Value.Flags & TF_Valid)){ error_code=UNDEFINED_VARIABLE; retval = 0; }else{ PRTK_TIME pTime = (PRTK_TIME)&tte->d.BinaryAddress[8]; retval = (double)(__int64)pTime->Data / 1e7; rtk_time_mark(pTime); } } return retval; } case 171 : { // a database tag PRTK_TAG tte; __r8 retval = 0; tte = (PRTK_TAG)a->pvObj; if(!tte){ error_code=UNDEFINED_VARIABLE; retval = 0; }else{ if(!(tte->d.Value.Flags & TF_Valid)){ error_code=UNDEFINED_VARIABLE; retval = 0; }else{ pmc_value_t dblVal; set_value_type(dblVal.Flags, dt_real8); pmc_type_cast(&tte->d.Value, &dblVal); retval = dblVal.Value.dbl; } } return retval; } case 172: { /* span time */ PRTK_TAG tte; RTK_TIME now; __r8 retval = 0; tte = (PRTK_TAG)a->left->pvObj; if(!tte){ error_code=UNDEFINED_VARIABLE; retval = 0; }else{ if(!(tte->d.Value.Flags & TF_Valid)){ error_code=UNDEFINED_VARIABLE; retval = 0; }else{ PRTK_TIME pTime = (PRTK_TIME)&(tte->d.BinaryAddress[8]); rtk_time_mark(&now); if(pTime->Data != 0){ /* yes, the field is previouly stored with a resonable value, thus valid for a sub-operation to get a duration time */ retval = rtk_time_diff(&now, pTime); }else{ /* this might be the first time that a time-span was requested for this tag */ retval = 0; } *pTime = now; } } return retval; } } return 0; }
void shr_vmath_fwrap_vexp_(double *X, double *Y, int *n) { vexp(X, Y, *n, 1, 1); }
static void adjust_icalls_eprob(const blt_options& opt, dependent_prob_cache& dpc, icalls_t& ic, const snp_pos_info& pi, std::vector<float>& dependent_eprob) { const unsigned ic_size(ic.size()); #ifdef DEBUG_ADJUST for (unsigned i(0); i<ic_size; ++i) { base_call& bi(pi.calls[ic[i]]); std::cerr << "BEFORE: " << i << " " << bi.is_neighbor_mismatch << " " << dependent_eprob[ic[i]] << "\n"; } #endif static const bool is_use_vexp_frac(true); // produce weighted fraction of reads with a neighboring mismatch: blt_float_t vexp_frac(opt.bsnp_ssd_no_mismatch); if (is_use_vexp_frac) { static const blt_float_t lnran(std::log(0.75)); blt_float_t num(0); blt_float_t den(0); for (unsigned i(0); i<ic_size; ++i) { const base_call& bi(pi.calls[ic[i]]); // const blt_float_t eprob(dependent_eprob[ic[i]]); const blt_float_t weight(lnran-bi.ln_error_prob()); den += weight; if (bi.is_neighbor_mismatch) { num += weight; } } blt_float_t mismatch_frac(0); if (ic_size && (den>0.)) mismatch_frac=(num/den); vexp_frac=(1.-mismatch_frac)*opt.bsnp_ssd_no_mismatch+mismatch_frac*opt.bsnp_ssd_one_mismatch; } const bool is_limit_vexp_iterations(opt.max_vexp_iterations>0); const int max_vexp_iterations(opt.max_vexp_iterations); const bool is_limit_vexp(opt.is_min_vexp); const blt_float_t min_vexp(opt.min_vexp); // used cached dependent probs once we reach the min_vexp level: bool is_min_vexp(false); std::sort(ic.begin(),ic.end(),sort_icall_by_eprob(pi)); blt_float_t vexp(1.); for (unsigned i(0); i<ic_size; ++i) { const base_call& bi(pi.calls[ic[i]]); if (! is_min_vexp) { dependent_eprob[ic[i]] = static_cast<float>(get_dependent_eprob(bi.get_qscore(),vexp)); if (is_limit_vexp_iterations && (static_cast<int>(i)>=max_vexp_iterations)) continue; blt_float_t next_vexp(vexp); if (is_use_vexp_frac) { next_vexp *= (1.-vexp_frac); } else { if (bi.is_neighbor_mismatch) { next_vexp *= (1.-opt.bsnp_ssd_one_mismatch); } else { next_vexp *= (1.-opt.bsnp_ssd_no_mismatch); } } if (is_limit_vexp) { is_min_vexp=(next_vexp<=min_vexp); vexp = std::max(min_vexp,next_vexp); } else { vexp = next_vexp; } } else { // cached version: dependent_eprob[ic[i]] = static_cast<float>(dpc.get_dependent_val(bi.get_qscore(),vexp)); } } #ifdef DEBUG_ADJUST for (unsigned i(0); i<ic_size; ++i) { base_call& bi(pi.calls[ic[i]]); std::cerr << "AFTER: " << i << " " << bi.is_neighbor_mismatch << " " << dependent_eprob[ic[i]] << "\n"; } #endif }
namespace test { template <class T> struct b { b(){} ~b(){} inline string& p() { return static_cast<T*>(this)->v; } }; #define perm(x,y,z) template <> struct n <x,y,z> : b< n<x,y,x> > #define vexp(x,y,z) string v; n():v("n " #x #y #z){} template <op T0, op T1, op T2> struct n : b< n<T0 , T1 , T2 > > {string v; n():v("n ___"){}}; template < op T1, op T2> struct n <X, T1, T2> : b< n<X, T1, T2> > {string v; n():v("n X__"){}}; template < op T1, op T2> struct n <A, T1, T2> : b< n<A, T1, T2> > {string v; n():v("n A__"){}}; template < op T1, op T2> struct n <O, T1, T2> : b< n<O, T1, T2> > {string v; n():v("n O__"){}}; // two operator boperator cases here perm(X,O,D) { vexp(X,O,D) }; perm(X,A,D) { vexp(X,A,D) }; perm(X,X,D) { vexp(X,X,D) }; perm(X,N,D) { vexp(X,N,D) }; perm(A,O,D) { vexp(A,O,D) }; perm(A,A,D) { vexp(A,A,D) }; perm(A,X,D) { vexp(A,X,D) }; perm(A,N,D) { vexp(A,N,D) }; perm(O,O,D) { vexp(O,O,D) }; perm(O,A,D) { vexp(O,A,D) }; perm(O,X,D) { vexp(O,X,D) }; perm(O,N,D) { vexp(O,N,D) }; perm(O,D,D) { vexp(O,D,D) }; perm(A,D,D) { vexp(A,D,D) }; perm(X,D,D) { vexp(X,D,D) }; perm(N,O,E) { vexp(N,O,E) }; perm(N,A,E) { vexp(N,A,E) }; perm(N,X,E) { vexp(N,X,E) }; perm(N,N,E) { vexp(N,N,E) }; perm(N,D,E) { vexp(N,D,E) }; }