libs/random/test/test_piecewise_constant_distribution.cpp

   1 /* test_piecewise_constant_distribution.cpp
   2  *
   3  * Copyright Steven Watanabe 2011
   4  * Distributed under the Boost Software License, Version 1.0. (See
   5  * accompanying file LICENSE_1_0.txt or copy at
   6  * http://www.boost.org/LICENSE_1_0.txt)
   7  *
   8  * $Id$
   9  *
  10  */
  11
  12 #include <boost/random/piecewise_constant_distribution.hpp>
  13 #include <boost/random/linear_congruential.hpp>
  14 #include <boost/assign/list_of.hpp>
  15 #include <sstream>
  16 #include <vector>
  17 #include "concepts.hpp"
  18
  19 #define BOOST_TEST_MAIN
  20 #include <boost/test/unit_test.hpp>
  21
  22 using boost::random::test::RandomNumberDistribution;
  23 using boost::random::piecewise_constant_distribution;
  24 BOOST_CONCEPT_ASSERT((RandomNumberDistribution< piecewise_constant_distribution<> >));
  25
  26 struct gen {
  27     double operator()(double arg) {
  28         if(arg < 100) return 100;
  29         else if(arg < 103) return 1;
  30         else if(arg < 107) return 2;
  31         else if(arg < 111) return 1;
  32         else if(arg < 114) return 4;
  33         else return 100;
  34     }
  35 };
  36
  37 #define CHECK_SEQUENCE(actual, expected)            \
  38     do {                                            \
  39         std::vector<double> _actual = (actual);     \
  40         std::vector<double> _expected = (expected); \
  41         BOOST_CHECK_EQUAL_COLLECTIONS(              \
  42             _actual.begin(), _actual.end(),         \
  43             _expected.begin(), _expected.end());    \
  44     } while(false)
  45
  46 using boost::assign::list_of;
  47
  48 BOOST_AUTO_TEST_CASE(test_constructors) {
  49     boost::random::piecewise_constant_distribution<> dist;
  50     CHECK_SEQUENCE(dist.densities(), list_of(1.0));
  51     CHECK_SEQUENCE(dist.intervals(), list_of(0.0)(1.0));
  52
  53 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
  54     boost::random::piecewise_constant_distribution<> dist_il = {
  55         { 99, 103, 107, 111, 115 },
  56         gen()
  57     };
  58     CHECK_SEQUENCE(dist_il.intervals(), list_of(99)(103)(107)(111)(115));
  59     CHECK_SEQUENCE(dist_il.densities(), list_of(.03125)(.0625)(.03125)(.125));
  60
  61     boost::random::piecewise_constant_distribution<> dist_il2 = {
  62         { 99 },
  63         gen()
  64     };
  65     CHECK_SEQUENCE(dist_il2.intervals(), list_of(0.0)(1.0));
  66     CHECK_SEQUENCE(dist_il2.densities(), list_of(1.0));
  67 #endif
  68     std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
  69     std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
  70     std::vector<double> intervals2 = boost::assign::list_of(99);
  71     std::vector<double> weights2;
  72
  73     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
  74     CHECK_SEQUENCE(dist_r.intervals(), list_of(0)(1)(2)(3)(5));
  75     CHECK_SEQUENCE(dist_r.densities(), list_of(.125)(.25)(.125)(.25));
  76
  77     boost::random::piecewise_constant_distribution<>
  78         dist_r2(intervals2, weights2);
  79     CHECK_SEQUENCE(dist_r2.intervals(), list_of(0.0)(1.0));
  80     CHECK_SEQUENCE(dist_r2.densities(), list_of(1.0));
  81
  82     boost::random::piecewise_constant_distribution<> dist_it(
  83         intervals.begin(), intervals.end(), weights.begin());
  84     CHECK_SEQUENCE(dist_it.intervals(), list_of(0)(1)(2)(3)(5));
  85     CHECK_SEQUENCE(dist_it.densities(), list_of(.125)(.25)(.125)(.25));
  86
  87     boost::random::piecewise_constant_distribution<> dist_it2(
  88         intervals2.begin(), intervals2.end(), weights2.begin());
  89     CHECK_SEQUENCE(dist_it2.intervals(), list_of(0.0)(1.0));
  90     CHECK_SEQUENCE(dist_it2.densities(), list_of(1.0));
  91
  92     boost::random::piecewise_constant_distribution<> dist_fun(4, 99,115, gen());
  93     CHECK_SEQUENCE(dist_fun.intervals(), list_of(99)(103)(107)(111)(115));
  94     CHECK_SEQUENCE(dist_fun.densities(), list_of(.03125)(.0625)(.03125)(.125));
  95
  96     boost::random::piecewise_constant_distribution<>
  97         dist_fun2(1, 99, 115, gen());
  98     CHECK_SEQUENCE(dist_fun2.intervals(), list_of(99)(115));
  99     CHECK_SEQUENCE(dist_fun2.densities(), list_of(0.0625));
 100
 101     boost::random::piecewise_constant_distribution<> copy(dist);
 102     BOOST_CHECK_EQUAL(dist, copy);
 103     boost::random::piecewise_constant_distribution<> copy_r(dist_r);
 104     BOOST_CHECK_EQUAL(dist_r, copy_r);
 105
 106     boost::random::piecewise_constant_distribution<> notpow2(3, 99, 111, gen());
 107     BOOST_REQUIRE_EQUAL(notpow2.densities().size(), 3u);
 108     BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[0], 0.0625, 0.00000000001);
 109     BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[1], 0.125, 0.00000000001);
 110     BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[2], 0.0625, 0.00000000001);
 111     boost::random::piecewise_constant_distribution<> copy_notpow2(notpow2);
 112     BOOST_CHECK_EQUAL(notpow2, copy_notpow2);
 113 }
 114
 115 BOOST_AUTO_TEST_CASE(test_param) {
 116     std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
 117     std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
 118     std::vector<double> intervals2 = boost::assign::list_of(0);
 119     std::vector<double> weights2;
 120     boost::random::piecewise_constant_distribution<> dist(intervals, weights);
 121     boost::random::piecewise_constant_distribution<>::param_type
 122         param = dist.param();
 123     CHECK_SEQUENCE(param.intervals(), list_of(0)(1)(2)(3)(5));
 124     CHECK_SEQUENCE(param.densities(), list_of(.125)(.25)(.125)(.25));
 125     boost::random::piecewise_constant_distribution<> copy1(param);
 126     BOOST_CHECK_EQUAL(dist, copy1);
 127     boost::random::piecewise_constant_distribution<> copy2;
 128     copy2.param(param);
 129     BOOST_CHECK_EQUAL(dist, copy2);
 130
 131     boost::random::piecewise_constant_distribution<>::param_type
 132         param_copy = param;
 133     BOOST_CHECK_EQUAL(param, param_copy);
 134     BOOST_CHECK(param == param_copy);
 135     BOOST_CHECK(!(param != param_copy));
 136     boost::random::piecewise_constant_distribution<>::param_type param_default;
 137     CHECK_SEQUENCE(param_default.intervals(), list_of(0.0)(1.0));
 138     CHECK_SEQUENCE(param_default.densities(), list_of(1.0));
 139     BOOST_CHECK(param != param_default);
 140     BOOST_CHECK(!(param == param_default));
 141
 142 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
 143     boost::random::piecewise_constant_distribution<>::param_type parm_il = {
 144         { 99, 103, 107, 111, 115 },
 145         gen()
 146     };
 147     CHECK_SEQUENCE(parm_il.intervals(), list_of(99)(103)(107)(111)(115));
 148     CHECK_SEQUENCE(parm_il.densities(), list_of(.03125)(.0625)(.03125)(.125));
 149
 150     boost::random::piecewise_constant_distribution<>::param_type parm_il2 = {
 151         { 99 },
 152         gen()
 153     };
 154     CHECK_SEQUENCE(parm_il2.intervals(), list_of(0.0)(1.0));
 155     CHECK_SEQUENCE(parm_il2.densities(), list_of(1.0));
 156 #endif
 157
 158     boost::random::piecewise_constant_distribution<>::param_type
 159         parm_r(intervals, weights);
 160     CHECK_SEQUENCE(parm_r.intervals(), list_of(0)(1)(2)(3)(5));
 161     CHECK_SEQUENCE(parm_r.densities(), list_of(.125)(.25)(.125)(.25));
 162
 163     boost::random::piecewise_constant_distribution<>::param_type
 164         parm_r2(intervals2, weights2);
 165     CHECK_SEQUENCE(parm_r2.intervals(), list_of(0.0)(1.0));
 166     CHECK_SEQUENCE(parm_r2.densities(), list_of(1.0));
 167
 168     boost::random::piecewise_constant_distribution<>::param_type
 169         parm_it(intervals.begin(), intervals.end(), weights.begin());
 170     CHECK_SEQUENCE(parm_it.intervals(), list_of(0)(1)(2)(3)(5));
 171     CHECK_SEQUENCE(parm_it.densities(), list_of(.125)(.25)(.125)(.25));
 172
 173     boost::random::piecewise_constant_distribution<>::param_type
 174         parm_it2(intervals2.begin(), intervals2.end(), weights2.begin());
 175     CHECK_SEQUENCE(parm_it2.intervals(), list_of(0.0)(1.0));
 176     CHECK_SEQUENCE(parm_it2.densities(), list_of(1.0));
 177
 178     boost::random::piecewise_constant_distribution<>::param_type
 179         parm_fun(4, 99, 115, gen());
 180     CHECK_SEQUENCE(parm_fun.intervals(), list_of(99)(103)(107)(111)(115));
 181     CHECK_SEQUENCE(parm_fun.densities(), list_of(.03125)(.0625)(.03125)(.125));
 182
 183     boost::random::piecewise_constant_distribution<>::param_type
 184         parm_fun2(1, 99, 115, gen());
 185     CHECK_SEQUENCE(parm_fun2.intervals(), list_of(99)(115));
 186     CHECK_SEQUENCE(parm_fun2.densities(), list_of(0.0625));
 187 }
 188
 189 BOOST_AUTO_TEST_CASE(test_min_max) {
 190     std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
 191     std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
 192     boost::random::piecewise_constant_distribution<> dist;
 193     BOOST_CHECK_EQUAL((dist.min)(), 0.0);
 194     BOOST_CHECK_EQUAL((dist.max)(), 1.0);
 195     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
 196     BOOST_CHECK_EQUAL((dist_r.min)(), 0.0);
 197     BOOST_CHECK_EQUAL((dist_r.max)(), 5.0);
 198 }
 199
 200 BOOST_AUTO_TEST_CASE(test_comparison) {
 201     std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
 202     std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
 203     boost::random::piecewise_constant_distribution<> dist;
 204     boost::random::piecewise_constant_distribution<> dist_copy(dist);
 205     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
 206     boost::random::piecewise_constant_distribution<> dist_r_copy(dist_r);
 207     BOOST_CHECK(dist == dist_copy);
 208     BOOST_CHECK(!(dist != dist_copy));
 209     BOOST_CHECK(dist_r == dist_r_copy);
 210     BOOST_CHECK(!(dist_r != dist_r_copy));
 211     BOOST_CHECK(dist != dist_r);
 212     BOOST_CHECK(!(dist == dist_r));
 213 }
 214
 215 BOOST_AUTO_TEST_CASE(test_streaming) {
 216     std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
 217     std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
 218     boost::random::piecewise_constant_distribution<> dist(intervals, weights);
 219     std::stringstream stream;
 220     stream << dist;
 221     boost::random::piecewise_constant_distribution<> restored_dist;
 222     stream >> restored_dist;
 223     BOOST_CHECK_EQUAL(dist, restored_dist);
 224 }
 225
 226 BOOST_AUTO_TEST_CASE(test_generation) {
 227     std::vector<double> intervals = boost::assign::list_of(1)(2);
 228     std::vector<double> weights = boost::assign::list_of(1);
 229     boost::minstd_rand0 gen;
 230     boost::random::piecewise_constant_distribution<> dist;
 231     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
 232     for(int i = 0; i < 10; ++i) {
 233         double value = dist(gen);
 234         BOOST_CHECK_GE(value, 0.0);
 235         BOOST_CHECK_LT(value, 1.0);
 236         double value_r = dist_r(gen);
 237         BOOST_CHECK_GE(value_r, 1.0);
 238         BOOST_CHECK_LT(value_r, 2.0);
 239         double value_param = dist_r(gen, dist.param());
 240         BOOST_CHECK_GE(value_param, 0.0);
 241         BOOST_CHECK_LT(value_param, 1.0);
 242         double value_r_param = dist(gen, dist_r.param());
 243         BOOST_CHECK_GE(value_r_param, 1.0);
 244         BOOST_CHECK_LT(value_r_param, 2.0);
 245     }
 246 }