StochasticTools::BiasCorrectedAccelerated< InType, OutType > Class Template Reference

#include <BootstrapCalculators.h>

Inheritance diagram for StochasticTools::BiasCorrectedAccelerated< InType, OutType >:

Public Member Functions
virtual std::vector< OutType >	compute (const InType &, const bool) override
const std::string &	name () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Protected Member Functions
std::vector< OutType >	computeBootstrapEstimates (const InType &, const bool)

Protected Attributes
const std::vector< Real >	_levels
const unsigned int	_replicates
const unsigned int	_seed
StochasticTools::Calculator< InType, OutType > &	_calc
const Parallel::Communicator &	_communicator

Private Member Functions
OutType	acceleration (const InType &, const bool)

Detailed Description

template<typename InType, typename OutType>
class StochasticTools::BiasCorrectedAccelerated< InType, OutType >

Definition at line 98 of file BootstrapCalculators.h.

Member Function Documentation

acceleration()

template<typename InType , typename OutType >

OutType StochasticTools::BiasCorrectedAccelerated< InType, OutType >::acceleration ( const InType &  data, const bool  is_distributed  )

private

Definition at line 77 of file BootstrapCalculators.C.

{
  const std::size_t local_size = data.size();
  std::vector<std::size_t> local_sizes = {local_size};
  if (is_distributed)
    this->_communicator.allgather(local_sizes);
  const std::size_t count = std::accumulate(local_sizes.begin(), local_sizes.end(), 0);
  const processor_id_type rank = is_distributed ? this->processor_id() : 0;

  // Jackknife statistics
  std::vector<OutType> theta_i(local_size);

  // Compute jackknife estimates, Ch. 11, Eq. 11.2, p. 141
  for (processor_id_type r = 0; r < local_sizes.size(); ++r)
    for (std::size_t i = 0; i < local_sizes[r]; ++i)
    {
      this->_calc.initializeCalculator();
      for (std::size_t il = 0; il < local_size; ++il)
        if (i != il || r != rank)
          this->_calc.updateCalculator(data[il]);
      this->_calc.finalizeCalculator(is_distributed);
      if (r == rank)
        theta_i[i] = this->_calc.getValue();
    }

  // Compute jackknife sum, Ch. 11, Eq. 11.4, p. 141
  OutType theta_dot = std::accumulate(theta_i.begin(), theta_i.end(), OutType());
  if (is_distributed)
    this->_communicator.sum(theta_dot);
  theta_dot /= count;

  // Acceleration, Ch. 14, Eq. 14.15, p. 185
  std::vector<OutType> num_den(2);
  for (const auto & jk : theta_i)
  {
    num_den[0] += MathUtils::pow(theta_dot - jk, 3);
    num_den[1] += MathUtils::pow(theta_dot - jk, 2);
  }
  if (is_distributed)
    this->_communicator.sum(num_den);

  mooseAssert(num_den[1] != OutType(), "The acceleration denomenator must not be zero.");
  return num_den[0] / (6 * std::pow(num_den[1], 3. / 2.));
}

compute()

template<typename InType , typename OutType >

std::vector< OutType > StochasticTools::BiasCorrectedAccelerated< InType, OutType >::compute ( const InType &  data, const bool  is_distributed  )

overridevirtual

Implements StochasticTools::BootstrapCalculator< InType, OutType >.

Definition at line 45 of file BootstrapCalculators.C.

{
  // Bootstrap estimates
  const std::vector<OutType> values = this->computeBootstrapEstimates(data, is_distributed);

  // Compute bias-correction, Efron and Tibshirani (2003), Eq. 14.14, p. 186
  const OutType value = this->_calc.compute(data, is_distributed);
  const Real count = std::count_if(
      values.begin(),
      values.end(),
      [&value](Real v) { return v < value; }); // use Real for non-integer division below
  const Real bias = NormalDistribution::quantile(count / this->_replicates, 0, 1);

  // Compute Acceleration, Efron and Tibshirani (2003), Eq. 14.15, p. 186
  const OutType acc = data.empty() ? OutType() : acceleration(data, is_distributed);

  // Compute intervals, Efron and Tibshirani (2003), Eq. 14.10, p. 185
  std::vector<OutType> output;
  for (const Real & level : this->_levels)
  {
    const Real z = NormalDistribution::quantile(level, 0, 1);
    const Real x = bias + (bias + (bias + z) / (1 - acc * (bias + z)));
    const Real alpha = NormalDistribution::cdf(x, 0, 1);

    long unsigned int index = std::lrint(alpha * (this->_replicates - 1));
    output.push_back(values[index]);
  }
  return output;
}

computeBootstrapEstimates()

template<typename InType, typename OutType >

std::vector< OutType > StochasticTools::BootstrapCalculator< InType, OutType >::computeBootstrapEstimates ( const InType &  data, const bool  is_distributed  )

protectedinherited

Definition at line 157 of file BootstrapCalculators.h.

{
  MooseRandom generator;
  generator.seed(0, _seed);

  // Compute replicate statistics
  std::vector<OutType> values(_replicates);
  auto calc_update = [this](const typename InType::value_type & val)
  { _calc.updateCalculator(val); };
  for (std::size_t i = 0; i < _replicates; ++i)
  {
    _calc.initializeCalculator();
    MooseUtils::resampleWithFunctor(
        data, calc_update, generator, 0, is_distributed ? &this->_communicator : nullptr);
    _calc.finalizeCalculator(is_distributed);
    values[i] = _calc.getValue();
  }
  inplaceSort(values);
  return values;
}

name()

template<typename InType, typename OutType>

const std::string& StochasticTools::BootstrapCalculator< InType, OutType >::name ( ) const

inlineinherited

Definition at line 61 of file BootstrapCalculators.h.

{ return _name; }

Member Data Documentation

_calc

template<typename InType, typename OutType>

StochasticTools::Calculator<InType, OutType>& StochasticTools::BootstrapCalculator< InType, OutType >::_calc

protectedinherited

Definition at line 77 of file BootstrapCalculators.h.

_levels

template<typename InType, typename OutType>

const std::vector<Real> StochasticTools::BootstrapCalculator< InType, OutType >::_levels

protectedinherited

Definition at line 68 of file BootstrapCalculators.h.

_replicates

template<typename InType, typename OutType>

const unsigned int StochasticTools::BootstrapCalculator< InType, OutType >::_replicates

protectedinherited

Definition at line 71 of file BootstrapCalculators.h.

_seed

template<typename InType, typename OutType>

const unsigned int StochasticTools::BootstrapCalculator< InType, OutType >::_seed

protectedinherited

Definition at line 74 of file BootstrapCalculators.h.

---

The documentation for this class was generated from the following files:

• stochastic_tools/include/utils/BootstrapCalculators.h
• stochastic_tools/src/utils/BootstrapCalculators.C