NDPseudoRandomNumberGeneratorTest.h

#ifndef NDPSEUDORANDOMNUMBERGENERATORTEST_H_
#define NDPSEUDORANDOMNUMBERGENERATORTEST_H_

#include <cxxtest/TestSuite.h>
#include "MantidKernel/NDPseudoRandomNumberGenerator.h"
#include "MantidKernel/MersenneTwister.h"

#include <boost/algorithm/string/predicate.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>


using Mantid::Kernel::NDRandomNumberGenerator;

class NDPseudoRandomNumberGeneratorTest : public CxxTest::TestSuite
{
private:
  typedef boost::shared_ptr<NDRandomNumberGenerator> NDGenerator_sptr;

public:

  void test_That_Next_Always_Returns_ND_Size_Array()
  {
    NDGenerator_sptr ndRand = createTestGenerator(12345);
    for(int i = 0; i < 20; ++i)
    {
      std::vector<double> point = ndRand->nextPoint();
      TS_ASSERT_EQUALS(static_cast<unsigned int>(point.size()), 3);
    }
  }

  void test_That_Restart_Is_Passed_On_Correctly()
  {
    NDGenerator_sptr ndRand = createTestGenerator(12345);
    std::vector<double> firstPoint = ndRand->nextPoint();
    TS_ASSERT_THROWS_NOTHING(ndRand->restart());
    std::vector<double> firstPointAfterReset = ndRand->nextPoint();
    for(size_t i = 0; i < firstPoint.size(); ++i)
    {
      TS_ASSERT_EQUALS(firstPoint[i], firstPointAfterReset[i]);
    }
  }

  void test_That_Range_Of_SingleValue_Generator_Is_Respected()
  {
    const double start(2.1), end(3.4);
    NDGenerator_sptr ndRand = createTestGenerator(12345, start, end);
    std::vector<double> firstPoint = ndRand->nextPoint();
    for(size_t i = 0; i < firstPoint.size(); ++i)
    {
      TS_ASSERT(firstPoint[i] >= start && firstPoint[i] <= end);
    }
  }

  void test_Save_Call_Restore_Gives_Sequence_From_Saved_Point()
  {
    NDGenerator_sptr ndRand = createTestGenerator(12345);
    doNextValueCalls(25, *ndRand); // Move from start to test it doesn't just go back to beginning
    ndRand->save();
    const size_t ncheck(20);
    auto firstValues = doNextValueCalls(ncheck, *ndRand);
    ndRand->restore();
    auto secondValues = doNextValueCalls(ncheck, *ndRand);

    for(size_t i = 0; i < ncheck; ++i)
    {
      TS_ASSERT(boost::algorithm::equals(firstValues[i], secondValues[i]));
    }
  }


private:
  boost::shared_ptr<NDRandomNumberGenerator> createTestGenerator(const size_t seedValue,
      const double start = -1.0, const double end = -1.0)
  {
    using namespace Mantid::Kernel;
    typedef NDPseudoRandomNumberGenerator<MersenneTwister> NDMersenneTwister;
    const unsigned int ndims(3);
    if(start > 0.0 && end > 0.0)
      return boost::make_shared<NDMersenneTwister>(ndims, seedValue, start, end);
    else
      return boost::make_shared<NDMersenneTwister>(ndims, seedValue);
  }

  std::vector<std::vector<double>> doNextValueCalls(const unsigned int ncalls, NDRandomNumberGenerator &randGen)
  {
    std::vector<std::vector<double>> values(ncalls);
    for(unsigned int i = 0; i < ncalls; ++i)
    {
      values[i] = randGen.nextPoint();
    }
    return values;
  }


};



#endif //NDPSEUDORANDOMNUMBERGENERATORTEST_H_