float eval(
const Shared &,
const Value & value,
rng_t &) const {
float beta = post_beta + value;
return score + fast_lgamma(beta) - fast_lgamma(alpha + beta);
}
float score_value_group(
const Shared &,
const std::vector<Group> &,
size_t groupid,
const Value & value,
rng_t &) const {
float beta = post_beta_[groupid] + value;
return score_[groupid] + fast_lgamma(beta)
- fast_lgamma(beta + alpha_[groupid]);
}
float score_data(
const Shared & shared,
rng_t &) const {
Shared post = shared.plus_group(*this);
float score = fast_lgamma(post.alpha) - fast_lgamma(shared.alpha);
score += shared.alpha * fast_log(shared.inv_beta)
- post.alpha * fast_log(post.inv_beta);
score += -log_prod;
return score;
}
void score_value(
const Shared &,
const std::vector<Group> &,
const Value & value,
AlignedFloats scores_accum,
rng_t &) const {
for (size_t i = 0, size = scores_accum.size(); i < size; ++i) {
float beta = post_beta_[i] + value;
scores_accum[i] += score_[i] + fast_lgamma(beta)
- fast_lgamma(beta + alpha_[i]);
}
}
void init(
const Shared & shared,
const Group & group,
rng_t &) {
Shared post = shared.plus_group(group);
post_beta = post.beta;
alpha = post.alpha + shared.r;
score = fast_lgamma(post.alpha + post.beta)
- fast_lgamma(post.alpha)
- fast_lgamma(post.beta)
+ fast_lgamma(alpha);
}
float eval(
const Shared &,
const Value & value,
rng_t &) const {
return score
+ fast_lgamma(post_alpha + value)
- fast_log_factorial(value)
+ score_coeff * value;
}
float score_data(
const Shared & shared,
const std::vector<Group> & groups,
rng_t &) const {
const float alpha_part = fast_lgamma(shared.alpha);
const float beta_part = shared.alpha * fast_log(shared.inv_beta);
float score = 0;
for (auto const & group : groups) {
if (group.count) {
Shared post = shared.plus_group(group);
score += fast_lgamma(post.alpha) - alpha_part;
score += beta_part - post.alpha * fast_log(post.inv_beta);
score += -group.log_prod;
}
}
return score;
}
void init(
const Shared & shared,
const Group & group,
rng_t &) {
Shared post = shared.plus_group(group);
score_coeff = -fast_log(1.f + post.inv_beta);
score = -fast_lgamma(post.alpha)
+ post.alpha * (fast_log(post.inv_beta) + score_coeff);
post_alpha = post.alpha;
}
float score_value_group(
const Shared &,
const std::vector<Group> &,
size_t groupid,
const Value & value,
rng_t &) const {
return score_[groupid]
+ fast_lgamma(post_alpha_[groupid] + value)
- fast_log_factorial(value)
+ score_coeff_[groupid] * value;
}
float score_data(
const Shared & shared,
rng_t &) const {
Shared post = shared.plus_group(*this);
float score = fast_lgamma(shared.alpha + shared.beta)
- fast_lgamma(post.alpha + post.beta);
score += fast_lgamma(post.alpha) - fast_lgamma(shared.alpha);
score += fast_lgamma(post.beta) - fast_lgamma(shared.beta);
return score;
}
float score_value(
const Shared & shared,
const Value & value,
rng_t &) const {
Shared post = shared.plus_group(*this);
float alpha = post.alpha + shared.r;
float beta = post.beta + value;
float score = fast_lgamma(post.alpha + post.beta)
- fast_lgamma(alpha + beta);
score += fast_lgamma(alpha) - fast_lgamma(post.alpha);
score += fast_lgamma(beta) - fast_lgamma(post.beta);
return score;
}
float score_data(
const Shared & shared,
const std::vector<Group> & groups,
rng_t &) const {
const float shared_part = fast_lgamma(shared.alpha + shared.beta)
- fast_lgamma(shared.alpha)
- fast_lgamma(shared.beta);
float score = 0;
for (auto const & group : groups) {
if (group.count) {
Shared post = shared.plus_group(group);
score += fast_lgamma(post.alpha)
+ fast_lgamma(post.beta)
- fast_lgamma(post.alpha + post.beta);
score += shared_part;
}
}
return score;
}
