diff --git a/examples/sizeof.cpp b/examples/sizeof.cpp index 9a9d8016..08f541c9 100644 --- a/examples/sizeof.cpp +++ b/examples/sizeof.cpp @@ -1,7 +1,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -17,6 +19,7 @@ int main(int argc, char** argv) { SIZEOF(float); SIZEOF(double); SIZEOF(void*); + SIZEOF(detail::wtype); SIZEOF(boost::multiprecision::int128_t); SIZEOF(boost::multiprecision::int512_t); SIZEOF(boost::multiprecision::cpp_int); @@ -24,6 +27,8 @@ int main(int argc, char** argv) { SIZEOF(std::vector); SIZEOF(std::valarray); SIZEOF(boost::container::vector); + typedef boost::container::static_vector static_vector_a16; + SIZEOF(static_vector_a16); SIZEOF(boost::scoped_array); SIZEOF(regular_axis); SIZEOF(polar_axis); diff --git a/examples/speed_vs_root.cpp b/examples/speed_vs_root.cpp index 4ce0c8a2..086aef88 100644 --- a/examples/speed_vs_root.cpp +++ b/examples/speed_vs_root.cpp @@ -124,13 +124,12 @@ void compare_6d(unsigned n) regular_axis(10, 0, 1), regular_axis(10, 0, 1), regular_axis(10, 0, 1)); - double y[6]; t = clock(); for (unsigned i = 0; i < n; ++i) { for (unsigned k = 0; k < 6; ++k) - y[k] = r[6 * i + k]; - h.fill(6, y); + x[k] = r[6 * i + k]; + h.fill_c(6, x); } t = clock() - t; best_boost = std::min(best_boost, double(t) / CLOCKS_PER_SEC); diff --git a/include/boost/histogram/detail/nstore.hpp b/include/boost/histogram/detail/nstore.hpp index 5e52a719..470e3e34 100644 --- a/include/boost/histogram/detail/nstore.hpp +++ b/include/boost/histogram/detail/nstore.hpp @@ -49,12 +49,13 @@ public: BOOST_HISTOGRAM_NSTORE_INC(uint32_t); BOOST_HISTOGRAM_NSTORE_INC(uint64_t); #undef BOOST_HISTOGRAM_NSTORE_INC - default: assert(!"invalid depth"); + default: BOOST_ASSERT(!"invalid depth"); } } inline void increase(size_type i, double w) { - assert(depth_ == sizeof(wtype)); + if (depth_ != sizeof(wtype)) + wconvert(); ((wtype*)buffer_)[i] += w; } @@ -84,7 +85,7 @@ private: BOOST_HISTOGRAM_NSTORE_CASE(uint32_t); BOOST_HISTOGRAM_NSTORE_CASE(uint64_t); #undef BOOST_HISTOGRAM_NSTORE_CASE - default: assert(!"invalid depth"); + default: BOOST_ASSERT(!"invalid depth"); } return 0; } @@ -127,7 +128,7 @@ private: BOOST_HISTOGRAM_NSTORE_SAVE(uint64_t); BOOST_HISTOGRAM_NSTORE_SAVE(wtype); #undef BOOST_HISTOGRAM_NSTORE_SAVE - default: assert(!"invalid depth"); + default: BOOST_ASSERT(!"invalid depth"); } } @@ -150,7 +151,7 @@ private: BOOST_HISTOGRAM_NSTORE_LOAD(uint64_t); BOOST_HISTOGRAM_NSTORE_LOAD(wtype); #undef BOOST_HISTOGRAM_NSTORE_LOAD - default: assert(!"invalid depth"); + default: BOOST_ASSERT(!"invalid depth"); } } } diff --git a/include/boost/histogram/histogram.hpp b/include/boost/histogram/histogram.hpp index ed817406..a1f946da 100644 --- a/include/boost/histogram/histogram.hpp +++ b/include/boost/histogram/histogram.hpp @@ -11,6 +11,7 @@ #include #include #include +#include namespace boost { namespace histogram { @@ -30,22 +31,11 @@ public: // generates constructors taking 1 to AXIS_LIMIT arguments BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_CTOR, nil) - // template - // inline - // void - // fill(const C& v) - // { - // BOOST_ASSERT(v.size() == dim()); - // const size_type k = pos(v); - // if (k != uintmax_t(-1)) - // data_.increase(k); - // } - // C-style call inline - void fill(unsigned n, const double* v) + void fill_c(unsigned n, const double* v) { - BOOST_ASSERT(n == dim()); + BOOST_ASSERT_MSG(n == dim(), "wrong number of arguments"); const size_type k = pos(v); if (k != uintmax_t(-1)) data_.increase(k); @@ -56,27 +46,17 @@ BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_CTOR, nil void fill( BOOST_PP_ENUM_PARAMS_Z(z, n, double x) ) \ { \ const double buffer[n] = { BOOST_PP_ENUM_PARAMS(n, x) }; \ - fill(n, buffer); /* size is checked here */ \ + fill_c(n, buffer); /* size is checked here */ \ } // generates fill functions taking 1 to AXIS_LIMT arguments BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_FILL, nil) - // template - // inline - // void wfill(const Container& v, double w) - // { - // BOOST_ASSERT(v.size() == dim()); - // const size_type k = pos(v); - // if (k != uintmax_t(-1)) - // data_.increase(k, w); - // } - // C-style call inline - void wfill(unsigned n, const double* v, double w) + void wfill_c(unsigned n, const double* v, double w) { - BOOST_ASSERT(n == dim()); + BOOST_ASSERT_MSG(n == dim(), "wrong number of arguments"); const size_type k = pos(v); if (k != uintmax_t(-1)) data_.increase(k, w); @@ -87,27 +67,18 @@ BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_FILL, nil void wfill( BOOST_PP_ENUM_PARAMS_Z(z, n, double x), double w ) \ { \ const double buffer[n] = { BOOST_PP_ENUM_PARAMS(n, x) }; \ - wfill(n, buffer, w); /* size is checked here */ \ + wfill_c(n, buffer, w); /* size is checked here */ \ } // generates wfill functions taking 1 to AXIS_LIMT arguments BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_WFILL, nil) - // template - // inline - // double value(const Container& idx) - // const - // { - // BOOST_ASSERT(idx.size() == dim()); - // return data_.value(linearize(idx)); - // } - // C-style call inline - double value(unsigned n, const int* idx) + double value_c(unsigned n, const int* idx) const { - BOOST_ASSERT(n == dim()); + BOOST_ASSERT_MSG(n == dim(), "wrong number of arguments"); return data_.value(linearize(idx)); } @@ -117,27 +88,18 @@ BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_WFILL, ni const \ { \ const int idx[n] = { BOOST_PP_ENUM_PARAMS_Z(z, n, i) }; \ - return value(n, idx); /* size is checked here */ \ + return value_c(n, idx); /* size is checked here */ \ } // generates value functions taking 1 to AXIS_LIMT arguments BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_VALUE, nil) - // template - // inline - // double variance(const Container& idx) - // const - // { - // BOOST_ASSERT(idx.size() == dim()); - // return data_.variance(linearize(idx)); - // } - // C-style call inline - double variance(unsigned n, const int* idx) + double variance_c(unsigned n, const int* idx) const { - BOOST_ASSERT(n == dim()); + BOOST_ASSERT_MSG(n == dim(), "wrong number of arguments"); return data_.variance(linearize(idx)); } @@ -147,7 +109,7 @@ BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_VALUE, ni const \ { \ const int idx[n] = { BOOST_PP_ENUM_PARAMS_Z(z, n, i) }; \ - return variance(n, idx); /* size is checked here */ \ + return variance_c(n, idx); /* size is checked here */ \ } // generates variance functions taking 1 to AXIS_LIMT arguments @@ -162,7 +124,12 @@ BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_VARIANCE, data_ == o.data_; } histogram& operator+=(const histogram& o) - { data_ += o.data_; return *this; } + { + if (!histogram_base::operator==(o)) + throw std::logic_error("histograms have different axes"); + data_ += o.data_; + return *this; + } private: detail::nstore data_; diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp index 6d040775..2b294043 100644 --- a/src/python/histogram.cpp +++ b/src/python/histogram.cpp @@ -24,8 +24,8 @@ histogram_init(python::tuple args, python::dict kwargs) { object pyinit = self.attr("__init__"); if (kwargs) { - PyErr_SetString(PyExc_TypeError, "no keyword arguments allowed"); - throw_error_already_set(); + PyErr_SetString(PyExc_RuntimeError, "no keyword arguments allowed"); + throw_error_already_set(); } // normal constructor @@ -55,6 +55,10 @@ histogram_fill(python::tuple args, python::dict kwargs) { const unsigned nargs = len(args); histogram& self = extract(args[0]); + object ow; + if (kwargs) + ow = kwargs["w"]; + #ifdef USE_NUMPY if (nargs == 2) { object o = args[1]; @@ -86,9 +90,40 @@ histogram_fill(python::tuple args, python::dict kwargs) { throw_error_already_set(); } - for (unsigned i = 0; i < dims[0]; ++i) { - double* v = (double*)PyArray_GETPTR1(a, i); - self.fill(self.dim(), v); + PyArrayObject* aw = 0; + if (!ow.is_none()) { + if (PySequence_Check(ow.ptr())) { + PyArrayObject* aw = (PyArrayObject*) + PyArray_FROM_OTF(ow.ptr(), NPY_DOUBLE, NPY_ARRAY_IN_ARRAY); + if (!aw) { + PyErr_SetString(PyExc_ValueError, "could not convert sequence into array"); + throw_error_already_set(); + } + + if (PyArray_NDIM(aw) != 1) { + PyErr_SetString(PyExc_ValueError, "array has to be one-dimensional"); + throw_error_already_set(); + } + + if (PyArray_DIMS(aw)[0] != dims[0]) { + PyErr_SetString(PyExc_ValueError, "sizes do not match"); + throw_error_already_set(); + } + } + } + + if (aw) { + for (unsigned i = 0; i < dims[0]; ++i) { + double* v = (double*)PyArray_GETPTR1(a, i); + double* w = (double*)PyArray_GETPTR1(aw, i); + self.wfill_c(self.dim(), v, *w); + } + Py_DECREF(aw); + } else { + for (unsigned i = 0; i < dims[0]; ++i) { + double* v = (double*)PyArray_GETPTR1(a, i); + self.fill_c(self.dim(), v); + } } Py_DECREF(a); @@ -99,40 +134,66 @@ histogram_fill(python::tuple args, python::dict kwargs) { const unsigned dim = nargs - 1; if (dim != self.dim()) { - PyErr_SetString(PyExc_TypeError, "wrong number of arguments"); + PyErr_SetString(PyExc_RuntimeError, "wrong number of arguments"); throw_error_already_set(); } - if (kwargs) { - PyErr_SetString(PyExc_TypeError, "no keyword arguments allowed"); - throw_error_already_set(); - } - double v[BOOST_HISTOGRAM_AXIS_LIMIT]; for (unsigned i = 0; i < dim; ++i) v[i] = extract(args[1 + i]); - self.fill(self.dim(), v); + + if (ow.is_none()) { + self.fill_c(self.dim(), v); + } else { + const double w = extract(ow); + self.wfill_c(self.dim(), v, w); + } + return object(); } -uint64_t -histogram_getitem(const histogram& self, python::object oidx) { +python::object +histogram_value(python::tuple args, python::dict kwargs) { using namespace python; + const histogram& self = extract(args[0]); - if (self.dim() == 1) - return self.value(extract(oidx)()); - - const unsigned dim = len(oidx); - if (dim != self.dim()) { + if (self.dim() != (len(args) - 1)) { PyErr_SetString(PyExc_RuntimeError, "wrong number of arguments"); throw_error_already_set(); } - int idx[BOOST_HISTOGRAM_AXIS_LIMIT]; - for (unsigned i = 0; i < dim; ++i) - idx[i] = extract(oidx[i]); + if (kwargs) { + PyErr_SetString(PyExc_ValueError, "no keyword arguments allowed"); + throw_error_already_set(); + } - return self.value(self.dim(), idx); + int idx[BOOST_HISTOGRAM_AXIS_LIMIT]; + for (unsigned i = 0; i < self.dim(); ++i) + idx[i] = extract(args[1 + i]); + + return object(self.value_c(self.dim(), idx)); +} + +python::object +histogram_variance(python::tuple args, python::dict kwargs) { + using namespace python; + const histogram& self = extract(args[0]); + + if (self.dim() != (len(args) - 1)) { + PyErr_SetString(PyExc_RuntimeError, "wrong number of arguments"); + throw_error_already_set(); + } + + if (kwargs) { + PyErr_SetString(PyExc_RuntimeError, "no keyword arguments allowed"); + throw_error_already_set(); + } + + int idx[BOOST_HISTOGRAM_AXIS_LIMIT]; + for (unsigned i = 0; i < self.dim(); ++i) + idx[i] = extract(args[1 + i]); + + return object(self.variance_c(self.dim(), idx)); } class histogram_access { @@ -140,12 +201,17 @@ public: static python::dict histogram_array_interface(histogram& self) { + python::dict d; python::list shape; for (unsigned i = 0; i < self.dim(); ++i) shape.append(self.shape(i)); - python::dict d; + if (self.data_.depth() == sizeof(detail::wtype)) { + shape.append(2); + d["typestr"] = python::str(" 0, 1 + h.wfill(-1, -1, 10); // -> 0, 0 + h.wfill(-1, -10, 5); // is ignored + h.wfill(-10, 0, 7); // -> -1, 1 + + BOOST_CHECK_EQUAL(h.sum(), 18); + + BOOST_CHECK_EQUAL(h.value(-1, 0), 0.0); + BOOST_CHECK_EQUAL(h.value(-1, 1), 7.0); + BOOST_CHECK_EQUAL(h.value(-1, 2), 0.0); + + BOOST_CHECK_EQUAL(h.value(0, 0), 10.0); + BOOST_CHECK_EQUAL(h.value(0, 1), 1.0); + BOOST_CHECK_EQUAL(h.value(0, 2), 0.0); + + BOOST_CHECK_EQUAL(h.value(1, 0), 0.0); + BOOST_CHECK_EQUAL(h.value(1, 1), 0.0); + BOOST_CHECK_EQUAL(h.value(1, 2), 0.0); + + BOOST_CHECK_EQUAL(h.value(2, 0), 0.0); + BOOST_CHECK_EQUAL(h.value(2, 1), 0.0); + BOOST_CHECK_EQUAL(h.value(2, 2), 0.0); + + BOOST_CHECK_EQUAL(h.variance(-1, 0), 0.0); + BOOST_CHECK_EQUAL(h.variance(-1, 1), 49.0); + BOOST_CHECK_EQUAL(h.variance(-1, 2), 0.0); + + BOOST_CHECK_EQUAL(h.variance(0, 0), 100.0); + BOOST_CHECK_EQUAL(h.variance(0, 1), 1.0); + BOOST_CHECK_EQUAL(h.variance(0, 2), 0.0); + + BOOST_CHECK_EQUAL(h.variance(1, 0), 0.0); + BOOST_CHECK_EQUAL(h.variance(1, 1), 0.0); + BOOST_CHECK_EQUAL(h.variance(1, 2), 0.0); + + BOOST_CHECK_EQUAL(h.variance(2, 0), 0.0); + BOOST_CHECK_EQUAL(h.variance(2, 1), 0.0); + BOOST_CHECK_EQUAL(h.variance(2, 2), 0.0); +} + +BOOST_AUTO_TEST_CASE(add_0) +{ + histogram a(integer_axis(-1, 1)); + histogram b(regular_axis(3, -1, 1)); + BOOST_CHECK_THROW(a + b, std::logic_error); +} + +BOOST_AUTO_TEST_CASE(add_1) +{ + histogram a(integer_axis(-1, 1)); + histogram b(integer_axis(-1, 1)); + a.fill(0); + b.fill(-1); + histogram c = a + b; + BOOST_CHECK_EQUAL(c.value(-1), 0); + BOOST_CHECK_EQUAL(c.value(0), 1); + BOOST_CHECK_EQUAL(c.value(1), 1); + BOOST_CHECK_EQUAL(c.value(2), 0); + BOOST_CHECK_EQUAL(c.value(3), 0); +} + +BOOST_AUTO_TEST_CASE(add_2) +{ + histogram a(integer_axis(-1, 1)); + histogram b(integer_axis(-1, 1)); + + a.fill(0); + b.wfill(-1, 3); + histogram c = a + b; + BOOST_CHECK_EQUAL(c.value(-1), 0); + BOOST_CHECK_EQUAL(c.value(0), 3); + BOOST_CHECK_EQUAL(c.value(1), 1); + BOOST_CHECK_EQUAL(c.value(2), 0); + BOOST_CHECK_EQUAL(c.value(3), 0); } diff --git a/test/python_suite_test.py b/test/python_suite_test.py index ab8bfe7c..1379d0ac 100755 --- a/test/python_suite_test.py +++ b/test/python_suite_test.py @@ -315,7 +315,7 @@ class histogram_test(unittest.TestCase): histogram(regular_axis()) with self.assertRaises(TypeError): histogram([integer_axis(-1, 1)]) - with self.assertRaises(TypeError): + with self.assertRaises(RuntimeError): histogram(integer_axis(-1, 1), unknown_keyword="nh") h = histogram(integer_axis(-1, 1)) @@ -353,14 +353,14 @@ class histogram_test(unittest.TestCase): self.assertEqual(h1.shape(0), 5) for h in (h0, h1): - self.assertEqual(h[0], 2) - self.assertEqual(h[1], 1) - self.assertEqual(h[2], 3) - with self.assertRaises(TypeError): - h[0, 1] + self.assertEqual(h.value(0), 2) + self.assertEqual(h.value(1), 1) + self.assertEqual(h.value(2), 3) + with self.assertRaises(RuntimeError): + h.value(0, 1) - self.assertEqual(h1[-1], 1) - self.assertEqual(h1[3], 1) + self.assertEqual(h1.value(-1), 1) + self.assertEqual(h1.value(3), 1) def test_growth(self): h = histogram(integer_axis(-1, 1)) @@ -374,11 +374,11 @@ class histogram_test(unittest.TestCase): self.assertEqual(h.depth, 2) for i in xrange(1000-256): h.fill(0) - self.assertEqual(h[-1], 0) - self.assertEqual(h[0], 1) - self.assertEqual(h[1], 1000) - self.assertEqual(h[2], 2) - self.assertEqual(h[3], 0) + self.assertEqual(h.value(-1), 0) + self.assertEqual(h.value(0), 1) + self.assertEqual(h.value(1), 1000) + self.assertEqual(h.value(2), 2) + self.assertEqual(h.value(3), 0) def test_fill_2d(self): for uoflow in (False, True): @@ -403,12 +403,12 @@ class histogram_test(unittest.TestCase): [0, 0, 0, 0, 0, 0]] for i in xrange(h.axis(0).bins + 2*uoflow): for j in xrange(h.axis(1).bins + 2*uoflow): - self.assertEqual(h[i, j], m[i][j]) + self.assertEqual(h.value(i, j), m[i][j]) def test_add_2d(self): for uoflow in (False, True): h = histogram(integer_axis(-1, 1, uoflow=uoflow), - regular_axis(4, -2, 2, uoflow=uoflow)) + regular_axis(4, -2, 2, uoflow=uoflow)) h.fill(-1, -2) h.fill(-1, -1) h.fill(0, 0) @@ -429,9 +429,47 @@ class histogram_test(unittest.TestCase): for i in xrange(h.axis(0).bins + 2*uoflow): for j in xrange(h.axis(1).bins + 2*uoflow): - self.assertEqual(h[i, j], 2 * m[i][j]) + self.assertEqual(h.value(i, j), 2 * m[i][j]) + self.assertEqual(h.variance(i, j), 2 * m[i][j]) - def test_pickle(self): + def test_add_2d_bad(self): + a = histogram(integer_axis(-1, 1)) + b = histogram(regular_axis(3, -1, 1)) + with self.assertRaises(RuntimeError): + a += b + + def test_add_2d_w(self): + for uoflow in (False, True): + h = histogram(integer_axis(-1, 1, uoflow=uoflow), + regular_axis(4, -2, 2, uoflow=uoflow)) + h.fill(-1, -2) + h.fill(-1, -1) + h.fill(0, 0) + h.fill(0, 1) + h.fill(1, 0) + h.fill(3, -1) + h.fill(0, -3) + + m = [[1, 1, 0, 0, 0, 0], + [0, 0, 1, 1, 0, 1], + [0, 0, 1, 0, 0, 0], + [0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0]] + + hw = histogram(integer_axis(-1, 1, uoflow=uoflow), + regular_axis(4, -2, 2, uoflow=uoflow)) + hw.fill(0, 0, w=0) + + h2 = h + hw + h += h + self.assertNotEqual(h, h2) + + for i in xrange(h.axis(0).bins + 2*uoflow): + for j in xrange(h.axis(1).bins + 2*uoflow): + self.assertEqual(h.value(i, j), 2 * m[i][j]) + self.assertEqual(h.variance(i, j), 2 * m[i][j]) + + def test_pickle_0(self): a = histogram(category_axis('A', 'B', 'C'), integer_axis(0, 3, label='ia'), regular_axis(4, 0.0, 4.0, uoflow=False), @@ -458,8 +496,35 @@ class histogram_test(unittest.TestCase): self.assertEqual(a.sum, b.sum) self.assertEqual(a, b) + def test_pickle_1(self): + a = histogram(category_axis('A', 'B', 'C'), + integer_axis(0, 3, label='ia'), + regular_axis(4, 0.0, 4.0, uoflow=False), + variable_axis(0.0, 1.0, 2.0)) + for i in xrange(a.axis(0).bins): + a.fill(i, 0, 0, 0, w=3) + for j in xrange(a.axis(1).bins): + a.fill(i, j, 0, 0, w=10) + for k in xrange(a.axis(2).bins): + a.fill(i, j, k, 0, w=2) + for l in xrange(a.axis(3).bins): + a.fill(i, j, k, l, w=5) + + io = StringIO.StringIO() + cPickle.dump(a, io) + io.seek(0) + b = cPickle.load(io) + self.assertNotEqual(id(a), id(b)) + self.assertEqual(a.dim, b.dim) + self.assertEqual(a.axis(0), b.axis(0)) + self.assertEqual(a.axis(1), b.axis(1)) + self.assertEqual(a.axis(2), b.axis(2)) + self.assertEqual(a.axis(3), b.axis(3)) + self.assertEqual(a.sum, b.sum) + self.assertEqual(a, b) + @unittest.skipUnless("numpy" in globals(), "requires numpy") - def test_numpy_conversion(self): + def test_numpy_conversion_0(self): a = histogram(integer_axis(0, 2, uoflow=False)) for i in xrange(100): a.fill(1) @@ -480,25 +545,63 @@ class histogram_test(unittest.TestCase): self.assertFalse(numpy.all(v == b)) @unittest.skipUnless("numpy" in globals(), "requires numpy") - def test_fill_with_numpy_array(self): + def test_numpy_conversion_1(self): + a = histogram(integer_axis(0, 2, uoflow=False)) + for i in xrange(10): + a.fill(1, w=3) + b = numpy.array(a) # a copy + v = numpy.asarray(a) # a view + self.assertEqual(b.dtype, numpy.float64) + self.assertTrue(numpy.all(b == numpy.array(((0, 0), (30, 90), (0, 0))))) + self.assertTrue(numpy.all(v == b)) + + @unittest.skipUnless("numpy" in globals(), "requires numpy") + def test_fill_with_numpy_array_0(self): a = histogram(integer_axis(0, 2, uoflow=False)) a.fill(numpy.array([-1, 0, 1, 2, 1, 4])) - self.assertEqual(a[0], 1) - self.assertEqual(a[1], 2) - self.assertEqual(a[2], 1) + self.assertEqual(a.value(0), 1) + self.assertEqual(a.value(1), 2) + self.assertEqual(a.value(2), 1) + with self.assertRaises(ValueError): + a.fill(numpy.empty((2, 2))) + with self.assertRaises(RuntimeError): + a.fill(numpy.empty((2, 1)), 1) + a = histogram(integer_axis(0, 1, uoflow=False), - regular_axis(2, 0, 2, uoflow=False)) + regular_axis(2, 0, 2, uoflow=False)) a.fill(numpy.array([[-1., -1.], [0., 1.], [1., 0.1]])) - self.assertEqual(a[0, 0], 0) - self.assertEqual(a[0, 1], 1) - self.assertEqual(a[1, 0], 1) - self.assertEqual(a[1, 1], 0) + self.assertEqual(a.value(0, 0), 0) + self.assertEqual(a.value(0, 1), 1) + self.assertEqual(a.value(1, 0), 1) + self.assertEqual(a.value(1, 1), 0) a = histogram(integer_axis(0, 2, uoflow=False)) a.fill([0, 0, 1, 2]) a.fill((1, 0, 2, 2)) - self.assertEqual(a[0], 3) - self.assertEqual(a[1], 2) - self.assertEqual(a[2], 3) + self.assertEqual(a.value(0), 3) + self.assertEqual(a.value(1), 2) + self.assertEqual(a.value(2), 3) + + @unittest.skipUnless("numpy" in globals(), "requires numpy") + def test_fill_with_numpy_array_1(self): + a = histogram(integer_axis(0, 2, uoflow=False)) + a.fill(numpy.array([-1, 0, 1, 2, 1, 4]), + w=numpy.array([2.0, 3.0, 4.0, 5.0, 6.0, 7.0])) + self.assertEqual(a.value(0), 1) + self.assertEqual(a.value(1), 2) + self.assertEqual(a.value(2), 1) + a = histogram(integer_axis(0, 1, uoflow=False), + regular_axis(2, 0, 2, uoflow=False)) + a.fill(numpy.array([[-1., -1.], [0., 1.], [1., 0.1]])) + self.assertEqual(a.value(0, 0), 0) + self.assertEqual(a.value(0, 1), 1) + self.assertEqual(a.value(1, 0), 1) + self.assertEqual(a.value(1, 1), 0) + a = histogram(integer_axis(0, 2, uoflow=False)) + a.fill([0, 0, 1, 2]) + a.fill((1, 0, 2, 2)) + self.assertEqual(a.value(0), 3) + self.assertEqual(a.value(1), 2) + self.assertEqual(a.value(2), 3) if __name__ == "__main__": unittest.main()