floating_t Pyramid::calculate_link(const Node& node, const Node& desc, spectral_distance_meassure_t spec_dst) const { using std::exp; using std::isfinite; using std::isinf; if (link(node, desc) == 0.l /* || 1./util::condition(value2(desc)) < 1e-6*/) { return 0.l; } const auto beta_spec = -0.01; const auto beta_vari = -0.01; const auto beta_spat = -0.01; auto spec_term = exp(beta_spec * spec_dst(node, desc)); auto spat_term = exp(beta_spat * spatial_distance(node, desc)); auto vari_term = exp(beta_vari * var(desc)); auto result = spec_term * vari_term * spat_term; assert(isfinite(spec_term)); assert(isfinite(vari_term)); assert(isfinite(spat_term)); assert(isfinite(result)); return result; }
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::isfinite; if (isfinite(a) && isfinite(b)) return a + b; if (isfinite(a)) return a; if (isfinite(b)) return b; return a + b; }
/** * \brief TODO */ static double trunc_estim_param_bisec(const double mean, const double tol){ double lambda_low = mean-1; double lambda_high = mean; double lambda_mid = mean - 0.5; double diff = std::numeric_limits<double>::max(); double prev_val = std::numeric_limits<double>::max(); while(movement(lambda_high, lambda_low) > tol && diff > tol){ lambda_mid = (lambda_low + lambda_high)/2; const double mid_val = lambda_score_funct(mean, lambda_mid); if (mid_val < 0) lambda_low = lambda_mid; else lambda_high = lambda_mid; diff = fabs((prev_val - mid_val)/std::max(mid_val, prev_val)); prev_val = mid_val; } if (!(isfinite(lambda_mid))) { stringstream ss; ss << "Zero-truncated Poisson parameter estimation failed. Reason: " << "got non-finite value for lambda"; throw DistributionException(ss.str()); } return lambda_mid; }
T invoke(I& integrand, P const& point) { using std::isfinite; hep::projector<T> projector(this, point); // call the integrand function with the supplied point. Distributions // are generated here T value = integrand.function()(point, projector); if (value != T()) { value *= point.weight(); if (isfinite(value)) { accumulate(sums_[0], sums_[1], compensations_[0], value); ++finite_calls_[0]; } else { value = T(); } ++non_zero_calls_[0]; } return value; }
/** * \brief ZTP probability mass function in log space */ double ZeroTruncatedPoisson::loglikelihood(const double y) const { if (y==0) { stringstream ss; ss << "Zero-truncated Poisson log-likelihood calculation failed. Reason: " << "log-likelihood is undefined for response of 0"; throw DistributionException(ss.str()); } // we're going to cast y from double to size_t, but be careful doing it.. double intpart; if ((y < 0) || (!(modf(y, &intpart) == 0.0))) { stringstream ss; ss << "evaluating ZTNB PDF value at " << y << " failed. " << "Reason: " << y << " is not a non-negative integer"; throw DistributionException(ss.str()); } double res = (-this->lambda + (y*log(this->lambda)) - gsl_sf_lnfact(size_t(y))) - log(1-exp(-this->lambda)); if (!(isfinite(res))) { stringstream ss; ss << "Zero-truncated Poisson log-likelihood calculation failed. Reason: " << "got non-finite value for response of " << y << " with " << "distribution parameters of " << this->toString(); throw DistributionException(ss.str()); } return res; }
T invoke(I& integrand, P const& point) { using std::isfinite; // call the integrand function with the supplied point. No distributions // are generated here T value = integrand.function()(point); if (value != T()) { value *= point.weight(); if (isfinite(value)) { accumulate(sums_[0], sums_[1], sums_[2], value); ++finite_calls_; } else { value = T(); } ++non_zero_calls_; } return value; }
int luaV_tostring (lua_State *L, StkId obj) { if (!ttisnumber(obj)) return 0; else { char s[LUAI_MAXNUMBER2STR]; lua_Number n = nvalue(obj); // SPRING -- synced safety change // -- need a custom number formatter? if (isfinite(n)) { lua_number2str(s, n); } else { if (isnan(n)) { strcpy(s, "nan"); } else { const int inf_type = isinf(n); if (inf_type == 1) { strcpy(s, "+inf"); } else if (inf_type == -1) { strcpy(s, "-inf"); } else { strcpy(s, "weird_number"); } } } setsvalue2s(L, obj, luaS_new(L, s)); return 1; } }
void add_to_2d_distribution(std::size_t index, T x, T y, T value) { using std::isfinite; if (!isfinite(value)) { return; } // TODO: index might be larger than the than allowed; throw? auto const parameters = parameters_.at(index); T const shifted_x = x - parameters.x_min(); if (shifted_x < T()) { // point is outside the binning range return; } T const shifted_y = y - parameters.y_min(); if (shifted_y < T()) { // point is outside the binning range return; } std::size_t const bin_x = shifted_x / parameters.bin_size_x(); if (bin_x >= parameters.bins_x()) { // point is right of the range that we are binning return; } std::size_t const bin_y = shifted_y / parameters.bin_size_y(); if (bin_y >= parameters.bins_y()) { return; } std::size_t const new_index = indices_.at(index) + 2 * (bin_y * parameters.bins_x() + bin_x); accumulate( sums_.at(new_index), sums_.at(new_index + 1), compensations_.at(new_index / 2), value ); // FIXME: if this function is called more than once, the values are // incorrect ++non_zero_calls_.at(new_index / 2); ++finite_calls_.at(new_index / 2); }
void print_nonfinite(const FloatType& x, const Node& node, const Node& dst) { using namespace std; if (!isfinite(x)) { cerr << endl << util::RED << "Non-finite weight " << x << "\tfrom " << node << "\tto " << dst << util::RESET << flush; } }
void print_nonfinite(const FloatType& x, const Node& node) { using namespace std; if (!isfinite(x)) { cerr << endl << util::RED << "Non-finite element " << x << "\tat " << node << util::RESET << flush; } }
bool TestExpDalpha(const MatrixXd& expDalpha) { for (int j = 0; j < expDalpha.cols(); j++) { for (int i = 0; i < expDalpha.rows(); i++) { if (isfinite(expDalpha(i, j)) == 0) { return false; } } } return true; }
// check 3 term recurrence to avoid non-positive elements // truncate if non-positive element found static void check_three_term_relation(vector<double> &a, vector<double> &b){ // first entry is zero! Abort if(a[0] <= 0.0){ a.clear(); b.clear(); } for(size_t i = 0; i < b.size(); i++){ if(b[i] <= 0.0 || !isfinite(b[i]) || a[i + 1] <= 0.0 || !isfinite(a[i + 1])){ b.resize(i); a.resize(i + 1); break; } } }
/** * \brief randomize the parameters for this distribution. In the case of the * ZTP this just selects a random value for lambda between 0 and * MAX_RANDOM_LAMBDA */ void ZeroTruncatedPoisson::randomise() { this->lambda = (rand() / double(RAND_MAX)) * MAX_RANDOM_LAMBDA; if (!(isfinite(this->lambda))) { stringstream ss; ss << "Randomizing zero-truncated Poisson failed. Reason: " << "got non-finite value for lambda"; throw DistributionException(ss.str()); } }
void DPmatrix::compute_Pr_sum_all_paths() { const int I = size1()-1; const int J = size2()-1; double total = 0.0; for(int state1=0;state1<nstates();state1++) total += (*this)(I,J,state1)*GQ(state1,endstate()); Pr_total = pow(efloat_t(2.0),scale(I,J)) * total; assert(not isnan(log(Pr_total)) and isfinite(log(Pr_total))); }
void TestExpDalpha(const MatrixXd& D, MatrixXd& alpha, MatrixXd& expDalpha) { for (int j = 0; j < expDalpha.cols(); j++) { for (int i = 0; i < expDalpha.rows(); i++) { if (isfinite(expDalpha(i, j)) == 0 || expDalpha(i, j) > MAX_EXPDALPHA_VAL || expDalpha(i, j) <-MAX_EXPDALPHA_VAL) { alpha.block(0, j, alpha.rows(), 1).noalias() = MatrixXd::Zero(alpha.rows(), 1); expDalpha.block(0, j, expDalpha.rows(), 1).noalias() = MatrixXd::Identity(expDalpha.rows(), 1); break; } } } }
void ConvolvedSpikeTrain::UpdateExponentialVectors() { if (size > 0) { for (unsigned int i=0; i<size; ++i) { exp_pos[i] = exp((long double)(spikes[i]/tau)); exp_neg[i] = exp((long double)(-spikes[i]/tau)); } /* Check if any over/underflow occurred while calculating the * exponentials */ if (tau!=0 && (exp_neg.front()==0 || !isfinite(exp_pos.back()))) { throw overflow_error("tau is too small compared to the spike times. Please use a larger value for tau, or shorter spike trains."); } } }
void DPmatrixConstrained::compute_Pr_sum_all_paths() { const int I = size1()-1; const int J = size2()-1; double total = 0.0; for(int s1=0;s1<states(J).size();s1++) { int S1 = states(J)[s1]; total += (*this)(I,J,S1)*GQ(S1,endstate()); } Pr_total = pow(efloat_t(2.0),scale(I,J)) * total; assert(not isnan(log(Pr_total)) and isfinite(log(Pr_total))); }
bool Modification::isFinite() const { return isfinite(m_transform.sx) && isfinite(m_transform.shy) && isfinite(m_transform.shx) && isfinite(m_transform.sy) && isfinite(m_transform.tx) && isfinite(m_transform.ty); }
/**** * \brief Set the parameters for this zero-truncated Poisson distribution * \param params a vector with only a single value in it, which is the value * of lambda * \throws DistributionException if more than one value is given in params */ void ZeroTruncatedPoisson::setParams(const vector<double>& params) { if (params.size() != 1) { stringstream ss; ss << "Setting parameters for zero-truncated Poisson failed. Reason: " << "expected one parameters (lambda), but instead we got " << params.size() << " parameters"; throw DistributionException(ss.str()); } if (!(isfinite(params[0]))) { stringstream ss; ss << "Setting parameters for zero-truncated Poisson failed. Reason: " << "supplied parameter value for lambda was non-finite"; throw DistributionException(ss.str()); } this->lambda = params[0]; }
/** * \brief read this NegativeBinomial distribution from the provided XML object * \throws DistributionException if the XML object does not define the mean * and alpha tags * \todo throw exception if root tag is incorrectly named */ void ZeroTruncatedPoisson::load(const SimpleXML& xml) { vector<SimpleXML> meanX = xml.getChildren("lambda"); if (meanX.size() != 1) { stringstream ss; ss << "loading zero-truncated Poisson from XML object " << endl << xml.toString() << endl << " failed. Reason: expected a single child " << "tag of type <mean> -- didn't find it"; throw DistributionException(ss.str()); } std::stringstream ss1, ss2; ss1 << meanX[0].getData(); ss1 >> this->lambda; if (!(isfinite(this->lambda))) { stringstream ss; ss << "Loading zero-truncated Poisson failed. Reason: " << "got non-finite value for lambda"; throw DistributionException(ss.str()); } }
floating_t Pyramid::calculate_var(const Node& node, spectral_distance_meassure_t spec_dst) const { using accumulators::extract::sum; using common::descs; using accumulators::sum_acc; using std::isfinite; auto acc = sum_acc<floating_t>{}; const auto node_norm = calculate_norm(node); for (const auto& desc : descs(node)) { if (link(node, desc) == 0. // skip deterministic descs /* ||1./util::condition(value2(desc)) < 1e-6*/) { continue; } else { acc(spec_dst(node, desc) * calculate_weight(node, desc, node_norm)); } } auto result = sum(acc); assert(isfinite(result)); return result; }
void Ip2_ViscElMat_ViscElMat_ViscElPhys::Calculate_ViscElMat_ViscElMat_ViscElPhys(const shared_ptr<Material>& b1, const shared_ptr<Material>& b2, const shared_ptr<Interaction>& interaction, shared_ptr<ViscElPhys> phys) { ViscElMat* mat1 = static_cast<ViscElMat*>(b1.get()); ViscElMat* mat2 = static_cast<ViscElMat*>(b2.get()); Real mass1 = 1.0; Real mass2 = 1.0; if ((isfinite(mat1->kn) and not (isfinite(mat2->kn))) or (isfinite(mat2->kn) and not (isfinite(mat1->kn))) or (isfinite(mat1->ks) and not (isfinite(mat2->ks))) or (isfinite(mat2->ks) and not (isfinite(mat1->ks))) or (isfinite(mat1->cn) and not (isfinite(mat2->cn))) or (isfinite(mat2->cn) and not (isfinite(mat1->cn))) or (isfinite(mat1->cs) and not (isfinite(mat2->cs))) or (isfinite(mat2->cs) and not (isfinite(mat1->cs))) or (isfinite(mat1->tc) and not (isfinite(mat2->tc))) or (isfinite(mat2->tc) and not (isfinite(mat1->tc))) or (isfinite(mat1->en) and not (isfinite(mat2->en))) or (isfinite(mat2->en) and not (isfinite(mat1->en))) or (isfinite(mat1->et) and not (isfinite(mat2->et))) or (isfinite(mat2->et) and not (isfinite(mat1->et)))) { throw runtime_error("Both materials should have the same defined set of variables e.g. tc, ks etc.!"); } mass1 = Body::byId(interaction->getId1())->state->mass; mass2 = Body::byId(interaction->getId2())->state->mass; if (mass1 == 0.0 and mass2 > 0.0) { mass1 = mass2; } else if (mass2 == 0.0 and mass1 > 0.0) { mass2 = mass1; } // See [Pournin2001, just below equation (19)] const Real massR = mass1*mass2/(mass1+mass2); GenericSpheresContact* sphCont=YADE_CAST<GenericSpheresContact*>(interaction->geom.get()); Real R1=sphCont->refR1>0?sphCont->refR1:sphCont->refR2; Real R2=sphCont->refR2>0?sphCont->refR2:sphCont->refR1; Real kn1 = 0.0; Real kn2 = 0.0; Real cn1 = 0.0; Real cn2 = 0.0; Real ks1 = 0.0; Real ks2 = 0.0; Real cs1 = 0.0; Real cs2 = 0.0; if (((isfinite(mat1->tc)) and (isfinite(mat1->en)) and (isfinite(mat1->et))) or ((tc) and (en) and (et))) { //Set parameters according to [Pournin2001] const Real Tc = (tc) ? (*tc)(mat1->id,mat2->id) : (mat1->tc+mat2->tc)/2.0; const Real En = (en) ? (*en)(mat1->id,mat2->id) : (mat1->en+mat2->en)/2.0; const Real Et = (et) ? (*et)(mat1->id,mat2->id) : (mat1->et+mat2->et)/2.0; // Factor 2 at the end of each expression is necessary, because we calculate // individual kn1, kn2, ks1, ks2 etc., because kn1 = 2*kn, ks1 = 2*ks // http://www.mail-archive.com/[email protected]/msg08778.html kn1 = kn2 = 1/Tc/Tc * ( Mathr::PI*Mathr::PI + pow(log(En),2) )*massR*2; cn1 = cn2 = -2.0 /Tc * log(En)*massR*2; ks1 = ks2 = 2.0/7.0 /Tc/Tc * ( Mathr::PI*Mathr::PI + pow(log(Et),2) )*massR*2; cs1 = cs2 = -4.0/7.0 /Tc * log(Et)*massR*2; // ^^^ // It seems to be an error in [Pournin2001] (22) Eq.4, missing factor 2 // Thanks to Dominik Boemer for pointing this out // http://www.mail-archive.com/[email protected]/msg08741.html if (std::abs(cn1) <= Mathr::ZERO_TOLERANCE ) cn1=0; if (std::abs(cn2) <= Mathr::ZERO_TOLERANCE ) cn2=0; if (std::abs(cs1) <= Mathr::ZERO_TOLERANCE ) cs1=0; if (std::abs(cs2) <= Mathr::ZERO_TOLERANCE ) cs2=0; } else if ((isfinite(mat1->kn)) and (isfinite(mat1->ks)) and (isfinite(mat1->cn)) and (isfinite(mat1->cs))) { //Set parameters explicitly kn1 = mat1->kn; kn2 = mat2->kn; ks1 = mat1->ks; ks2 = mat2->ks; cn1 = mat1->cn; cn2 = mat2->cn; cs1 = mat1->cs; cs2 = mat2->cs; } else { //Set parameters on the base of young modulus kn1 = 2*mat1->young*R1; kn2 = 2*mat2->young*R2; ks1 = kn1*mat1->poisson; ks2 = kn2*mat2->poisson; if ((isfinite(mat1->cn)) and (isfinite(mat1->cs))) { cn1 = mat1->cn; cn2 = mat2->cn; cs1 = mat1->cs; cs2 = mat2->cs; } else if( isfinite(mat1->en) and isfinite(mat1->et)) { const Real En = (en) ? (*en)(mat1->id,mat2->id) : (mat1->en+mat2->en)/2.0; cn1 = cn2 = 2.0*find_cn_from_en(En, massR,contactParameterCalculation(kn1,kn2),interaction); cs1 = cs2 = 0; } } const Real mR1 = mat1->mR; const Real mR2 = mat2->mR; const int mRtype1 = mat1->mRtype; const int mRtype2 = mat2->mRtype; phys->kn = contactParameterCalculation(kn1,kn2); phys->ks = contactParameterCalculation(ks1,ks2); phys->cn = contactParameterCalculation(cn1,cn2); phys->cs = contactParameterCalculation(cs1,cs2); if ((mR1>0) or (mR2>0)) { phys->mR = 2.0/( ((mR1>0)?1/mR1:0) + ((mR2>0)?1/mR2:0) ); } else { phys->mR = 0; } if (frictAngle) { phys->tangensOfFrictionAngle = std::tan((*frictAngle)(mat1->id,mat2->id)); } else { phys->tangensOfFrictionAngle = std::tan(std::min(mat1->frictionAngle, mat2->frictionAngle)); } phys->shearForce = Vector3r(0,0,0); if ((mRtype1 != mRtype2) or (mRtype1>2) or (mRtype2>2) or (mRtype1<1) or (mRtype2<1) ) { throw runtime_error("mRtype should be equal for both materials and have the values 1 or 2!"); } else { phys->mRtype = mRtype1; } #ifdef YADE_SPH if (mat1->SPHmode and mat2->SPHmode) { phys->SPHmode=true; phys->mu=(mat1->mu+mat2->mu); phys->h=(mat1->h+mat2->h)/2.0; } phys->kernelFunctionCurrentPressure = returnKernelFunction (mat1->KernFunctionPressure, mat2->KernFunctionPressure, Grad); phys->kernelFunctionCurrentVisco = returnKernelFunction (mat1->KernFunctionVisco, mat2->KernFunctionVisco, Lapl); #endif }