mirror of
https://github.com/boostorg/histogram.git
synced 2025-05-09 23:04:07 +00:00
... and delay allocation of memory until the first call of fill or wfill
This commit is contained in:
Hans Dembinski
parent
be537449a7
commit
f6bd538689
125
include/boost/histogram/basic_histogram.hpp
Normal file
125
include/boost/histogram/basic_histogram.hpp
Normal file
@ -0,0 +1,125 @@
|
||||
#ifndef _BOOST_HISTOGRAM_BASE_HPP_
|
||||
#define _BOOST_HISTOGRAM_BASE_HPP_
|
||||
|
||||
#include <boost/histogram/axis.hpp>
|
||||
#include <boost/histogram/visitors.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/preprocessor.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/split_member.hpp>
|
||||
#include <boost/serialization/variant.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/container/static_vector.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
#include <bitset>
|
||||
|
||||
#define BOOST_HISTOGRAM_AXIS_LIMIT 16
|
||||
|
||||
namespace boost {
|
||||
namespace histogram {
|
||||
|
||||
// holds collection of axis instances and computes the internal index
|
||||
class basic_histogram {
|
||||
public:
|
||||
typedef container::static_vector<axis_type, BOOST_HISTOGRAM_AXIS_LIMIT> axes_type;
|
||||
typedef uintptr_t size_type;
|
||||
|
||||
basic_histogram(const basic_histogram&);
|
||||
basic_histogram& operator=(const basic_histogram&);
|
||||
~basic_histogram() {}
|
||||
|
||||
unsigned dim() const { return axes_.size(); }
|
||||
|
||||
template <typename T>
|
||||
T& axis(unsigned i)
|
||||
{ if (is_same<T, axis_type>::value) return axes_[i];
|
||||
return boost::get<T&>(axes_[i]); }
|
||||
|
||||
template <typename T>
|
||||
const T& axis(unsigned i) const
|
||||
{ if (is_same<T, axis_type>::value) return axes_[i];
|
||||
return boost::get<const T&>(axes_[i]); }
|
||||
|
||||
unsigned bins(unsigned i) const { return size_[i]; }
|
||||
unsigned shape(unsigned i) const { return size_[i] + 2 * uoflow_[i]; }
|
||||
|
||||
protected:
|
||||
basic_histogram() {}
|
||||
explicit basic_histogram(const axes_type& axes);
|
||||
|
||||
#define BOOST_HISTOGRAM_BASE_APPEND(z, n, unused) axes_.push_back(a ## n);
|
||||
#define BOOST_HISTOGRAM_BASE_CTOR(z, n, unused) \
|
||||
basic_histogram( BOOST_PP_ENUM_PARAMS_Z(z, n, const axis_type& a) ) \
|
||||
{ \
|
||||
axes_.reserve(n); \
|
||||
BOOST_PP_REPEAT(n, BOOST_HISTOGRAM_BASE_APPEND, unused) \
|
||||
update_buffers(); \
|
||||
}
|
||||
|
||||
// generates constructors taking 1 to AXIS_LIMIT arguments
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_BASE_CTOR, nil)
|
||||
|
||||
bool operator==(const basic_histogram&) const;
|
||||
bool operator!=(const basic_histogram& o) const
|
||||
{ return !operator==(o); }
|
||||
|
||||
template <typename Array>
|
||||
inline
|
||||
size_type pos(const Array& v) const {
|
||||
int idx[BOOST_HISTOGRAM_AXIS_LIMIT];
|
||||
for (unsigned i = 0, n = axes_.size(); i < n; ++i)
|
||||
idx[i] = apply_visitor(detail::index_visitor(v[i]), axes_[i]);
|
||||
return linearize(idx);
|
||||
}
|
||||
|
||||
inline
|
||||
size_type linearize(const int* idx) const {
|
||||
size_type stride = 1, k = 0, i = axes_.size();
|
||||
while (i--) {
|
||||
const int size = size_[i];
|
||||
const int range = size + 2 * uoflow_[i];
|
||||
int j = idx[i];
|
||||
// the following three lines work for any overflow setting
|
||||
j += (j < 0) * (size + 2); // wrap around if j < 0
|
||||
if (j >= range)
|
||||
return size_type(-1); // indicate out of range
|
||||
k += j * stride;
|
||||
stride *= range;
|
||||
}
|
||||
return k;
|
||||
}
|
||||
|
||||
// compute the number of fields needed for storage
|
||||
size_type field_count() const;
|
||||
|
||||
private:
|
||||
axes_type axes_;
|
||||
|
||||
// internal buffers
|
||||
int32_t size_[BOOST_HISTOGRAM_AXIS_LIMIT];
|
||||
std::bitset<BOOST_HISTOGRAM_AXIS_LIMIT> uoflow_;
|
||||
|
||||
void update_buffers(); ///< fills size_ and uoflow_
|
||||
|
||||
friend class serialization::access;
|
||||
template <class Archive>
|
||||
void serialize(Archive& ar, unsigned version)
|
||||
{
|
||||
using namespace serialization;
|
||||
unsigned size = axes_.size();
|
||||
ar & size;
|
||||
if (Archive::is_loading::value) {
|
||||
axes_.resize(size);
|
||||
ar & serialization::make_array(&axes_[0], size);
|
||||
update_buffers();
|
||||
} else {
|
||||
ar & serialization::make_array(&axes_[0], size);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
63
src/basic_histogram.cpp
Normal file
63
src/basic_histogram.cpp
Normal file
@ -0,0 +1,63 @@
|
||||
#include <boost/histogram/basic_histogram.hpp>
|
||||
#include <boost/histogram/axis.hpp>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace boost {
|
||||
namespace histogram {
|
||||
|
||||
basic_histogram::basic_histogram(const basic_histogram& o) :
|
||||
axes_(o.axes_)
|
||||
{
|
||||
update_buffers();
|
||||
}
|
||||
|
||||
basic_histogram::basic_histogram(const axes_type& axes) :
|
||||
axes_(axes)
|
||||
{
|
||||
if (axes_.size() > BOOST_HISTOGRAM_AXIS_LIMIT)
|
||||
throw std::invalid_argument("too many axes");
|
||||
update_buffers();
|
||||
}
|
||||
|
||||
basic_histogram&
|
||||
basic_histogram::operator=(const basic_histogram& o)
|
||||
{
|
||||
axes_ = o.axes_;
|
||||
update_buffers();
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool
|
||||
basic_histogram::operator==(const basic_histogram& o)
|
||||
const
|
||||
{
|
||||
if (axes_.size() != o.axes_.size())
|
||||
return false;
|
||||
for (unsigned i = 0; i < axes_.size(); ++i) {
|
||||
if (!apply_visitor(detail::cmp_visitor(), axes_[i], o.axes_[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
basic_histogram::size_type
|
||||
basic_histogram::field_count()
|
||||
const
|
||||
{
|
||||
size_type fc = 1;
|
||||
for (unsigned i = 0, n = axes_.size(); i < n; ++i)
|
||||
fc *= apply_visitor(detail::fields_visitor(), axes_[i]);
|
||||
return fc;
|
||||
}
|
||||
|
||||
void
|
||||
basic_histogram::update_buffers()
|
||||
{
|
||||
for (unsigned i = 0, n = axes_.size(); i < n; ++i) {
|
||||
size_[i] = apply_visitor(detail::bins_visitor(), axes_[i]);
|
||||
uoflow_[i] = apply_visitor(detail::uoflow_visitor(), axes_[i]);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
325
src/python/basic_histogram.cpp
Normal file
325
src/python/basic_histogram.cpp
Normal file
@ -0,0 +1,325 @@
|
||||
#include <boost/histogram/axis.hpp>
|
||||
#include <boost/histogram/basic_histogram.hpp>
|
||||
#include <boost/python.hpp>
|
||||
#include <boost/python/raw_function.hpp>
|
||||
#include <boost/python/def_visitor.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
|
||||
namespace boost {
|
||||
namespace histogram {
|
||||
|
||||
namespace {
|
||||
|
||||
python::object
|
||||
variable_axis_init(python::tuple args, python::dict kwargs) {
|
||||
using namespace python;
|
||||
using python::tuple;
|
||||
|
||||
object self = args[0];
|
||||
object pyinit = self.attr("__init__");
|
||||
|
||||
if (len(args) < 2) {
|
||||
PyErr_SetString(PyExc_TypeError, "require at least two arguments");
|
||||
throw_error_already_set();
|
||||
}
|
||||
|
||||
std::vector<double> v;
|
||||
for (int i = 1, n = len(args); i < n; ++i) {
|
||||
v.push_back(extract<double>(args[i]));
|
||||
}
|
||||
|
||||
std::string label;
|
||||
bool uoflow = true;
|
||||
while (len(kwargs) > 0) {
|
||||
tuple kv = kwargs.popitem();
|
||||
std::string k = extract<std::string>(kv[0]);
|
||||
object v = kv[1];
|
||||
if (k == "label")
|
||||
label = extract<std::string>(v);
|
||||
else if (k == "uoflow")
|
||||
uoflow = extract<bool>(v);
|
||||
else {
|
||||
std::stringstream s;
|
||||
s << "keyword " << k << " not recognized";
|
||||
PyErr_SetString(PyExc_KeyError, s.str().c_str());
|
||||
throw_error_already_set();
|
||||
}
|
||||
}
|
||||
return pyinit(v, label, uoflow);
|
||||
}
|
||||
|
||||
python::object
|
||||
category_axis_init(python::tuple args, python::dict kwargs) {
|
||||
using namespace python;
|
||||
|
||||
object self = args[0];
|
||||
object pyinit = self.attr("__init__");
|
||||
|
||||
if (len(args) == 1) {
|
||||
PyErr_SetString(PyExc_TypeError, "require at least one argument");
|
||||
throw_error_already_set();
|
||||
}
|
||||
|
||||
if (len(kwargs) > 0) {
|
||||
PyErr_SetString(PyExc_TypeError, "unknown keyword argument");
|
||||
throw_error_already_set();
|
||||
}
|
||||
|
||||
if (len(args) == 2) {
|
||||
extract<std::string> es(args[1]);
|
||||
if (es.check())
|
||||
pyinit(es);
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError, "require one or several string arguments");
|
||||
throw_error_already_set();
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::string> c;
|
||||
for (int i = 1, n = len(args); i < n; ++i)
|
||||
c.push_back(extract<std::string>(args[i]));
|
||||
|
||||
return pyinit(c);
|
||||
}
|
||||
|
||||
// python::object
|
||||
// regular_axis_data(const regular_axis& self) {
|
||||
// #if HAVE_NUMPY
|
||||
// py_intp dims[1] = { self.size() + 1 };
|
||||
// PyArrayObject* a = (PyArrayObject*)PyArray_SimpleNew(1, dims, NPY_DOUBLE);
|
||||
// for (unsigned i = 0; i < self.size() + 1; ++i) {
|
||||
// double* pv = (double*)PyArray_GETPTR1(a, i);
|
||||
// *pv = self.left(i);
|
||||
// }
|
||||
// return python::object(handle<>((PyObject*)a));
|
||||
// #else
|
||||
// list v;
|
||||
// for (int i = 0; i < self.size() + 1; ++i)
|
||||
// v.append(self.left(i));
|
||||
// return v;
|
||||
// #endif
|
||||
// }
|
||||
|
||||
struct axis_visitor : public static_visitor<python::object>
|
||||
{
|
||||
template <typename T>
|
||||
python::object operator()(const T& t) const { return python::object(T(t)); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
unsigned
|
||||
axis_len(const T& t) {
|
||||
return t.bins() + 1;
|
||||
}
|
||||
|
||||
template <>
|
||||
unsigned
|
||||
axis_len(const category_axis& t) {
|
||||
return t.bins();
|
||||
}
|
||||
|
||||
template <>
|
||||
unsigned
|
||||
axis_len(const integer_axis& t) {
|
||||
return t.bins();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
typename T::value_type
|
||||
axis_getitem(const T& t, int i) {
|
||||
if (i == axis_len(t)) {
|
||||
PyErr_SetString(PyExc_StopIteration, "no more");
|
||||
python::throw_error_already_set();
|
||||
}
|
||||
return t[i];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
struct has_index_method
|
||||
{
|
||||
struct yes { char x[1]; };
|
||||
struct no { char x[2]; };
|
||||
template<typename U, int (U::*)(double) const> struct SFINAE {};
|
||||
template<typename U> static yes test( SFINAE<U, &U::index>* );
|
||||
template<typename U> static no test( ... );
|
||||
enum { value = sizeof(test<T>(0)) == sizeof(yes) };
|
||||
};
|
||||
|
||||
std::string escape(const std::string& s) {
|
||||
std::ostringstream os;
|
||||
os << '\'';
|
||||
for (unsigned i = 0; i < s.size(); ++i) {
|
||||
const char c = s[i];
|
||||
if (c == '\'' && (i == 0 || s[i - 1] != '\\'))
|
||||
os << "\\\'";
|
||||
else
|
||||
os << c;
|
||||
}
|
||||
os << '\'';
|
||||
return os.str();
|
||||
}
|
||||
|
||||
std::string axis_repr(const regular_axis& a) {
|
||||
std::stringstream s;
|
||||
s << "regular_axis(" << a.bins() << ", " << a[0] << ", " << a[a.bins()];
|
||||
if (!a.label().empty())
|
||||
s << ", label=" << escape(a.label());
|
||||
if (!a.uoflow())
|
||||
s << ", uoflow=False";
|
||||
s << ")";
|
||||
return s.str();
|
||||
}
|
||||
|
||||
std::string axis_repr(const polar_axis& a) {
|
||||
std::stringstream s;
|
||||
s << "polar_axis(" << a.bins();
|
||||
if (a[0] != 0.0)
|
||||
s << ", " << a[0];
|
||||
if (!a.label().empty())
|
||||
s << ", label=" << escape(a.label());
|
||||
s << ")";
|
||||
return s.str();
|
||||
}
|
||||
|
||||
std::string axis_repr(const variable_axis& a) {
|
||||
std::stringstream s;
|
||||
s << "variable_axis(" << a[0];
|
||||
for (int i = 1; i <= a.bins(); ++i)
|
||||
s << ", " << a.left(i);
|
||||
if (!a.label().empty())
|
||||
s << ", label=" << escape(a.label());
|
||||
if (!a.uoflow())
|
||||
s << ", uoflow=False";
|
||||
s << ")";
|
||||
return s.str();
|
||||
}
|
||||
|
||||
std::string axis_repr(const category_axis& a) {
|
||||
std::stringstream s;
|
||||
s << "category_axis(";
|
||||
for (int i = 0; i < a.bins(); ++i)
|
||||
s << escape(a[i]) << (i == (a.bins() - 1)? ")" : ", ");
|
||||
return s.str();
|
||||
}
|
||||
|
||||
std::string axis_repr(const integer_axis& a) {
|
||||
std::stringstream s;
|
||||
s << "integer_axis(" << a[0] << ", " << a[a.bins() - 1];
|
||||
if (!a.label().empty())
|
||||
s << ", label=" << escape(a.label());
|
||||
if (!a.uoflow())
|
||||
s << ", uoflow=False";
|
||||
s << ")";
|
||||
return s.str();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct axis_suite : public python::def_visitor<axis_suite<T> > {
|
||||
|
||||
template <typename Class, typename U>
|
||||
static
|
||||
typename enable_if_c<has_index_method<U>::value, void>::type
|
||||
add_axis_index(Class& cl) {
|
||||
cl.def("index", &U::index);
|
||||
}
|
||||
|
||||
template <typename Class, typename U>
|
||||
static
|
||||
typename disable_if_c<has_index_method<U>::value, void>::type
|
||||
add_axis_index(Class& cl) {}
|
||||
|
||||
template <typename Class, typename U>
|
||||
static
|
||||
typename enable_if<is_base_of<axis_base, U>, void>::type
|
||||
add_axis_label(Class& cl) {
|
||||
cl.add_property("label",
|
||||
python::make_function((const std::string&(U::*)() const) &U::label,
|
||||
python::return_value_policy<python::copy_const_reference>()),
|
||||
(void(U::*)(const std::string&)) &U::label);
|
||||
}
|
||||
|
||||
template <typename Class, typename U>
|
||||
static
|
||||
typename disable_if<is_base_of<axis_base, U>, void>::type
|
||||
add_axis_label(Class& cl) {}
|
||||
|
||||
template <class Class>
|
||||
static void
|
||||
visit(Class& cl)
|
||||
{
|
||||
cl.add_property("bins", &T::bins);
|
||||
add_axis_index<Class, T>(cl);
|
||||
add_axis_label<Class, T>(cl);
|
||||
cl.def("__len__", axis_len<T>);
|
||||
cl.def("__getitem__", axis_getitem<T>);
|
||||
cl.def("__repr__", (std::string (*)(const T&)) &axis_repr);
|
||||
cl.def(python::self == python::self);
|
||||
}
|
||||
};
|
||||
|
||||
python::object
|
||||
basic_histogram_axis(const basic_histogram& self, unsigned i)
|
||||
{
|
||||
return apply_visitor(axis_visitor(), self.axis<axis_type>(i));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void register_basic_histogram() {
|
||||
using namespace python;
|
||||
using python::arg;
|
||||
|
||||
// used to pass arguments from raw python init to specialized C++ constructors
|
||||
class_<std::vector<double> >("vector_double", no_init);
|
||||
class_<std::vector<std::string> >("vector_string", no_init);
|
||||
class_<basic_histogram::axes_type>("axes", no_init);
|
||||
|
||||
class_<regular_axis>("regular_axis", no_init)
|
||||
.def(init<unsigned, double, double, std::string, bool>(
|
||||
(arg("bin"), arg("min"), arg("max"),
|
||||
arg("label") = std::string(),
|
||||
arg("uoflow") = true)))
|
||||
.def(axis_suite<regular_axis>())
|
||||
;
|
||||
|
||||
class_<polar_axis>("polar_axis", no_init)
|
||||
.def(init<unsigned, double, std::string>(
|
||||
(arg("bin"), arg("start") = 0.0,
|
||||
arg("label") = std::string())))
|
||||
.def(axis_suite<polar_axis>())
|
||||
;
|
||||
|
||||
class_<variable_axis>("variable_axis", no_init)
|
||||
.def("__init__", raw_function(variable_axis_init))
|
||||
.def(init<std::vector<double>, std::string, bool>())
|
||||
.def(axis_suite<variable_axis>())
|
||||
;
|
||||
|
||||
class_<category_axis>("category_axis", no_init)
|
||||
.def("__init__", raw_function(category_axis_init))
|
||||
.def(init<std::string>())
|
||||
.def(init<std::vector<std::string> >())
|
||||
.def(axis_suite<category_axis>())
|
||||
;
|
||||
|
||||
class_<integer_axis>("integer_axis", no_init)
|
||||
.def(init<int, int, std::string, bool>(
|
||||
(arg("min"), arg("max"),
|
||||
arg("label") = std::string(),
|
||||
arg("uoflow") = true)))
|
||||
.def(axis_suite<integer_axis>())
|
||||
;
|
||||
|
||||
class_<basic_histogram>("basic_histogram", no_init)
|
||||
.add_property("dim", &basic_histogram::dim)
|
||||
.def("bins", &basic_histogram::bins)
|
||||
.def("shape", &basic_histogram::shape)
|
||||
.def("axis", basic_histogram_axis)
|
||||
;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user