libs/histogram/test/detail_axes_test.cpp

   1 // Copyright 2015-2017 Hans Dembinski
   2 //
   3 // Distributed under the Boost Software License, Version 1.0.
   4 // (See accompanying file LICENSE_1_0.txt
   5 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #include <array>
   8 #include <boost/core/lightweight_test.hpp>
   9 #include <boost/core/lightweight_test_trait.hpp>
  10 #include <boost/histogram/axis.hpp>
  11 #include <boost/histogram/axis/ostream.hpp>
  12 #include <boost/histogram/detail/axes.hpp>
  13 #include <limits>
  14 #include <tuple>
  15 #include <utility>
  16 #include <vector>
  17 #include "std_ostream.hpp"
  18 #include "throw_exception.hpp"
  19
  20 using namespace boost::histogram;
  21
  22 int main() {
  23   // dynamic axis_get with tuples
  24   {
  25     auto a1 = axis::integer<>(0, 1);
  26     auto a2 = axis::integer<>(1, 2);
  27     auto tup = std::make_tuple(a1, a2);
  28     using E1 = axis::variant<axis::integer<>*>;
  29     BOOST_TEST_TRAIT_SAME(decltype(detail::axis_get(tup, 0)), E1);
  30     BOOST_TEST_EQ(detail::axis_get(tup, 0), a1);
  31     BOOST_TEST_EQ(detail::axis_get(tup, 1), a2);
  32     BOOST_TEST_NE(detail::axis_get(tup, 0), a2);
  33   }
  34
  35   // sequence equality
  36   {
  37     using R = axis::regular<>;
  38     using I = axis::integer<>;
  39     using V = axis::variable<>;
  40     auto r = R(2, -1, 1);
  41     auto i = I(-1, 1);
  42     auto v = V{-1, 0, 1};
  43
  44     std::vector<axis::variant<R, I, V>> v1 = {r, i};
  45     std::vector<axis::variant<R, I>> v2 = {r, i};
  46     std::vector<axis::variant<R, I>> v3 = {i, r};
  47     std::vector<axis::variant<I, R>> v4 = {r, i};
  48     std::vector<axis::variant<R, I>> v5 = {r, r};
  49     std::vector<R> v6 = {r, r};
  50
  51     BOOST_TEST(detail::axes_equal(v1, v2));
  52     BOOST_TEST(detail::axes_equal(v1, v4));
  53     BOOST_TEST(detail::axes_equal(v5, v6));
  54     BOOST_TEST_NOT(detail::axes_equal(v1, v3));
  55     BOOST_TEST_NOT(detail::axes_equal(v2, v3));
  56     BOOST_TEST_NOT(detail::axes_equal(v3, v4));
  57     BOOST_TEST_NOT(detail::axes_equal(v1, v5));
  58
  59     auto t1 = std::make_tuple(r, i);
  60     auto t2 = std::make_tuple(i, r);
  61     auto t3 = std::make_tuple(v, i);
  62     auto t4 = std::make_tuple(r, r);
  63
  64     BOOST_TEST(detail::axes_equal(t1, v1));
  65     BOOST_TEST(detail::axes_equal(t1, v2));
  66     BOOST_TEST(detail::axes_equal(t1, v4));
  67     BOOST_TEST(detail::axes_equal(v1, t1));
  68     BOOST_TEST(detail::axes_equal(v2, t1));
  69     BOOST_TEST(detail::axes_equal(v4, t1));
  70     BOOST_TEST(detail::axes_equal(t2, v3));
  71     BOOST_TEST(detail::axes_equal(v3, t2));
  72     BOOST_TEST(detail::axes_equal(t4, v5));
  73     BOOST_TEST(detail::axes_equal(t4, v6));
  74     BOOST_TEST_NOT(detail::axes_equal(t1, t2));
  75     BOOST_TEST_NOT(detail::axes_equal(t2, t3));
  76     BOOST_TEST_NOT(detail::axes_equal(t1, v3));
  77     BOOST_TEST_NOT(detail::axes_equal(t1, v3));
  78     BOOST_TEST_NOT(detail::axes_equal(t3, v1));
  79     BOOST_TEST_NOT(detail::axes_equal(t3, v2));
  80     BOOST_TEST_NOT(detail::axes_equal(t3, v3));
  81     BOOST_TEST_NOT(detail::axes_equal(t3, v4));
  82   }
  83
  84   // sequence assign
  85   {
  86     using R = axis::regular<>;
  87     using I = axis::integer<>;
  88     using V = axis::variable<>;
  89     auto r = R(2, -1, 1);
  90     auto i = I(-1, 1);
  91     auto v = V{-1, 0, 1};
  92
  93     std::vector<axis::variant<R, V, I>> v1 = {r, i};
  94     std::vector<axis::variant<I, R>> v2;
  95     std::vector<R> v3 = {r, r};
  96
  97     BOOST_TEST_NOT(detail::axes_equal(v2, v1));
  98     detail::axes_assign(v2, v1);
  99     BOOST_TEST(detail::axes_equal(v2, v1));
 100     detail::axes_assign(v2, v3);
 101     BOOST_TEST(detail::axes_equal(v2, v3));
 102
 103     auto t1 = std::make_tuple(r);
 104     detail::axes_assign(v3, t1);
 105     BOOST_TEST(detail::axes_equal(v3, t1));
 106
 107     auto t2 = std::make_tuple(r, i);
 108     detail::axes_assign(v2, t2);
 109     BOOST_TEST(detail::axes_equal(v2, t2));
 110
 111     auto t3 = std::make_tuple(R{3, -1, 1}, i);
 112     BOOST_TEST_NOT(detail::axes_equal(t2, t3));
 113     detail::axes_assign(t2, t3);
 114     BOOST_TEST(detail::axes_equal(t2, t3));
 115   }
 116
 117   // axes_rank
 118   {
 119     std::tuple<int, int> a;
 120     std::vector<int> b(3);
 121     std::array<int, 4> c;
 122     const std::tuple<int> d;
 123     BOOST_TEST_EQ(detail::axes_rank(a), 2);
 124     BOOST_TEST_EQ(detail::axes_rank(b), 3);
 125     BOOST_TEST_EQ(detail::axes_rank(c), 4);
 126     BOOST_TEST_EQ(detail::axes_rank(d), 1);
 127   }
 128
 129   // bincount overflow
 130   {
 131     auto v = std::vector<axis::integer<>>(
 132         100, axis::integer<>(0, (std::numeric_limits<int>::max)() - 2));
 133     BOOST_TEST_THROWS(detail::bincount(v), std::overflow_error);
 134   }
 135
 136   // has_growing_axis
 137   {
 138     struct growing {
 139       auto update(int) { return std::make_pair(0, 0); }
 140     };
 141     using T = growing;
 142     using I = axis::integer<>;
 143
 144     using A = std::tuple<I, T>;
 145     using B = std::vector<T>;
 146     using C = std::vector<axis::variant<I, T>>;
 147     using D = std::tuple<I>;
 148     using E = std::vector<I>;
 149     using F = std::vector<axis::variant<I>>;
 150
 151     BOOST_TEST_TRAIT_TRUE((detail::has_growing_axis<A>));
 152     BOOST_TEST_TRAIT_TRUE((detail::has_growing_axis<B>));
 153     BOOST_TEST_TRAIT_TRUE((detail::has_growing_axis<C>));
 154     BOOST_TEST_TRAIT_FALSE((detail::has_growing_axis<D>));
 155     BOOST_TEST_TRAIT_FALSE((detail::has_growing_axis<E>));
 156     BOOST_TEST_TRAIT_FALSE((detail::has_growing_axis<F>));
 157   }
 158
 159   // value_types
 160   {
 161     using R = axis::regular<float>;
 162     using I = axis::integer<int>;
 163     using CI = axis::category<int>;
 164     using CS = axis::category<std::string>;
 165     using A = std::vector<axis::variant<R, I, CS>>;
 166     using B = std::vector<axis::variant<CS, I, CI, R>>;
 167     using C = std::tuple<I, R, CS>;
 168     using D = std::tuple<CS, I, CI, R>;
 169     using Expected = boost::mp11::mp_list<int, float, std::string>;
 170     BOOST_TEST_TRAIT_SAME(detail::value_types<A>, Expected);
 171     BOOST_TEST_TRAIT_SAME(detail::value_types<B>, Expected);
 172     BOOST_TEST_TRAIT_SAME(detail::value_types<C>, Expected);
 173     BOOST_TEST_TRAIT_SAME(detail::value_types<D>, Expected);
 174   }
 175
 176   return boost::report_errors();
 177 }