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

#include <Calculators.h>

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

Public Member Functions
OutType	compute (const InType &, bool)
	Evaluate the calculator on the full vector of data. More...
void	initializeCalculator ()
	Public function that must be called before updateCalculator and finalizeCalculator. More...
void	updateCalculator (const typename InType::value_type &)
	Public function to update calculator with a piece of data. More...
void	finalizeCalculator (bool)
	Public function to finalize the resulting calculator value. More...
OutType	getValue () const
	Public function to return the calculated value _state must be FINALIZED. More...
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
virtual void	initialize () override
	This function is used to reset the calculator to its initial state and prepare it for another evaluation. More...
virtual void	update (const typename InType::value_type &val) override
	Updating the calculator with a piece of data. More...
virtual void	finalize (bool is_distributed) override
	This is used to compute the resulting calculator value by performing necessary arithmetic and parallel communication. More...
virtual OutType	get () const override
	Returns the resulting calculator value. More...

Protected Attributes
std::vector< OutType >	_storage
OutType	_median
const Parallel::Communicator &	_communicator

Detailed Description

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

Definition at line 251 of file Calculators.h.

Member Function Documentation

compute()

template<typename InType, typename OutType >

OutType StochasticTools::Calculator< InType, OutType >::compute ( const InType &  data, bool  is_distributed  )

inherited

Evaluate the calculator on the full vector of data.

This is basically a convenient wrapper around initializeCalculator, updateCalculator, finalizeCalculator, and getvalue.

Definition at line 288 of file Calculators.h.

{
  initializeCalculator();
  for (const auto & val : data)
    updateCalculator(val);
  finalizeCalculator(is_distributed);
  return getValue();
}

finalize()

template<typename InType , typename OutType >

void StochasticTools::Median< InType, OutType >::finalize ( bool  )

overrideprotectedvirtual

This is used to compute the resulting calculator value by performing necessary arithmetic and parallel communication.

This only called once after all the input data is entered through update.

Implements StochasticTools::Calculator< InType, OutType >.

Definition at line 185 of file Calculators.C.

{
  // Make sure we aren't doing anything silly like taking the median of an empty vector
  _median = OutType();
  auto count = _storage.size();
  if (is_distributed)
    this->_communicator.sum(count);
  if (count == 0)
    return;

  if (!is_distributed || this->n_processors() == 1)
  {
    std::sort(_storage.begin(), _storage.end());
    if (count % 2)
      _median = _storage[count / 2];
    else
      _median += (_storage[count / 2] + _storage[count / 2 - 1]) / 2;
    return;
  }

  dof_id_type kgt = count % 2 ? (count / 2) : (count / 2 - 1);
  dof_id_type klt = kgt;
  while (true)
  {
    // Gather all sizes and figure out current number of values
    std::vector<std::size_t> sz = {_storage.size()};
    this->_communicator.allgather(sz);
    dof_id_type n = std::accumulate(sz.begin(), sz.end(), 0);

    // Choose the first value for the first processor with values
    for (const auto & i : index_range(sz))
      if (sz[i])
      {
        if (this->processor_id() == i)
          _median = _storage[0];
        this->_communicator.broadcast(_median, i);
        break;
      }

    // Count number of values greater than, less than, and equal to _median
    std::vector<dof_id_type> m(3, 0);
    for (const auto & val : _storage)
    {
      if (_median < val)
        m[0]++;
      else if (val < _median)
        m[1]++;
    }
    this->_communicator.sum(m);
    m[2] = n - m[0] - m[1];

    // Remove greater than equal to
    if ((m[0] + m[2]) <= kgt)
    {
      _storage.erase(std::remove_if(_storage.begin(),
                                    _storage.end(),
                                    [this](const OutType & val) { return val >= _median; }),
                     _storage.end());
      kgt -= m[0] + m[2];
    }
    // Remove less than equal to
    else if ((m[1] + m[2]) <= klt)
    {
      _storage.erase(std::remove_if(_storage.begin(),
                                    _storage.end(),
                                    [this](const OutType & val) { return val <= _median; }),
                     _storage.end());
      klt -= m[1] + m[2];
    }
    // If the number of points is odd, then we've found it
    else if (count % 2)
      break;
    // Get average of the two middle numbers
    else
    {
      OutType num2;
      // Find the next greater than
      if (m[0] > kgt)
      {
        num2 = std::numeric_limits<OutType>::max();
        for (const auto & val : _storage)
          if (_median < val && val < num2)
            num2 = val;
        this->_communicator.min(num2);
      }
      // Find the next less than
      else if (m[1] > klt)
      {
        num2 = std::numeric_limits<OutType>::min();
        for (const auto & val : _storage)
          if (val < _median && num2 < val)
            num2 += val;
        this->_communicator.max(num2);
      }
      // Otherwise we know the other number is equal
      else
        num2 = _median;

      _median = (_median + num2) / 2;
      break;
    }
  }
}

