root/lang/cplusplus/boost-supplement/trunk/libs/random/test_discrete_distribution.cpp @ 5902

/* test for boost_supplement random/discrete_distribution.hpp
 *
 * Copyright (C) 2008 Kenta Murata.
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * $Id$
 * 
 */

#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>

#include <boost_supplement/random/discrete_distribution.hpp>

#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/comparison/not_equal.hpp>
#include <boost/preprocessor/repetition/for.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
                                                                \
#include <boost/test/floating_point_comparison.hpp>
#include <boost/tuple/tuple.hpp>

#include <iostream>

template<class Iterator>
void
iterator_out(Iterator first, Iterator last)
{
  std::cout << *first;
  while (++first != last) {
    std::cout << ", " << *first;
  }
  std::cout << std::endl;
}

BOOST_AUTO_TEST_CASE(test_discrete_distribution_from_probability)
{
  double const pdf[16] = {
    0.0 / 36.0, // 0
    0.0 / 36.0, // 1
    1.0 / 36.0, // 2
    2.0 / 36.0, // 3
    3.0 / 36.0, // 4
    4.0 / 36.0, // 5
    5.0 / 36.0, // 6
    6.0 / 36.0, // 7
    5.0 / 36.0, // 8
    4.0 / 36.0, // 9
    3.0 / 36.0, // 10
    2.0 / 36.0, // 11
    1.0 / 36.0, // 12
    0.0 / 36.0, // 13
    0.0 / 36.0, // 14
    0.0 / 36.0  // 15
  };

  bs::discrete_distribution<> dd(pdf, pdf + 16, true);

  bs::discrete_distribution<>::probability_iterator pi, pi_end;
  boost::tie(pi, pi_end) = dd.probabilities();
  iterator_out(pi, pi_end);

  bs::discrete_distribution<>::alias_iterator ai, ai_end;
  boost::tie(ai, ai_end) = dd.aliases();
  iterator_out(ai, ai_end);

  double pdf2[16];
  for (int i = 0; i < 16; ++i) {
    bs::discrete_distribution<>::probability_iterator p(pi);
    std::advance(p, i);
    pdf2[i] = *p;

    for (int j = 0; j < 16; ++j) {
      if (i == j) continue;
      bs::discrete_distribution<>::alias_iterator a(ai);
      std::advance(a, j);
      if (*a == i) {
        p = pi;
        std::advance(p, j);
        pdf2[i] += 1.0 - *p;
      }
    }
    pdf2[i] /= 16.0;
  }

#define PRED(r, state)                                  \
  BOOST_PP_NOT_EQUAL(                                   \
    BOOST_PP_TUPLE_ELEM(2, 0, state),                   \
    BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 1, state))      \
    )
#define OP(r, state) \
  (                                                     \
    BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 0, state)),     \
    BOOST_PP_TUPLE_ELEM(2, 1, state)                    \
    )
#define MACRO(r, state)                                         \
  BOOST_CHECK_CLOSE(pdf2[BOOST_PP_TUPLE_ELEM(2, 0, state)],     \
                    pdf[BOOST_PP_TUPLE_ELEM(2, 0, state)],      \
                    1e-9);
  BOOST_PP_FOR((0, 15), PRED, OP, MACRO);
#undef MACRO
#undef OP
#undef PRED
}

BOOST_AUTO_TEST_CASE(test_discrete_distribution_from_weight)
{
  const double pdf[16] = {
    0.0, // 0
    0.0, // 1
    1.0, // 2
    2.0, // 3
    3.0, // 4
    4.0, // 5
    5.0, // 6
    6.0, // 7
    5.0, // 8
    4.0, // 9
    3.0, // 10
    2.0, // 11
    1.0, // 12
    0.0, // 13
    0.0, // 14
    0.0  // 15
  };

  bs::discrete_distribution<> dd(pdf, pdf + 16);

  bs::discrete_distribution<>::probability_iterator pi, pi_end;
  boost::tie(pi, pi_end) = dd.probabilities();
  iterator_out(pi, pi_end);

  bs::discrete_distribution<>::alias_iterator ai, ai_end;
  boost::tie(ai, ai_end) = dd.aliases();
  iterator_out(ai, ai_end);

  double pdf2[16];
  for (int i = 0; i < 16; ++i) {
    bs::discrete_distribution<>::probability_iterator p(pi);
    std::advance(p, i);
    pdf2[i] = *p;

    for (int j = 0; j < 16; ++j) {
      if (i == j) continue;
      bs::discrete_distribution<>::alias_iterator a(ai);
      std::advance(a, j);
      if (*a == i) {
        p = pi;
        std::advance(p, j);
        pdf2[i] += 1.0 - *p;
      }
    }
    pdf2[i] /= 16.0;
  }

#define PRED(r, state)                                  \
  BOOST_PP_NOT_EQUAL(                                   \
    BOOST_PP_TUPLE_ELEM(2, 0, state),                   \
    BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 1, state))      \
    )
#define OP(r, state) \
  (                                                     \
    BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 0, state)),     \
    BOOST_PP_TUPLE_ELEM(2, 1, state)                    \
    )
#define MACRO(r, state)                                         \
  BOOST_CHECK_CLOSE(pdf2[BOOST_PP_TUPLE_ELEM(2, 0, state)],     \
                    pdf[BOOST_PP_TUPLE_ELEM(2, 0, state)]/36.0, \
                    1e-9);
  BOOST_PP_FOR((0, 15), PRED, OP, MACRO);
#undef MACRO
#undef OP
#undef PRED
}

/*
 * Local Variables:
 * coding: utf-8
 * mode: c++
 * c-basic-offset: 2
 * indent-tabs-mode: nil
 * End:
 */