void operator ()(Args const &args)
{
std::size_t cnt = count(args);
if(cnt > 1)
{
extractor<MeanFeature> const some_mean = {};
result_type tmp = args[parameter::keyword<Tag>::get()] - some_mean(args);
this->weighted_variance =
numeric::average(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args))
+ numeric::average(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] );
}
}
void operator ()(Args const &args)
{
std::size_t cnt = count(args);
if (cnt > 1)
{
extractor<tag::weighted_mean_of_variates<VariateType, VariateTag> > const some_weighted_mean_of_variates = {};
this->cov_ = this->cov_ * (sum_of_weights(args) - args[weight]) / sum_of_weights(args)
+ numeric::outer_product(
some_weighted_mean_of_variates(args) - args[parameter::keyword<VariateTag>::get()]
, weighted_mean(args) - args[sample]
) * args[weight] / (sum_of_weights(args) - args[weight]);
}
}
result_type result(Args const &args) const
{
float_type threshold = sum_of_weights(args)
* ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] );
std::size_t n = 0;
Weight sum = Weight(0);
while (sum < threshold)
{
if (n < static_cast<std::size_t>(tail_weights(args).size()))
{
sum += *(tail_weights(args).begin() + n);
n++;
}
else
{
if (std::numeric_limits<result_type>::has_quiet_NaN)
{
return std::numeric_limits<result_type>::quiet_NaN();
}
else
{
std::ostringstream msg;
msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
boost::throw_exception(std::runtime_error(msg.str()));
return Sample(0);
}
}
}
// Note that the cached samples of the left are sorted in ascending order,
// whereas the samples of the right tail are sorted in descending order
return *(boost::begin(tail(args)) + n - 1);
}
result_type result(Args const &args) const
{
float_type threshold = sum_of_weights(args)
* ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] );
std::size_t n = 0;
Weight sum = Weight(0);
while (sum < threshold)
{
if (n < static_cast<std::size_t>(tail_weights(args).size()))
{
sum += *(tail_weights(args).begin() + n);
n++;
}
else
{
if (std::numeric_limits<float_type>::has_quiet_NaN)
{
std::fill(
this->tail_means_.begin()
, this->tail_means_.end()
, std::numeric_limits<float_type>::quiet_NaN()
);
}
else
{
std::ostringstream msg;
msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
boost::throw_exception(std::runtime_error(msg.str()));
}
}
}
std::size_t num_variates = tail_variate(args).begin()->size();
this->tail_means_.clear();
this->tail_means_.resize(num_variates, Sample(0));
this->tail_means_ = std::inner_product(
tail_variate(args).begin()
, tail_variate(args).begin() + n
, tail_weights(args).begin()
, this->tail_means_
, numeric::functional::plus<array_type const, array_type const>()
, numeric::functional::multiply_and_promote_to_double<VariateType const, Weight const>()
);
float_type factor = sum * ( (is_same<Impl, relative>::value) ? non_coherent_weighted_tail_mean(args) : 1. );
std::transform(
this->tail_means_.begin()
, this->tail_means_.end()
, this->tail_means_.begin()
, std::bind2nd(numeric::functional::divides<typename array_type::value_type const, float_type const>(), factor)
);
return make_iterator_range(this->tail_means_);
}
void operator ()(Args const &args)
{
// Matthias:
// need to pass the argument pack since the weight might be an external
// accumulator set passed as a named parameter
Weight w_sum = sum_of_weights(args);
Weight w = args[weight];
weighted_sample const &s = args[parameter::keyword<Tag>::get()] * w;
this->mean = numeric::fdiv(this->mean * (w_sum - w) + s, w_sum);
}
result_type result(Args const &args) const
{
typedef
typename mpl::if_<
is_same<Tag, tag::sample>
, tag::weighted_sum
, tag::weighted_sum_of_variates<Sample, Tag>
>::type
weighted_sum_tag;
extractor<weighted_sum_tag> const some_weighted_sum = {};
return numeric::fdiv(some_weighted_sum(args), sum_of_weights(args));
}
result_type result(Args const &args) const
{
float_type threshold = sum_of_weights(args)
* ( ( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability] );
std::size_t n = 0;
Weight sum = Weight(0);
while (sum < threshold)
{
if (n < static_cast<std::size_t>(tail_weights(args).size()))
{
sum += *(tail_weights(args).begin() + n);
n++;
}
else
{
if (std::numeric_limits<result_type>::has_quiet_NaN)
{
return std::numeric_limits<result_type>::quiet_NaN();
}
else
{
std::ostringstream msg;
msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
boost::throw_exception(std::runtime_error(msg.str()));
return result_type(0);
}
}
}
return numeric::average(
std::inner_product(
tail(args).begin()
, tail(args).begin() + n
, tail_weights(args).begin()
, weighted_sample(0)
)
, sum
);
}
result_type result(Args const &args) const
{
if (this->is_dirty_)
{
this->is_dirty_ = false;
this->mu_ = this->sign_ * numeric::average(this->mu_, this->w_sum_);
this->sigma2_ = numeric::average(this->sigma2_, this->w_sum_);
this->sigma2_ -= this->mu_ * this->mu_;
float_type threshold_probability = numeric::average(sum_of_weights(args) - this->w_sum_, sum_of_weights(args));
float_type tmp = numeric::average(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
float_type xi_hat = 0.5 * ( 1. - tmp );
float_type beta_hat = 0.5 * ( this->mu_ - this->threshold_ ) * ( 1. + tmp );
float_type beta_bar = beta_hat * std::pow(1. - threshold_probability, xi_hat);
float_type u_bar = this->threshold_ - beta_bar * ( std::pow(1. - threshold_probability, -xi_hat) - 1.)/xi_hat;
this->fit_parameters_ = boost::make_tuple(u_bar, beta_bar, xi_hat);
}
return this->fit_parameters_;
}
result_type result(Args const &args) const
{
if (this->is_dirty_)
{
this->is_dirty_ = false;
float_type threshold = sum_of_weights(args)
* ( ( is_same<LeftRight, left>::value ) ? this->threshold_probability_ : 1. - this->threshold_probability_ );
std::size_t n = 0;
Weight sum = Weight(0);
while (sum < threshold)
{
if (n < static_cast<std::size_t>(tail_weights(args).size()))
{
mu_ += *(tail_weights(args).begin() + n) * *(tail(args).begin() + n);
sigma2_ += *(tail_weights(args).begin() + n) * *(tail(args).begin() + n) * (*(tail(args).begin() + n));
sum += *(tail_weights(args).begin() + n);
n++;
}
else
{
if (std::numeric_limits<float_type>::has_quiet_NaN)
{
return boost::make_tuple(
std::numeric_limits<float_type>::quiet_NaN()
, std::numeric_limits<float_type>::quiet_NaN()
, std::numeric_limits<float_type>::quiet_NaN()
);
}
else
{
std::ostringstream msg;
msg << "index n = " << n << " is not in valid range [0, " << tail(args).size() << ")";
boost::throw_exception(std::runtime_error(msg.str()));
return boost::make_tuple(Sample(0), Sample(0), Sample(0));
}
}
}
float_type u = *(tail(args).begin() + n - 1) * this->sign_;
this->mu_ = this->sign_ * numeric::average(this->mu_, sum);
this->sigma2_ = numeric::average(this->sigma2_, sum);
this->sigma2_ -= this->mu_ * this->mu_;
if (is_same<LeftRight, left>::value)
this->threshold_probability_ = 1. - this->threshold_probability_;
float_type tmp = numeric::average(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
float_type xi_hat = 0.5 * ( 1. - tmp );
float_type beta_hat = 0.5 * ( this->mu_ - u ) * ( 1. + tmp );
float_type beta_bar = beta_hat * std::pow(1. - threshold_probability_, xi_hat);
float_type u_bar = u - beta_bar * ( std::pow(1. - threshold_probability_, -xi_hat) - 1.)/xi_hat;
this->fit_parameters_ = boost::make_tuple(u_bar, beta_bar, xi_hat);
}
return this->fit_parameters_;
}
void operator ()(Args const &args)
{
std::size_t cnt = count(args);
std::size_t sample_cell = 1; // k
std::size_t num_quantiles = this->probabilities.size();
// m+2 principal markers and m+1 middle markers
std::size_t num_markers = 2 * num_quantiles + 3;
// first accumulate num_markers samples
if(cnt <= num_markers)
{
this->heights[cnt - 1] = args[sample];
this->actual_positions[cnt - 1] = args[weight];
// complete the initialization of heights (and actual_positions) by sorting
if(cnt == num_markers)
{
// TODO: we need to sort the initial samples (in heights) in ascending order and
// sort their weights (in actual_positions) the same way. The following lines do
// it, but there must be a better and more efficient way of doing this.
typename array_type::iterator it_begin, it_end, it_min;
it_begin = this->heights.begin();
it_end = this->heights.end();
std::size_t pos = 0;
while (it_begin != it_end)
{
it_min = std::min_element(it_begin, it_end);
std::size_t d = std::distance(it_begin, it_min);
std::swap(*it_begin, *it_min);
std::swap(this->actual_positions[pos], this->actual_positions[pos + d]);
++it_begin;
++pos;
}
// calculate correct initial actual positions
for (std::size_t i = 1; i < num_markers; ++i)
{
actual_positions[i] += actual_positions[i - 1];
}
}
}
else
{
if(args[sample] < this->heights[0])
{
this->heights[0] = args[sample];
this->actual_positions[0] = args[weight];
sample_cell = 1;
}
else if(args[sample] >= this->heights[num_markers - 1])
{
this->heights[num_markers - 1] = args[sample];
sample_cell = num_markers - 1;
}
else
{
// find cell k = sample_cell such that heights[k-1] <= sample < heights[k]
typedef typename array_type::iterator iterator;
iterator it = std::upper_bound(
this->heights.begin()
, this->heights.end()
, args[sample]
);
sample_cell = std::distance(this->heights.begin(), it);
}
// update actual position of all markers above sample_cell
for(std::size_t i = sample_cell; i < num_markers; ++i)
{
this->actual_positions[i] += args[weight];
}
// compute desired positions
{
this->desired_positions[0] = this->actual_positions[0];
this->desired_positions[num_markers - 1] = sum_of_weights(args);
this->desired_positions[1] = (sum_of_weights(args) - this->actual_positions[0]) * probabilities[0]
/ 2. + this->actual_positions[0];
this->desired_positions[num_markers - 2] = (sum_of_weights(args) - this->actual_positions[0])
* (probabilities[num_quantiles - 1] + 1.)
/ 2. + this->actual_positions[0];
for (std::size_t i = 0; i < num_quantiles; ++i)
{
this->desired_positions[2 * i + 2] = (sum_of_weights(args) - this->actual_positions[0])
* probabilities[i] + this->actual_positions[0];
}
for (std::size_t i = 1; i < num_quantiles; ++i)
{
this->desired_positions[2 * i + 1] = (sum_of_weights(args) - this->actual_positions[0])
* (probabilities[i - 1] + probabilities[i])
/ 2. + this->actual_positions[0];
}
}
// adjust heights and actual_positions of markers 1 to num_markers - 2 if necessary
for (std::size_t i = 1; i <= num_markers - 2; ++i)
{
// offset to desired position
float_type d = this->desired_positions[i] - this->actual_positions[i];
// offset to next position
float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
// offset to previous position
float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
// height ds
float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
if((d >= 1 && dp > 1) || (d <= -1 && dm < -1))
{
short sign_d = static_cast<short>(d / std::abs(d));
float_type h = this->heights[i] + sign_d / (dp - dm) * ((sign_d - dm)*hp + (dp - sign_d) * hm);
// try adjusting heights[i] using p-squared formula
if(this->heights[i - 1] < h && h < this->heights[i + 1])
{
this->heights[i] = h;
}
else
{
// use linear formula
if(d > 0)
{
this->heights[i] += hp;
}
if(d < 0)
{
this->heights[i] -= hm;
}
}
this->actual_positions[i] += sign_d;
}
}
}
}
result_type result(Args const &args) const
{
return numeric::average(this->sum, sum_of_weights(args));
}
result_type result(Args const &args) const
{
if(count(args[accumulator])<1) return 1.;
return sum_of_weights(args[accumulator])/count(args[accumulator]);
}
result_type result(Args const &args) const
{
if (this->is_dirty)
{
this->is_dirty = false;
// creates a vector of std::pair where each pair i holds
// the values heights[i] (x-axis of histogram) and
// actual_positions[i] / sum_of_weights (y-axis of histogram)
for (std::size_t i = 0; i < this->histogram.size(); ++i)
{
this->histogram[i] = std::make_pair(this->heights[i], numeric::fdiv(this->actual_positions[i], sum_of_weights(args)));
}
}
return make_iterator_range(this->histogram);
}
void operator ()(Args const &args)
{
std::size_t cnt = count(args);
// accumulate 5 first samples
if (cnt <= 5)
{
this->heights[cnt - 1] = args[sample];
// In this initialization phase, actual_positions stores the weights of the
// inital samples that are needed at the end of the initialization phase to
// compute the correct initial positions of the markers.
this->actual_positions[cnt - 1] = args[weight];
// complete the initialization of heights and actual_positions by sorting
if (cnt == 5)
{
// TODO: we need to sort the initial samples (in heights) in ascending order and
// sort their weights (in actual_positions) the same way. The following lines do
// it, but there must be a better and more efficient way of doing this.
typename array_type::iterator it_begin, it_end, it_min;
it_begin = this->heights.begin();
it_end = this->heights.end();
std::size_t pos = 0;
while (it_begin != it_end)
{
it_min = std::min_element(it_begin, it_end);
std::size_t d = std::distance(it_begin, it_min);
std::swap(*it_begin, *it_min);
std::swap(this->actual_positions[pos], this->actual_positions[pos + d]);
++it_begin;
++pos;
}
// calculate correct initial actual positions
for (std::size_t i = 1; i < 5; ++i)
{
this->actual_positions[i] += this->actual_positions[i - 1];
}
}
}
else
{
std::size_t sample_cell = 1; // k
// find cell k such that heights[k-1] <= args[sample] < heights[k] and adjust extreme values
if (args[sample] < this->heights[0])
{
this->heights[0] = args[sample];
this->actual_positions[0] = args[weight];
sample_cell = 1;
}
else if (this->heights[4] <= args[sample])
{
this->heights[4] = args[sample];
sample_cell = 4;
}
else
{
typedef typename array_type::iterator iterator;
iterator it = std::upper_bound(
this->heights.begin()
, this->heights.end()
, args[sample]
);
sample_cell = std::distance(this->heights.begin(), it);
}
// increment positions of markers above sample_cell
for (std::size_t i = sample_cell; i < 5; ++i)
{
this->actual_positions[i] += args[weight];
}
// update desired positions for all markers
this->desired_positions[0] = this->actual_positions[0];
this->desired_positions[1] = (sum_of_weights(args) - this->actual_positions[0])
* this->p/2. + this->actual_positions[0];
this->desired_positions[2] = (sum_of_weights(args) - this->actual_positions[0])
* this->p + this->actual_positions[0];
this->desired_positions[3] = (sum_of_weights(args) - this->actual_positions[0])
* (1. + this->p)/2. + this->actual_positions[0];
this->desired_positions[4] = sum_of_weights(args);
// adjust height and actual positions of markers 1 to 3 if necessary
for (std::size_t i = 1; i <= 3; ++i)
{
// offset to desired positions
float_type d = this->desired_positions[i] - this->actual_positions[i];
// offset to next position
float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
// offset to previous position
float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
// height ds
float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
if ( ( d >= 1. && dp > 1. ) || ( d <= -1. && dm < -1. ) )
{
short sign_d = static_cast<short>(d / std::abs(d));
// try adjusting heights[i] using p-squared formula
float_type h = this->heights[i] + sign_d / (dp - dm) * ( (sign_d - dm) * hp + (dp - sign_d) * hm );
if ( this->heights[i - 1] < h && h < this->heights[i + 1] )
{
this->heights[i] = h;
}
else
{
// use linear formula
if (d>0)
{
this->heights[i] += hp;
}
if (d<0)
{
this->heights[i] -= hm;
}
}
this->actual_positions[i] += sign_d;
}
}
}
}
void operator ()(Args const &args)
{
this->is_dirty = true;
std::size_t cnt = count(args);
std::size_t sample_cell = 1; // k
std::size_t b = this->num_cells;
// accumulate num_cells + 1 first samples
if (cnt <= b + 1)
{
this->heights[cnt - 1] = args[sample];
this->actual_positions[cnt - 1] = args[weight];
// complete the initialization of heights by sorting
if (cnt == b + 1)
{
//std::sort(this->heights.begin(), this->heights.end());
// TODO: we need to sort the initial samples (in heights) in ascending order and
// sort their weights (in actual_positions) the same way. The following lines do
// it, but there must be a better and more efficient way of doing this.
typename array_type::iterator it_begin, it_end, it_min;
it_begin = this->heights.begin();
it_end = this->heights.end();
std::size_t pos = 0;
while (it_begin != it_end)
{
it_min = std::min_element(it_begin, it_end);
std::size_t d = std::distance(it_begin, it_min);
std::swap(*it_begin, *it_min);
std::swap(this->actual_positions[pos], this->actual_positions[pos + d]);
++it_begin;
++pos;
}
// calculate correct initial actual positions
for (std::size_t i = 1; i < b; ++i)
{
this->actual_positions[i] += this->actual_positions[i - 1];
}
}
}
else
{
// find cell k such that heights[k-1] <= args[sample] < heights[k] and adjust extreme values
if (args[sample] < this->heights[0])
{
this->heights[0] = args[sample];
this->actual_positions[0] = args[weight];
sample_cell = 1;
}
else if (this->heights[b] <= args[sample])
{
this->heights[b] = args[sample];
sample_cell = b;
}
else
{
typename array_type::iterator it;
it = std::upper_bound(
this->heights.begin()
, this->heights.end()
, args[sample]
);
sample_cell = std::distance(this->heights.begin(), it);
}
// increment positions of markers above sample_cell
for (std::size_t i = sample_cell; i < b + 1; ++i)
{
this->actual_positions[i] += args[weight];
}
// determine desired marker positions
for (std::size_t i = 1; i < b + 1; ++i)
{
this->desired_positions[i] = this->actual_positions[0]
+ numeric::fdiv((i-1) * (sum_of_weights(args) - this->actual_positions[0]), b);
}
// adjust heights of markers 2 to num_cells if necessary
for (std::size_t i = 1; i < b; ++i)
{
// offset to desire position
float_type d = this->desired_positions[i] - this->actual_positions[i];
// offset to next position
float_type dp = this->actual_positions[i + 1] - this->actual_positions[i];
// offset to previous position
float_type dm = this->actual_positions[i - 1] - this->actual_positions[i];
// height ds
float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
if ( ( d >= 1. && dp > 1. ) || ( d <= -1. && dm < -1. ) )
{
short sign_d = static_cast<short>(d / std::abs(d));
// try adjusting heights[i] using p-squared formula
float_type h = this->heights[i] + sign_d / (dp - dm) * ( (sign_d - dm) * hp + (dp - sign_d) * hm );
if ( this->heights[i - 1] < h && h < this->heights[i + 1] )
{
this->heights[i] = h;
}
else
{
// use linear formula
if (d>0)
{
this->heights[i] += hp;
}
if (d<0)
{
this->heights[i] -= hm;
}
}
this->actual_positions[i] += sign_d;
}
}
}
}
result_type result(Args const &args) const
{
if (this->is_dirty)
{
this->is_dirty = false;
// creates a vector of std::pair where each pair i holds
// the values bin_positions[i] (x-axis of histogram) and
// samples_in_bin[i] / cnt (y-axis of histogram).
for (std::size_t i = 0; i < this->num_bins + 2; ++i)
{
this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::fdiv(this->samples_in_bin[i], sum_of_weights(args)));
}
}
// returns a range of pairs
return make_iterator_range(this->histogram);
}
int main(int argc, char **argv)
{
char *str_alpha_p = argv[1], *str_alpha_q = argv[2];
char *cdf = argv[3];
unsigned nprior = atoi(argv[4]);
unsigned npost = atoi(argv[5]);
unsigned ngold = atoi(argv[6]);
/* double step_mult = atof(argv[7]); */
gsl_set_error_handler_off();
FILE *cdf_fh = fopen(cdf, "w");
double alpha_p[4], alpha_q[4];
sscanf(str_alpha_p, "%lf,%lf,%lf,%lf", &alpha_p[0], &alpha_p[1], &alpha_p[2], &alpha_p[3]);
sscanf(str_alpha_q, "%lf,%lf,%lf,%lf", &alpha_q[0], &alpha_q[1], &alpha_q[2], &alpha_q[3]);
double alpha_combined[] = {
alpha_p[0] + alpha_q[0] - 1,
alpha_p[1] + alpha_q[1] - 1,
alpha_p[2] + alpha_q[2] - 1,
alpha_p[3] + alpha_q[3] - 1
};
unsigned ntotal = nprior + npost + ngold;
struct wpoint *buf = (struct wpoint *)malloc(ntotal * sizeof(struct wpoint));
struct wpoint *p_points = buf, *q_points = buf + nprior, *g_points = q_points + npost;
struct wpoint **tmp_points = (struct wpoint **)malloc((nprior + npost) * sizeof(struct wpoint *));
struct wpoint **int_smooth_points = (struct wpoint **)malloc(npost * sizeof(struct wpoint *));
struct wpoint **ext_points = (struct wpoint **)malloc(nprior * sizeof(struct wpoint *));
struct wpoint **ext_smooth_points = (struct wpoint **)malloc(nprior * sizeof(struct wpoint *));
struct wpoint **ext_rough_points = (struct wpoint **)malloc(nprior * sizeof(struct wpoint *));
struct wpoint **all_smooth_points = (struct wpoint **)malloc((nprior + npost) * sizeof(struct wpoint *));
struct wpoint **pg = (struct wpoint **)malloc(ngold * sizeof(struct wpoint *));
struct wpoint **pp, **pp2, **pe;
struct wpoint *s, *p_end = p_points + nprior, *q_end = q_points + npost;
gsl_rng *rand = gsl_rng_alloc(gsl_rng_taus);
// populate P(*)
double p_norm;
populate_points(p_points, nprior, alpha_p, alpha_q, rand, "prior", &p_norm);
// populate Q(*)
double q_norm;
populate_points(q_points, npost, alpha_q, alpha_p, rand, "post", &q_norm);
int i;
for (i = 0; i != 10; ++i)
{
populate_points(q_points, npost, alpha_q, alpha_p, rand, "post", &q_norm);
fprintf(stderr, "q_norm = %g\n", q_norm);
}
/* populate gold(*) */
double g_norm;
double alpha_uniform[] = { 1, 1, 1, 1 };
populate_points(g_points, ngold, alpha_combined, alpha_uniform, rand, "gold", &g_norm);
/* normalize */
normalize_points(p_points, nprior, p_norm, q_norm);
normalize_points(q_points, npost, q_norm, p_norm);
normalize_points(g_points, ngold, g_norm, g_norm);
unsigned n;
/* gather all Q(*) points (use int_smooth_points temporarily) */
for (s = q_points, pp = int_smooth_points; s != q_end; ++s)
*pp++ = s;
n = pp - int_smooth_points;
/* collect Q(*) smooth (interior) points */
// double ln_p_bound = smooth_threshold(int_smooth_points, step_mult, &n);
/* for (s = q_points, pp = int_smooth_points; s != q_end; ++s) */
/* if (s->ln_o <= ln_p_bound) */
/* *pp++ = s; */
for (s = q_points, pp = int_smooth_points; s != q_end; ++s)
if (s->ln_d > s->ln_o)
*pp++ = s;
unsigned n_int_smooth_q = pp - int_smooth_points;
/* double ma_ratio = max_to_avg_ratio(int_smooth_points,); */
double int_mass_on_q = sum_of_weights(int_smooth_points, n_int_smooth_q);
/* collect exterior P(*) points */
/* for (s = p_points, pp = ext_points; s != p_end; ++s) */
/* if (s->ln_d > ln_p_bound) */
/* *pp++ = s; */
for (s = p_points, pp = ext_smooth_points; s != p_end; ++s)
if (s->ln_d > s->ln_o)
*pp++ = s;
/* unsigned n_ext_p = n = pp - ext_points; */
/* double ln_q_bound = smooth_threshold(ext_points, step_mult, &n); */
/* collect exterior P(*) smooth points */
/* for (s = p_points, pp = ext_smooth_points; s != p_end; ++s) */
/* if (s->ln_d > ln_p_bound && s->ln_o < ln_q_bound) */
/* *pp++ = s; */
unsigned n_ext_smooth_p = pp - ext_smooth_points;
/* double ma2_ratio = max_to_avg_ratio(ext_smooth_points, n_ext_smooth_p); */
double ext_mass_on_p = sum_of_weights(ext_smooth_points, n_ext_smooth_p);
double total_mixed_mass = int_mass_on_q + ext_mass_on_p;
/* fprintf(stderr, "Number of points unaccounted for: %u\n", n_ext_p - n_ext_smooth_p); */
// print out numerical CDFs
char hdr[] = "Dist\tBase\tComp\tPointIndex\tCDF\tln_d\tln_o\tBaseDist\n";
fprintf(cdf_fh, hdr);
print_cdf(int_smooth_points, n_int_smooth_q, total_mixed_mass, buf, "int_smooth_q", cdf_fh);
print_cdf(ext_smooth_points, n_ext_smooth_p, total_mixed_mass, buf, "ext_smooth_p", cdf_fh);
pe = int_smooth_points + n_int_smooth_q;
for (pp = int_smooth_points, pp2 = all_smooth_points; pp != pe; ++pp, ++pp2)
*pp2 = *pp;
pe = ext_smooth_points + n_ext_smooth_p;
for (pp = ext_smooth_points; pp != pe; ++pp, ++pp2)
*pp2 = *pp;
unsigned n_smooth = n_int_smooth_q + n_ext_smooth_p;
print_cdf(all_smooth_points, n_smooth, total_mixed_mass, p_points, "smooth_combined", cdf_fh);
/* all points in the P(*) sampling */
for (s = p_points, pp = tmp_points; s != p_end; ++s)
*pp++ = s;
print_cdf(tmp_points, nprior, total_mixed_mass, p_points, "all_p", cdf_fh);
/* all points in the Q(*) sampling */
for (s = q_points, pp = tmp_points; s != q_end; ++s)
*pp++ = s;
print_cdf(tmp_points, npost, total_mixed_mass, q_points, "all_q", cdf_fh);
/* print out the gold standard */
struct wpoint *gold_end = g_points + ngold;
for (s = g_points, pp = pg; s != gold_end; ++s)
*pp++ = s;
double gold_mass = sum_of_weights(pg, ngold);
print_cdf(pg, ngold, gold_mass, g_points, "dgold", cdf_fh);
/* compute component-wise marginal estimates. */
/* double q[] = { 0.0001, 0.001, 0.01, 0.1, 0.5, 0.9, 0.99, 0.999, 0.9999 }; */
/* double qv[NUCS][sizeof(q) / sizeof(double)]; */
// print out marginal estimates
/* unsigned iq; */
/* for (dim = 0; dim != NUCS; ++dim) */
/* { */
/* for (iq = 0; iq != sizeof(qv[dim]) / sizeof(double); ++iq) */
/* printf(iq ? "\t%f" : "%f", qv[dim][iq]); */
/* printf("\n"); */
/* } */
free(buf);
free(tmp_points);
free(int_smooth_points);
free(ext_points);
free(ext_smooth_points);
free(ext_rough_points);
free(all_smooth_points);
free(pg);
gsl_rng_free(rand);
fclose(cdf_fh);
return 0;
}