finalizeCalculator()

template<typename InType , typename OutType >

void StochasticTools::Calculator< InType, OutType >::finalizeCalculator ( bool  is_distributed )

inherited

Public function to finalize the resulting calculator value.

_state must be INITLIALIZED Sets _state to FINALIZED

Definition at line 315 of file Calculators.h.

{
  if (_state != CalculatorState::INITIALIZED)
    ::mooseError("Calculator is in wrong state.");
  finalize(is_distributed);
  _state = CalculatorState::FINALIZED;
}

get()

template<typename InType , typename OutType >

virtual OutType StochasticTools::Median< InType, OutType >::get ( ) const

inlineoverrideprotectedvirtual

Returns the resulting calculator value.

It is important to not modify member data here so the calculator can retain its state.

Implements StochasticTools::Calculator< InType, OutType >.

Definition at line 260 of file Calculators.h.

{ return _median; }

getValue()

template<typename InType , typename OutType >

OutType StochasticTools::Calculator< InType, OutType >::getValue ( ) const

inherited

Public function to return the calculated value _state must be FINALIZED.

Definition at line 325 of file Calculators.h.

{
  if (_state != CalculatorState::FINALIZED)
    ::mooseError("Calculator is in wrong state.");
  return get();
}

initialize()

template<typename InType , typename OutType >

void StochasticTools::Median< InType, OutType >::initialize ( )

overrideprotectedvirtual

This function is used to reset the calculator to its initial state and prepare it for another evaluation.

This usually involves clearing class members.

Implements StochasticTools::Calculator< InType, OutType >.

Definition at line 171 of file Calculators.C.

{
  _storage.clear();
}

initializeCalculator()

template<typename InType , typename OutType >

void StochasticTools::Calculator< InType, OutType >::initializeCalculator ( )

inherited

Public function that must be called before updateCalculator and finalizeCalculator.

Sets _state to INITIALIZED

Definition at line 299 of file Calculators.h.

Referenced by StochasticTools::SobolCalculator< std::vector< InType >, std::vector< OutType > >::finalize(), and StochasticTools::SobolCalculator< std::vector< InType >, std::vector< OutType > >::update().

{
  initialize();
  _state = CalculatorState::INITIALIZED;
}

name()

template<typename InType, typename OutType>

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

inlineinherited

Definition at line 99 of file Calculators.h.

{ return _name; }

update()

template<typename InType , typename OutType >

void StochasticTools::Median< InType, OutType >::update ( const typename InType::value_type &  )

overrideprotectedvirtual

Updating the calculator with a piece of data.

Sometimes some clever arithmetic is required to avoid storing data.

Implements StochasticTools::Calculator< InType, OutType >.

Definition at line 178 of file Calculators.C.

{
  _storage.push_back(static_cast<OutType>(val));
}

updateCalculator()

template<typename InType, typename OutType >

void StochasticTools::Calculator< InType, OutType >::updateCalculator ( const typename InType::value_type &  val )

inherited

Public function to update calculator with a piece of data.

_state mush be INITIALIZED

Definition at line 307 of file Calculators.h.

{
  mooseAssert(_state == CalculatorState::INITIALIZED, "Calculator is in wrong state.");
  update(val);
}

Member Data Documentation

_median

template<typename InType , typename OutType >

OutType StochasticTools::Median< InType, OutType >::_median

protected

Definition at line 263 of file Calculators.h.

Referenced by StochasticTools::Median< InType, OutType >::get().

_storage

template<typename InType , typename OutType >

std::vector<OutType> StochasticTools::Median< InType, OutType >::_storage

protected

Definition at line 262 of file Calculators.h.

---

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

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