TestStochasticToolsCalculators.C File Reference

Go to the source code of this file.

Functions
template<typename InType , typename OutType >
std::pair< std::vector< OutType >, std::vector< OutType > >	calculate (const InType &x, const std::vector< std::string > &compute)
	TEST (StochasticTools, Calculators)

Function Documentation

calculate()

template<typename InType , typename OutType >

std::pair< std::vector< OutType >, std::vector< OutType > > calculate	(	const InType &	x,
		const std::vector< std::string > &	compute
	)

Definition at line 21 of file TestStochasticToolsCalculators.C.

{
  Parallel::Communicator comm;
  ParallelObject po(comm);
  std::vector<std::unique_ptr<StochasticTools::Calculator<InType, OutType>>> calcs;
  for (const auto & stat : compute)
    calcs.push_back(StochasticTools::makeCalculator<InType, OutType>(stat, po));
 
  std::vector<OutType> result1;
  for (unsigned int i = 0; i < calcs.size(); ++i)
    result1.push_back(calcs[i]->compute(x, false));
 
  std::vector<OutType> result2;
  for (unsigned int i = 0; i < calcs.size(); ++i)
  {
    calcs[i]->initializeCalculator();
    for (const auto & val : x)
      calcs[i]->updateCalculator(val);
    calcs[i]->finalizeCalculator(false);
    result2.push_back(calcs[i]->getValue());
  }
 
  return {result1, result2};
}

TEST()

TEST	(	StochasticTools	,
		Calculators
	)

Definition at line 46 of file TestStochasticToolsCalculators.C.

{
  const std::vector<std::string> compute = {
      "mean", "min", "max", "sum", "stddev", "stderr", "ratio", "norm2", "median"};
 
  {
    const std::vector<Real> x = {6, 1, 7, 3, 4, 5, 2};
    const std::vector<Real> expect = {
        4, 1, 7, 28, 2.1602468994692869408, 0.81649658092772603446, 7, 11.832159566199232259, 4};
 
    auto result = calculate<std::vector<Real>, Real>(x, compute);
    for (unsigned int i = 0; i < expect.size(); ++i)
    {
      EXPECT_EQ(result.first[i], expect[i]);
      EXPECT_EQ(result.second[i], expect[i]);
    }
  }
 
  {
    const std::vector<int> x = {6, 1, 7, 3, 4, 5, 2};
    const std::vector<Real> expect = {
        4, 1, 7, 28, 2.1602468994692869408, 0.81649658092772603446, 7, 11.832159566199232259, 4};
 
    auto result = calculate<std::vector<int>, Real>(x, compute);
    for (unsigned int i = 0; i < expect.size(); ++i)
    {
      EXPECT_EQ(result.first[i], expect[i]);
      EXPECT_EQ(result.second[i], expect[i]);
    }
  }
 
  {
    const std::vector<std::vector<Real>> x = {{6, 1, 7, 3, 4, 5, 2},
                                              {1, 7, 3, 4, 5, 2, 6},
                                              {7, 3, 4, 5, 2, 6, 1},
                                              {3, 4, 5, 2, 6, 1, 7},
                                              {4, 5, 2, 6, 1, 7, 3},
                                              {5, 2, 6, 1, 7, 3, 4},
                                              {2, 6, 1, 7, 3, 4, 5}};
    const std::vector<Real> expect = {
        4, 1, 7, 28, 2.1602468994692869408, 0.81649658092772603446, 7, 11.832159566199232259, 4};
 
    auto result = calculate<std::vector<std::vector<Real>>, std::vector<Real>>(x, compute);
    for (unsigned int i = 0; i < expect.size(); ++i)
      for (unsigned int j = 0; j < x[0].size(); ++j)
      {
        EXPECT_EQ(result.first[i][j], expect[i]);
        EXPECT_EQ(result.second[i][j], expect[i]);
      }
  }
}