// Specify the residual. This is where the ODE system and boundary // conditions are specified. The solver will attempt to find a solution // x so that this function returns 0 for all n and j. virtual doublereal residual(doublereal* x, size_t n, size_t j) { // if n = 0, return the residual for the first ODE if (n == 0) { if (isLeft(j)) { // here we specify zeta(0) = 0 return zeta(x,j); } else // this implements d(zeta)/dz = u { return (zeta(x,j) - zeta(x,j-1))/(z(j)-z(j-1)) - u(x,j); } } // if n = 1, then return the residual for the second ODE else { if (isLeft(j)) { // here we specify u(0) = 0 return u(x,j); } else if (isRight(j)) { // and here we specify u(L) = 1 return u(x,j) - 1.0; } else // this implements the 2nd ODE { return cdif2(x,1,j) + 0.5*zeta(x,j)*centralFirstDeriv(x,1,j); } } }
void YCSBQueryGenerator::init() { mrand = (myrand *) mem_allocator.alloc(sizeof(myrand)); mrand->init(get_sys_clock()); if (SKEW_METHOD == ZIPF) { zeta_2_theta = zeta(2, g_zipf_theta); uint64_t table_size = g_synth_table_size / g_part_cnt; the_n = table_size - 1; denom = zeta(the_n, g_zipf_theta); } }
static ex zeta1_evalf(const ex& x, PyObject* parent) { /* if (is_exactly_a<lst>(x) && (x.nops()>1)) { // multiple zeta value const int count = x.nops(); const lst& xlst = ex_to<lst>(x); std::vector<int> r(count); // check parameters and convert them auto it1 = xlst.begin(); auto it2 = r.begin(); do { if (!(*it1).info(info_flags::posint)) { return zeta(x).hold(); } *it2 = ex_to<numeric>(*it1).to_int(); it1++; it2++; } while (it2 != r.end()); // check for divergence if (r[0] == 1) { return zeta(x).hold(); } // decide on summation algorithm // this is still a bit clumsy int limit = 10; if ((r[0] < limit) || ((count > 3) && (r[1] < limit/2))) { return numeric(zeta_do_sum_Crandall(r)); } else { return numeric(zeta_do_sum_simple(r)); } }*/ // single zeta value if (x == 1) { return UnsignedInfinity; } else if (is_exactly_a<numeric>(x)) { try { return zeta(ex_to<numeric>(x.evalf(0, parent))); } catch (const dunno &e) { } } return zeta(x).hold(); }
void CurrentElem<real_num_mov>::PrintOrientation() const { const uint mesh_dim = _mesh.get_dim(); const uint el_nnodes = _el_conn.size(); std::vector<double> xi(mesh_dim,0.); std::vector<double> eta(mesh_dim,0.); std::vector<double> zeta(mesh_dim,0.); //TODO this should only be instantiated in the 3D case, in any case we avoid USING IT for (uint idim=0; idim< mesh_dim; idim++) { xi[idim] = _xx_nds[1+idim*el_nnodes]-_xx_nds[0+idim*el_nnodes]; //1-0 xi axis eta[idim] = _xx_nds[3+idim*el_nnodes]-_xx_nds[0+idim*el_nnodes]; //3-0 eta axis if ( mesh_dim == 3 ) zeta[idim] = _xx_nds[4+idim*el_nnodes]-_xx_nds[0+idim*el_nnodes]; //4-0 zeta axis } std::cout << "asse xi "; for (uint idim=0; idim< mesh_dim; idim++) std::cout << xi[idim] << " "; std::cout <<std::endl; std::cout << "asse eta "; for (uint idim=0; idim< mesh_dim; idim++) std::cout << eta[idim] << " "; std::cout <<std::endl; if ( mesh_dim == 3 ) { std::cout << "asse zeta "; for (uint idim=0; idim< mesh_dim; idim++) std::cout << zeta[idim] << " "; std::cout <<std::endl; } return; }
Partition ClusteringProjector::projectCoarseGraphToFinestClustering(const Graph& Gcoarse, const Graph& Gfinest, const std::vector<std::vector<node> >& maps) { Partition zeta(Gfinest.upperNodeIdBound()); zeta.setUpperBound(Gcoarse.upperNodeIdBound()); // store temporarily coarsest supernode here std::vector<node> super(Gfinest.upperNodeIdBound()); // initialize to identity Gfinest.parallelForNodes([&](node v){ super[v] = v; }); // find coarsest supernode for each node for (auto iter = maps.begin(); iter != maps.end(); ++iter) { Gfinest.parallelForNodes([&](node v){ super[v] = (* iter)[super[v]]; }); } // assign super node id as cluster id Gfinest.parallelForNodes([&](node v) { //zeta.addToSubset(super[v],v); zeta[v] = super[v]; }); DEBUG("number of clusters in projected clustering: " , zeta.numberOfSubsets()); DEBUG("number of nodes in coarse graph: " , Gcoarse.numberOfNodes()); assert (zeta.numberOfSubsets() == Gcoarse.numberOfNodes()); return zeta; }
TEST_F(OverlapGTest, testHashingOverlapperForCorrectness) { count n = 4; Graph G(n); Partition zeta(n); Partition eta(n); zeta.setUpperBound(2); zeta[0] = 0; zeta[1] = 0; zeta[2] = 1; zeta[3] = 1; eta.setUpperBound(2); eta[0] = 0; eta[1] = 1; eta[2] = 0; eta[3] = 1; std::vector<Partition> clusterings = {zeta, eta}; HashingOverlapper overlapper; Partition overlap = overlapper.run(G, clusterings); INFO("overlap clustering number of clusters: ", overlap.numberOfSubsets()); INFO("overlap clustering: ", overlap.getVector()); }
void ycsb_query::calculateDenom() { assert(the_n == 0); uint64_t table_size = g_synth_table_size / g_virtual_part_cnt; the_n = table_size - 1; denom = zeta(the_n, g_zipf_theta); }
void ycsb_query::init(uint64_t thd_id, workload * h_wl) { // mrand = (myrand *) mem_allocator.alloc(sizeof(myrand), thd_id); // mrand->init(thd_id); // cout << g_req_per_query << endl; requests = (ycsb_request *) mem_allocator.alloc(sizeof(ycsb_request) * g_req_per_query, thd_id); part_to_access = (uint64_t *) mem_allocator.alloc(sizeof(uint64_t) * g_part_per_txn, thd_id); zeta_2_theta = zeta(2, g_zipf_theta); if (the_n == 0) { //uint64_t table_size = g_synth_table_size / g_part_cnt; uint64_t table_size = g_synth_table_size / g_virtual_part_cnt; the_n = table_size - 1; denom = zeta(the_n, g_zipf_theta); } gen_requests(thd_id, h_wl); }
static ex zeta2_eval(const ex& m, const ex& s_) { if (is_exactly_a<lst>(s_)) { const lst& s = ex_to<lst>(s_); for (const auto & elem : s) { if ((elem).info(info_flags::positive)) { continue; } return zeta(m, s_).hold(); } return zeta(m); } else if (s_.info(info_flags::positive)) { return zeta(m); } return zeta(m, s_).hold(); }
static ex zetaderiv_eval(const ex & n, const ex & x) { if (n.info(info_flags::numeric)) { // zetaderiv(0,x) -> zeta(x) if (n.is_zero()) return zeta(x).hold(); } return zetaderiv(n, x).hold(); }
void ycsb_query::init(uint64_t thd_id, workload * h_wl, Query_thd * query_thd) { _query_thd = query_thd; requests = (ycsb_request *) mem_allocator.alloc(sizeof(ycsb_request) * g_req_per_query, thd_id); part_to_access = (uint64_t *) mem_allocator.alloc(sizeof(uint64_t) * g_part_per_txn, thd_id); zeta_2_theta = zeta(2, g_zipf_theta); assert(the_n != 0); assert(denom != 0); gen_requests(thd_id, h_wl); }
static ex zeta1_eval(const ex& m) { if (is_exactly_a<lst>(m)) { if (m.nops() == 1) { return zeta(m.op(0)); } return zeta(m).hold(); } if (m.info(info_flags::numeric)) { const numeric& y = ex_to<numeric>(m); // trap integer arguments: if (y.is_integer()) { if (y.is_zero()) { return _ex_1_2; } if (y.is_equal(*_num1_p)) { //return zeta(m).hold(); return UnsignedInfinity; } if (y.info(info_flags::posint)) { if (y.info(info_flags::odd)) { return zeta(m).hold(); } else { return abs(bernoulli(y)) * pow(Pi, y) * pow(*_num2_p, y-(*_num1_p)) / factorial(y); } } else { if (y.info(info_flags::odd)) { return -bernoulli((*_num1_p)-y) / ((*_num1_p)-y); } else { return _ex0; } } } // zeta(float) if (y.info(info_flags::numeric) && !y.info(info_flags::crational)) { return zeta(y); // y is numeric } } return zeta(m).hold(); }
struct GenInfo * generator_new_zipfian(const uint64_t min, const uint64_t max) { struct GenInfo * const gi = (typeof(gi))malloc(sizeof(*gi)); struct GenInfo_Zipfian * const gz = &(gi->gen.zipfian); const uint64_t items = max - min + 1; gz->nr_items = items; gz->base = min; gz->zipfian_constant = ZIPFIAN_CONSTANT; gz->theta = ZIPFIAN_CONSTANT; gz->zeta2theta = zeta(2, ZIPFIAN_CONSTANT); gz->alpha = 1.0 / (1.0 - ZIPFIAN_CONSTANT); double zetan = zeta(items, ZIPFIAN_CONSTANT); gz->zetan = zetan; gz->eta = (1.0 - pow(2.0 / (double)items, 1.0 - ZIPFIAN_CONSTANT)) / (1.0 - (gz->zeta2theta / zetan)); gz->countforzeta = items; gz->min = min; gz->max = max; gi->type = GEN_ZIPFIAN; gi->next = gen_zipfian; return gi; }
Partition ClusteringGenerator::makeRandomClustering(Graph& G, count k) { count n = G.upperNodeIdBound(); Partition zeta(n); zeta.setUpperBound(k); G.parallelForNodes([&](node v) { index c = Aux::Random::integer(k-1); zeta.addToSubset(c, v); }); if (zeta.numberOfSubsets() != k) { WARN("random clustering does not contain k=",k," cluster: ",zeta.numberOfSubsets()); } assert (GraphClusteringTools::isProperClustering(G, zeta)); return zeta; }
static ex zeta2_evalf(const ex& x, const ex& s, PyObject* parent) { /* if (is_exactly_a<lst>(x)) { // alternating Euler sum const int count = x.nops(); const lst& xlst = ex_to<lst>(x); const lst& slst = ex_to<lst>(s); std::vector<int> xi(count); std::vector<int> si(count); // check parameters and convert them auto it_xread = xlst.begin(); auto it_sread = slst.begin(); auto it_xwrite = xi.begin(); auto it_swrite = si.begin(); do { if (!(*it_xread).info(info_flags::posint)) { return zeta(x, s).hold(); } *it_xwrite = ex_to<numeric>(*it_xread).to_int(); if (*it_sread > 0) { *it_swrite = 1; } else { *it_swrite = -1; } it_xread++; it_sread++; it_xwrite++; it_swrite++; } while (it_xwrite != xi.end()); // check for divergence if ((xi[0] == 1) && (si[0] == 1)) { return zeta(x, s).hold(); } // use Hoelder convolution return numeric(zeta_do_Hoelder_convolution(xi, si)); }*/ return zeta(x, s).hold(); }
/* Compute lgam(x + 1) around x = 0 using its Taylor series. */ double lgam1p_taylor(double x) { int n; double xfac, coeff, res; if (x == 0) { return 0; } res = -CEPHES_EULER * x; xfac = -x; for (n = 2; n < 42; n++) { xfac *= -x; coeff = zeta(n, 1) * xfac / n; res += coeff; if (fabs(coeff) < MACHEP * fabs(res)) { break; } } return res; }
int main() { // alpha should propagate the error from epsilon xapi exit = zeta(); assert_eq_exit(TEST_ERROR_ONE, exit); assert_eq_d(0, alpha_dead); assert_eq_d(1, beta_count); assert_eq_d(1, delta_count); assert_eq_d(1, epsilon_count); // lambda has a subsequence rooted at frame 0 exit = lambda(); assert_eq_exit(TEST_ERROR_ONE, exit); assert_eq_d(1, fi_live); assert_eq_d(0, fi_dead); assert_eq_d(1, lambda_live_one); assert_eq_d(0, lambda_dead_one); assert_eq_d(1, lambda_live_two); assert_eq_d(0, lambda_dead_two); succeed; }
static void prix_en_0_ls(double *res_prix, PnlMat *asset, int M, int N, int N_trading, double spot, double T, param *P, PnlBasis *basis) { PnlMat *V, *res_beta, *res_no_call; PnlMatInt *H, *mod_H; PnlVectInt *res_zeta, *res_tau,*res_theta; PnlVect *tmp_prix; int j, i, zeta_j, tau_j, theta_j; double sprix,s; double h=T/N; //initialisation V=pnl_mat_new(); res_no_call=pnl_mat_new(); res_beta=pnl_mat_new(); res_zeta=pnl_vect_int_new(); res_theta=pnl_vect_int_new(); res_tau=pnl_vect_int_new(); tmp_prix=pnl_vect_create(M); H=pnl_mat_int_new(); mod_H=pnl_mat_int_new(); //calcul du vecteur H calcul_H(H,asset,M,N,N_trading,spot,P); calcul_mod_H(mod_H,H,M,N,N_trading,P); //calcul du vecteur theta theta(res_theta,mod_H,M,N,N_trading,P); //calcul du prix_no_call protection prix_no_call(res_no_call,M,N,asset,spot,T,P,basis); //calcul du prix standard protection prix(V,res_no_call,M,N,asset,res_theta,spot,T,P,basis); //calcul de tau, zeta et beta tau(res_tau,M,N,V,asset,res_theta,P); zeta(res_zeta,res_tau,res_theta); beta(res_beta,spot,asset,T,N,P); //calcul de la somme Monte Carlo for(j=0;j<M;j++) { s=0; tau_j=pnl_vect_int_get(res_tau,j); theta_j=pnl_vect_int_get(res_theta,j); zeta_j=pnl_vect_int_get(res_zeta,j); if(tau_j<theta_j) { pnl_vect_set(tmp_prix,j,pnl_mat_get(res_beta,zeta_j,j)*low(pnl_mat_get(asset,tau_j,j),P)); } else { pnl_vect_set(tmp_prix,j,pnl_mat_get(res_beta,zeta_j,j)*pnl_mat_get(res_no_call,theta_j,j)); } for(i=1;i<=zeta_j;i++) s=s+h*pnl_mat_get(res_beta,i,j)*c(pnl_mat_get(asset,i,j),spot,P); pnl_vect_set(tmp_prix,j,pnl_vect_get(tmp_prix,j)+s); } sprix=pnl_vect_sum(tmp_prix); pnl_mat_free(&V); pnl_mat_free(&res_beta); pnl_mat_int_free(&H); pnl_mat_int_free(&mod_H); pnl_vect_int_free(&res_zeta); pnl_vect_int_free(&res_tau); pnl_vect_int_free(&res_theta); pnl_vect_free(&tmp_prix); *res_prix=sprix/M; }
void PseudoBlockStochasticCGIter<ScalarType,MV,OP>::iterate() { // // Allocate/initialize data structures // if (initialized_ == false) { initialize(); } // Allocate memory for scalars. int i=0; std::vector<int> index(1); std::vector<ScalarType> rHz( numRHS_ ), rHz_old( numRHS_ ), pAp( numRHS_ ); Teuchos::SerialDenseMatrix<int, ScalarType> alpha( numRHS_,numRHS_ ), beta( numRHS_,numRHS_ ), zeta(numRHS_,numRHS_); // Create convenience variables for zero and one. const ScalarType one = Teuchos::ScalarTraits<ScalarType>::one(); const MagnitudeType zero = Teuchos::ScalarTraits<MagnitudeType>::zero(); // Get the current solution std::vector. Teuchos::RCP<MV> cur_soln_vec = lp_->getCurrLHSVec(); // Compute first <r,z> a.k.a. rHz MVT::MvDot( *R_, *Z_, rHz ); if ( assertPositiveDefiniteness_ ) for (i=0; i<numRHS_; ++i) TEUCHOS_TEST_FOR_EXCEPTION( SCT::real(rHz[i]) < zero, CGIterateFailure, "Belos::PseudoBlockStochasticCGIter::iterate(): negative value for r^H*M*r encountered!" ); //////////////////////////////////////////////////////////////// // Iterate until the status test tells us to stop. // while (stest_->checkStatus(this) != Passed) { // Increment the iteration iter_++; // Multiply the current direction std::vector by A and store in AP_ lp_->applyOp( *P_, *AP_ ); // Compute alpha := <R_,Z_> / <P_,AP_> MVT::MvDot( *P_, *AP_, pAp ); for (i=0; i<numRHS_; ++i) { if ( assertPositiveDefiniteness_ ) // Check that pAp[i] is a positive number! TEUCHOS_TEST_FOR_EXCEPTION( SCT::real(pAp[i]) <= zero, CGIterateFailure, "Belos::PseudoBlockStochasticCGIter::iterate(): non-positive value for p^H*A*p encountered!" ); alpha(i,i) = rHz[i] / pAp[i]; // Compute the scaling parameter for the stochastic vector ScalarType z = normal(); zeta(i,i) = z / Teuchos::ScalarTraits<ScalarType>::squareroot(pAp[i]); } // // Update the solution std::vector x := x + alpha * P_ // MVT::MvTimesMatAddMv( one, *P_, alpha, one, *cur_soln_vec ); lp_->updateSolution(); // Updates the stochastic vector y := y + zeta * P_ MVT::MvTimesMatAddMv( one, *P_, zeta, one, *Y_); // // Save the denominator of beta before residual is updated [ old <R_, Z_> ] // for (i=0; i<numRHS_; ++i) { rHz_old[i] = rHz[i]; } // // Compute the new residual R_ := R_ - alpha * AP_ // MVT::MvTimesMatAddMv( -one, *AP_, alpha, one, *R_ ); // // Compute beta := [ new <R_, Z_> ] / [ old <R_, Z_> ], // and the new direction std::vector p. // if ( lp_->getLeftPrec() != Teuchos::null ) { lp_->applyLeftPrec( *R_, *Z_ ); if ( lp_->getRightPrec() != Teuchos::null ) { Teuchos::RCP<MV> tmp = MVT::Clone( *Z_, numRHS_ ); lp_->applyRightPrec( *Z_, *tmp ); Z_ = tmp; } } else if ( lp_->getRightPrec() != Teuchos::null ) { lp_->applyRightPrec( *R_, *Z_ ); } else { Z_ = R_; } // MVT::MvDot( *R_, *Z_, rHz ); if ( assertPositiveDefiniteness_ ) for (i=0; i<numRHS_; ++i) TEUCHOS_TEST_FOR_EXCEPTION( SCT::real(rHz[i]) < zero, CGIterateFailure, "Belos::PseudoBlockStochasticCGIter::iterate(): negative value for r^H*M*r encountered!" ); // // Update the search directions. for (i=0; i<numRHS_; ++i) { beta(i,i) = rHz[i] / rHz_old[i]; index[0] = i; Teuchos::RCP<const MV> Z_i = MVT::CloneView( *Z_, index ); Teuchos::RCP<MV> P_i = MVT::CloneViewNonConst( *P_, index ); MVT::MvAddMv( one, *Z_i, beta(i,i), *P_i, *P_i ); } // } // end while (sTest_->checkStatus(this) != Passed) }
void mlalign_TKF91(mlalign_Nucleotide *as, size_t na, mlalign_Nucleotide *bs, size_t nb, double lambda, double mu, double tau, double pi[mlalign_NUMBER_OF_BASES], mlalign_Site *alignment, size_t *n, double *score) { /***********************/ /* initialize matrices */ /***********************/ size_t rows = na + 1; size_t cols = nb + 1; auto idxM = diagonalizedIndexer(rows, cols, VECSIZE); auto idxA = identityIndexer(na); auto idxB = identityIndexer(nb); auto idxP1 = identityIndexer(mlalign_NUMBER_OF_BASES); auto idxP2 = rowMajorIndexer(mlalign_NUMBER_OF_BASES, mlalign_NUMBER_OF_BASES); auto idx2 = identityIndexer(2); // Allocate enough bytes for the matrices and properly align that. // We won't use vector because // 1) it initializes every element to 0 // 2) has some extra payload we won't need (e.g. capacity and size for bounds checks) // 3) we don't resize const size_t doubles_per_matrix = to_next_multiple(idxM(rows - 1, cols - 1) + 1, VECSIZE); std::unique_ptr<double[]> buffer(new double[3 * doubles_per_matrix + VECSIZE]); auto M0 = reinterpret_cast<double*>( to_next_multiple( reinterpret_cast<size_t>(buffer.get()), VECSIZE * sizeof(double))); auto M1 = M0 + doubles_per_matrix; auto M2 = M1 + doubles_per_matrix; assert(M0 - buffer.get() < static_cast<std::ptrdiff_t>(VECSIZE)); // // Memoization // const double beta = (1 - std::exp((lambda - mu) * tau)) / (mu - lambda * std::exp((lambda - mu) * tau)); const double delta = 1 / (1 - pi[0] * pi[0] - pi[1] * pi[1] - pi[2] * pi[2] - pi[3] * pi[3]); const double lambda_div_mu = lambda / mu; const double lambda_mul_beta = lambda * beta; double p_desc_1 = p_desc(1, beta, lambda, mu, tau); double M0_factor[mlalign_NUMBER_OF_BASES]; double M1_factor[mlalign_NUMBER_OF_BASES * mlalign_NUMBER_OF_BASES]; double M2_factor[mlalign_NUMBER_OF_BASES]; double p_desc_inv_n[2]; for (size_t i = 0; i < 2; ++i) { p_desc_inv_n[idx2(i)] = p_desc_inv(i, beta, lambda, mu, tau); } for (size_t i = 0; i < mlalign_NUMBER_OF_BASES; ++i) { const auto a = static_cast<mlalign_Nucleotide>(i); M0_factor[idxP1(a)] = std::log(lambda_div_mu * pi[idxP1(a)] * p_desc_inv_n[idx2(0)]); } for (size_t i = 0; i < mlalign_NUMBER_OF_BASES; ++i) { for (size_t j = 0; j < mlalign_NUMBER_OF_BASES; ++j) { const auto a = static_cast<mlalign_Nucleotide>(i); const auto b = static_cast<mlalign_Nucleotide>(j); M1_factor[idxP2(a, b)] = std::log(lambda_div_mu * pi[idxP1(a)] * std::max(p_trans(a, b, delta, pi, tau) * p_desc_1, pi[idxP1(b)] * p_desc_inv_n[idx2(1)])); } } for (size_t i = 0; i < mlalign_NUMBER_OF_BASES; ++i) { const auto b = static_cast<mlalign_Nucleotide>(i); M2_factor[idxP1(b)] = std::log(pi[idxP1(b)] * lambda_mul_beta); } size_t ix = idxM(0, 0); // We'll reuse ix throughout this function for caching idx calculations M0[ix] = -std::numeric_limits<double>::max(); M1[ix] = std::log(gamma2(0, lambda, mu) * zeta(1, beta, lambda)); M2[ix] = -std::numeric_limits<double>::max(); double accum = 0.0; for (size_t i = 1; i < rows; i++) { ix = idxM(i, 0); accum += std::log(pi[idxP1(as[idxA(i-1)])] * p_desc_inv_n[idx2(0)]); M0[ix] = std::log(gamma2(i, lambda, mu) * zeta(i, beta, lambda)) + accum; M1[ix] = -std::numeric_limits<double>::max(); M2[ix] = -std::numeric_limits<double>::max(); } accum = 0.0; for (size_t j = 1; j < cols; j++) { ix = idxM(0, j); accum += std::log(pi[idxP1(bs[idxB(j-1)])]); M0[ix] = -std::numeric_limits<double>::max(); M1[ix] = -std::numeric_limits<double>::max(); M2[ix] = std::log(gamma2(0, lambda, mu) * zeta(j + 1, beta, lambda)) + accum; } /****************/ /* DP algorithm */ /****************/ // TODO: Implement these in circular queues. size_t top[3] = { 0, 0, SIZE_MAX }; size_t bottom[3] { 1, 0, SIZE_MAX }; // This is tricky. We store the corrected offsets for diagonals offset -1 and -2 (7, 3 resp.) and the // uncorrected (e.g. not aligned) offset for the current diagonal (which is 7 + 2 = 9). // We inititialize with the values for diagonal 2, 1 and 0, we start at diagonal = 2 anyway. size_t diagonal_offsets[3] = { 2*VECSIZE + 1, 2*VECSIZE - 1, VECSIZE - 1 }; const size_t number_of_diagonals = rows + cols - 1; for (size_t diagonal = 2; diagonal < number_of_diagonals; ++diagonal) { // Topmost and bottommost row index of the diagonal, // skipping the already initialized first row and column (diagonal - 1 for that reason). // It's helpful for intuition to visualize this (rows=7, cols=6): // // 3 7 11 15 19 // 8 12 16 20 24 // 5 17 21 25 32 // 18 22 26 33 40 // 23 27 34 41 44 // 28 35 42 45 48 // 36 43 46 49 52 // // diagonal | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | // bottom_without_first | 1 | 2 | 3 | 4 | 5 | 6 | 6 | 6 | // top_without_first | 1 | 1 | 1 | 1 | 2 | 3 | 4 | 5 | // // We will then iterate over the diagonal through the indices // [top_without_first, bottom_without_first] inclusive. Column // indices are easily computed from the diagonal and row index. // We start with diagonal = 2, e.g. the third diagonal, because // it's the first containing uninitialized values. // const size_t bottom_without_first = std::min(diagonal - 1, rows - 1); const size_t top_without_first = diagonal - std::min(diagonal - 1, cols - 1); std::rotate(top, top + 2, top + 3); // This pushes all elements on further back std::rotate(bottom, bottom + 2, bottom + 3); bottom[0] = std::min(diagonal, rows - 1); top[0] = diagonal - std::min(diagonal, cols - 1); const size_t length_of_diagonal = bottom[0] + 1 - top[0]; // We have to correct the diagonal offset for the alignment rules layed out in diagonalizedIndexer. // 1. If the diagonal starts in the first row (top[0]=0), then the offset must have alignment -1. // 2. If the diagonal doesn't start in the first row, then the offset must have alignment 0. diagonal_offsets[0] += top[0] == 0 ? VECSIZE - 1 - diagonal_offsets[0] % VECSIZE : (VECSIZE - diagonal_offsets[0] % VECSIZE) % VECSIZE; assert((top[0] == 0 && diagonal_offsets[0] % VECSIZE == VECSIZE - 1) || (top[0] != 0 && diagonal_offsets[0] % VECSIZE == 0)); // INDEX EXPLANATIONS // row_offset offset of the row where the current SIMD vector begins // i index into the SIMD vector // col index of the column where the currently processed vector element is located in the DP matrix // row index of the row where the currently processed vector element is located in the DP matrix // Step in vector size over diagonal entries for (size_t row_offset = top_without_first; row_offset <= bottom_without_first; row_offset += VECSIZE) { // Copy the factors values from the lookuptable into the vector // Apparently it is not better to copy into temp memory and the use loaddvec, but it is faster to just use the [] operator. dvec factors[3]; for (size_t i = 0; i < VECSIZE; ++i) { const size_t row = row_offset + i; const size_t col = diagonal - row; if (row > bottom_without_first) { // We would load from somewhere out of the matrix, so we just leave the // other vector elements untouched break; } const mlalign_Nucleotide a = as[idxA(row - 1)]; const mlalign_Nucleotide b = bs[idxB(col - 1)]; factors[0][i] = M0_factor[idxP1(a)]; factors[1][i] = M1_factor[idxP2(a, b)]; factors[2][i] = M2_factor[idxP1(b)]; } // Compute the indexes of the top, left and top left cells and load them. const size_t ix_top = diagonal_offsets[1] + row_offset - 1 - top[1]; assert(ix_top == idxM(row_offset - 1, diagonal - row_offset)); const dvec max_top[3] = { loaddvec(M0 + ix_top), loaddvec(M1 + ix_top), loaddvec(M2 + ix_top), }; const size_t ix_topleft = diagonal_offsets[2] + row_offset - 1 - top[2]; assert(ix_topleft == idxM(row_offset - 1, diagonal - row_offset - 1)); const dvec max_topleft[3] = { loaddvec(M0 + ix_topleft), loaddvec(M1 + ix_topleft), loaddvec(M2 + ix_topleft), }; // Against all symmetry M0 isn't part of the formula. const size_t ix_left = ix_top + 1; assert(ix_left == idxM(row_offset, diagonal - row_offset - 1)); const dvec max_left[2] = { loaddvec(M1 + ix_left), loaddvec(M2 + ix_left), }; // Maxima for each cells on top/topleft/left of the calculated cell const dvec mt = maxdvec(max_top[0], maxdvec(max_top[1], max_top[2])); const dvec mtl = maxdvec(max_topleft[0], maxdvec(max_topleft[1], max_topleft[2])); const dvec ml = maxdvec(max_left[0], max_left[1]); // Vectorised add const dvec m0v = factors[0] + mt; const dvec m1v = factors[1] + mtl; const dvec m2v = factors[2] + ml; // Write back to matrix const size_t occupied_vector_elements = std::min(bottom_without_first + 1 - row_offset, VECSIZE); ix = diagonal_offsets[0] + row_offset - top[0]; assert(ix % VECSIZE == 0); assert(ix == idxM(row_offset, diagonal - row_offset)); storedvec(M0 + ix, m0v, occupied_vector_elements); storedvec(M1 + ix, m1v, occupied_vector_elements); storedvec(M2 + ix, m2v, occupied_vector_elements); } std::rotate(diagonal_offsets, diagonal_offsets + 2, diagonal_offsets + 3); diagonal_offsets[0] = diagonal_offsets[1] + length_of_diagonal; } /****************/ /* Backtracking */ /****************/ ix = idxM(na, nb); *n = 0; *score = std::exp(std::max({M0[ix], M1[ix], M2[ix]})); size_t cur = max_idx({M0[ix], M1[ix], M2[ix]}); for (size_t i = na, j = nb; i > 0 || j > 0;) { mlalign_Site site = {mlalign_Gap, mlalign_Gap}; switch (cur) { case 0: // insert assert(i > 0); site.a = as[--i]; site.b = mlalign_Gap; ix = idxM(i, j); cur = max_idx({M0[ix], M1[ix], M2[ix]}); break; case 1: // substitution assert(i > 0); assert(j > 0); site.a = as[--i]; site.b = bs[--j]; ix = idxM(i, j); cur = max_idx({M0[ix], M1[ix], M2[ix]}); break; case 2: // deletion assert(j > 0); site.a = mlalign_Gap; site.b = bs[--j]; ix = idxM(i, j); cur = max_idx({M1[ix], M2[ix]}) + 1; break; default: assert(0); } alignment[(*n)++] = site; // Doesn't get any scarier } // The alignment is reversed, so we have to undo that. for (size_t i = 0; i < (*n) / 2; ++i) { std::swap(alignment[i], alignment[*n - i - 1]); } }
void FULLCOND_rj_mix::update(void) { step_aborted = true; /********* in principle like FULLCOND_rj::rj_step, but now depending on the var_type functions of FULLCOND_rj or FULLCOND_rj_int are used **********************/ while (step_aborted==true) { // two variables are randomly chosen unsigned int i,j; i= rand() % nvar; j=i; while(i==j) j= rand() % nvar; // decide which kind of step (birth, death, switch) if (zeta(i,j) == 1) { if(preg_mods[j]->tell_var_type()=='d') { if(conditions == false) FULLCOND_rj_int::death_step(i,j); else if(conditions_okay_d(i,j) ==true) FULLCOND_rj_int::death_step(i,j); } else { if(conditions == false) FULLCOND_rj::death_step(i,j); else if(conditions_okay_d(i,j) ==true) FULLCOND_rj::death_step(i,j); } } else if (zeta(j,i)==1) { if(preg_mods[j]->tell_var_type()=='d' || preg_mods[i]->tell_var_type()=='d') { if(conditions == false) FULLCOND_rj_int::switch_step(i,j); else if(conditions_okay_s(i,j) ==true) { FULLCOND_rj_int::switch_step(i,j); //cout<<"s_int: "<<i<<" "<<j<<endl; } } else if(preg_mods[j]->tell_var_type()=='c' && preg_mods[i]->tell_var_type()=='c') { if(conditions == false) FULLCOND_rj::switch_step(i,j); else if(conditions_okay_s(i,j) ==true) FULLCOND_rj::switch_step(i,j); } } else { if(preg_mods[j]->tell_var_type()=='d') { if(conditions == false) FULLCOND_rj_int::birth_step(i,j); else if(conditions_okay_b(i,j) ==true) FULLCOND_rj_int::birth_step(i,j); } else { if(conditions == false) FULLCOND_rj::birth_step(i,j); else if(conditions_okay_b(i,j) ==true) FULLCOND_rj::birth_step(i,j); } } } /************* from this point on like in Fullcond_rj::update ***************/ nrtrials++; update_zeta(); //std::set < ST::string, unsigned int> freq; if((optionsp->get_nriter() > optionsp->get_burnin()) && (optionsp->get_nriter() % (optionsp->get_step()) == 0)) { store_model(); } }
Partition ClusteringGenerator::makeOneClustering(Graph& G) { count n = G.upperNodeIdBound(); Partition zeta(n); zeta.allToOnePartition(); return zeta; }
static ex Li2_series(const ex &x, const relational &rel, int order, unsigned options) { const ex x_pt = x.subs(rel, subs_options::no_pattern); if (x_pt.info(info_flags::numeric)) { // First special case: x==0 (derivatives have poles) if (x_pt.is_zero()) { // method: // The problem is that in d/dx Li2(x==0) == -log(1-x)/x we cannot // simply substitute x==0. The limit, however, exists: it is 1. // We also know all higher derivatives' limits: // (d/dx)^n Li2(x) == n!/n^2. // So the primitive series expansion is // Li2(x==0) == x + x^2/4 + x^3/9 + ... // and so on. // We first construct such a primitive series expansion manually in // a dummy symbol s and then insert the argument's series expansion // for s. Reexpanding the resulting series returns the desired // result. const symbol s; ex ser; // manually construct the primitive expansion for (int i=1; i<order; ++i) ser += pow(s,i) / pow(numeric(i), *_num2_p); // substitute the argument's series expansion ser = ser.subs(s==x.series(rel, order), subs_options::no_pattern); // maybe that was terminating, so add a proper order term epvector nseq { expair(Order(_ex1), order) }; ser += pseries(rel, std::move(nseq)); // reexpanding it will collapse the series again return ser.series(rel, order); // NB: Of course, this still does not allow us to compute anything // like sin(Li2(x)).series(x==0,2), since then this code here is // not reached and the derivative of sin(Li2(x)) doesn't allow the // substitution x==0. Probably limits *are* needed for the general // cases. In case L'Hospital's rule is implemented for limits and // basic::series() takes care of this, this whole block is probably // obsolete! } // second special case: x==1 (branch point) if (x_pt.is_equal(_ex1)) { // method: // construct series manually in a dummy symbol s const symbol s; ex ser = zeta(_ex2); // manually construct the primitive expansion for (int i=1; i<order; ++i) ser += pow(1-s,i) * (numeric(1,i)*(I*Pi+log(s-1)) - numeric(1,i*i)); // substitute the argument's series expansion ser = ser.subs(s==x.series(rel, order), subs_options::no_pattern); // maybe that was terminating, so add a proper order term epvector nseq { expair(Order(_ex1), order) }; ser += pseries(rel, std::move(nseq)); // reexpanding it will collapse the series again return ser.series(rel, order); } // third special case: x real, >=1 (branch cut) if (!(options & series_options::suppress_branchcut) && ex_to<numeric>(x_pt).is_real() && ex_to<numeric>(x_pt)>1) { // method: // This is the branch cut: assemble the primitive series manually // and then add the corresponding complex step function. const symbol &s = ex_to<symbol>(rel.lhs()); const ex point = rel.rhs(); const symbol foo; epvector seq; // zeroth order term: seq.push_back(expair(Li2(x_pt), _ex0)); // compute the intermediate terms: ex replarg = series(Li2(x), s==foo, order); for (size_t i=1; i<replarg.nops()-1; ++i) seq.push_back(expair((replarg.op(i)/power(s-foo,i)).series(foo==point,1,options).op(0).subs(foo==s, subs_options::no_pattern),i)); // append an order term: seq.push_back(expair(Order(_ex1), replarg.nops()-1)); return pseries(rel, std::move(seq)); } } // all other cases should be safe, by now: throw do_taylor(); // caught by function::series() }
int main(int argc, char* argv[]) { int program = 0; // Get input file from first command line argument if(argc < 3){ // No input file given std::cerr << "Usage: ./drudeh [input_file] [basis_file]\n"; program = -1; } else { std::string ifname = argv[1]; // Input filename std::string bfname = argv[2]; // Basis filename std::string ofname = ifname; // Output file prefix std::size_t pos = ofname.find('.'); if (pos != std::string::npos) { // Cut off extension ofname.erase(pos, ofname.length()); } ofname += ".output"; // Open the input file std::ifstream input(ifname); // Check it opened successfully if (!input.is_open()){ std::cerr << "Failed to open input file.\n"; program = -1; } else { // Declare and read parameters int N; std::vector<double> mu, omega, q; N = readParams(input, mu, omega, q); // Make the zeta vector std::vector<double> zeta(N); for (int i = 0; i < N; i++) zeta[i] = 0.5*mu[i]*omega[i]; // Geometry Eigen::MatrixXd R(N-1, 3); // Rewind input file input.clear(); input.seekg(0, std::ios::beg); // Read in geometry readGeom(input, R, N); // Open basis file std::ifstream basis(bfname); // Check if opened successfully if (!basis.is_open()){ std::cerr << "Failed to open basis file.\n"; program = -1; } else { // Initialise array of basis functions std::vector<BasisFunction> bfs; // Read in the basis functions int nbfs = readBasis(basis, bfs, N, zeta, R); // Form and diagonalise hamiltonian matrix Eigen::MatrixXd D = hamiltonian(N, nbfs, bfs, R, mu, omega, q); // Find lowest non-zero eigenvalue //int i = 0; double lowest_eig = D(0); // while ( D(i) < 0.1 ) i++; // if ( i < nbfs ) //lowest_eig = D(i); // Open output file std::ofstream output(ofname); if (!output.is_open()){ std::cout << "Couldn't open output file.\n"; std::cout << "Total number of basis functions = " << nbfs << "\n"; std::cout << "Lowest eigenvalue = " << std::setprecision(15) << lowest_eig << "\n"; } else { output << "Total number of basis functions = " << nbfs << "\n"; output << "Lowest eigenvalue = "<< std::setprecision(15) << lowest_eig << "\n"; } } } } return program; }
void Gauss_siedel(double *phi, double *mu, double *V) { long i, j, index, index_right, index_front, index_left, index_back; double V_old,A[MESHX*MESHY],B[MESHX*MESHY],C[MESHX*MESHY],E[MESHX*MESHY],F[MESHX*MESHY]; double error; double tol=1.0e-6; for(i=1; i < MESHX-1; i++) { for(j=1; j< MESHY-1; j++) { indx = i*MESHY + j; indx_rght = indx + 1; indx_frnt = indx + MESHY; indx_lft = indx - 1; indx_bck = indx - MESHY; A[index] = (zeta(phi[index_left]) + zeta(phi[index])); //left B[index] = (zeta(phi[index_right]) + zeta(phi[index])); //right C[index] = (zeta(phi[index_back]) + zeta(phi[index])); //back E[index] = (zeta(phi[index_front]) + zeta(phi[index])); //front F[index] = -(A[index] + B[index] + C[index] + E[index]); } } for(;;) { for(i=1; i < MESHX-1; i++) { for(j=1;j < MESHY-1;j++) { index = i*MESHY + j; index_right = index + 1; index_front = index + MESHY; index_left = index - 1; index_back = index - MESHY; if (((i+j)%2) == 0) { V_old = V[index]; V[index] = A[index]*V[index_left] + B[index]*V[index_right] + C[index]*V[index_back] + E[index]*V[index_front]; V[index] /= (-F[index]); } } } for(i=1; i < MESHX-1; i++) { for(j=1;j < MESHY-1; j++) { index = i*MESHY + j; index_right = index + 1; index_front = index + MESHY; index_left = index - 1; index_back = index - MESHY; if (((i+j)%2) != 0) { V_old = V[index]; V[index] = A[index]*V[index_left] + B[index]*V[index_right] + C[index]*V[index_back] + E[index]*V[index_front]; V[index] /= (-F[index]); } } } error = compute_error(A, B, C, E, F, V); if (fabs(error) < tol) { break; } } }