boost_mirror/histogram
1
0
Fork 0
mirror of https://github.com/boostorg/histogram.git synced 2025-05-09 23:04:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

renaming of histogram_base to basic_histogram

Browse Source
This commit is contained in:
Hans Dembinski 2016-04-12 23:13:23 -04:00
parent 439f6260aa
commit be537449a7
10 changed files with 24 additions and 533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMake/CMakeLists.txt
View File

@ -35,7 +35,7 @@ set(LIBRARIES stdc++ m ${Boost_LIBRARIES})
# core library
add_library(boost_histogram SHARED
../src/axis.cpp
../src/histogram_base.cpp
../src/basic_histogram.cpp
../src/histogram.cpp
../src/nstore.cpp
../src/zero_suppression.cpp
@ -55,7 +55,7 @@ if(Boost_PYTHON_FOUND AND PYTHONLIBS_FOUND AND USE_PYTHON)
add_library(pyhistogram MODULE
../src/python/module.cpp
../src/python/histogram_base.cpp
../src/python/basic_histogram.cpp
../src/python/histogram.cpp
)
target_link_libraries(pyhistogram boost_histogram ${LIBRARIES} boost_python ${PYTHON_LIBRARIES})

1
include/boost/histogram/detail/nstore.hpp
View File

@ -33,6 +33,7 @@ public:
inline void increase(size_type i) {
switch (depth_) {
case 0: depth_ = 1; create();
case sizeof(wtype): {
wtype& b = ((wtype*)buffer_)[i];
b += 1.0;

12
include/boost/histogram/histogram.hpp
View File

@ -2,7 +2,7 @@
#define _BOOST_HISTOGRAM_HISTOGRAM_HPP_
#include <boost/histogram/axis.hpp>
#include <boost/histogram/histogram_base.hpp>
#include <boost/histogram/basic_histogram.hpp>
#include <boost/histogram/detail/nstore.hpp>
#include <boost/preprocessor.hpp>
#include <boost/serialization/access.hpp>
@ -16,7 +16,7 @@
namespace boost {
namespace histogram {
class histogram : public histogram_base {
class histogram : public basic_histogram {
public:
histogram() {}
histogram(const histogram& o);
@ -24,7 +24,7 @@ public:
#define BOOST_HISTOGRAM_CTOR(z, n, unused) \
histogram( BOOST_PP_ENUM_PARAMS_Z(z, n, const axis_type& a) ) : \
histogram_base( BOOST_PP_ENUM_PARAMS_Z(z, n, a) ), \
basic_histogram( BOOST_PP_ENUM_PARAMS_Z(z, n, a) ), \
data_(field_count()) \
{}
@ -120,12 +120,12 @@ BOOST_PP_REPEAT_FROM_TO(1, BOOST_HISTOGRAM_AXIS_LIMIT, BOOST_HISTOGRAM_VARIANCE,
double sum() const;
bool operator==(const histogram& o) const
{ return histogram_base::operator==(o) &&
{ return basic_histogram::operator==(o) &&
data_ == o.data_; }
histogram& operator+=(const histogram& o)
{
if (!histogram_base::operator==(o))
if (!basic_histogram::operator==(o))
throw std::logic_error("histograms have different axes");
data_ += o.data_;
return *this;
@ -138,7 +138,7 @@ private:
template <class Archive>
void serialize(Archive& ar, unsigned version)
{
ar & serialization::base_object<histogram_base>(*this);
ar & serialization::base_object<basic_histogram>(*this);
ar & data_;
}

125
include/boost/histogram/histogram_base.hpp
View File

@ -1,125 +0,0 @@
#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 histogram_base {
public:
typedef container::static_vector<axis_type, BOOST_HISTOGRAM_AXIS_LIMIT> axes_type;
typedef uintptr_t size_type;
histogram_base(const histogram_base&);
histogram_base& operator=(const histogram_base&);
~histogram_base() {}
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:
histogram_base() {}
explicit histogram_base(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) \
histogram_base( 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 histogram_base&) const;
bool operator!=(const histogram_base& 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

4
src/histogram.cpp
View File

@ -5,12 +5,12 @@ namespace boost {
namespace histogram {
histogram::histogram(const histogram& o) :
histogram_base(o),
basic_histogram(o),
data_(o.data_)
{}
histogram::histogram(const axes_type& axes) :
histogram_base(axes),
basic_histogram(axes),
data_(field_count())
{}

63
src/histogram_base.cpp
View File

@ -1,63 +0,0 @@
#include <boost/histogram/histogram_base.hpp>
#include <boost/histogram/axis.hpp>
#include <stdexcept>
namespace boost {
namespace histogram {
histogram_base::histogram_base(const histogram_base& o) :
axes_(o.axes_)
{
update_buffers();
}
histogram_base::histogram_base(const axes_type& axes) :
axes_(axes)
{
if (axes_.size() > BOOST_HISTOGRAM_AXIS_LIMIT)
throw std::invalid_argument("too many axes");
update_buffers();
}
histogram_base&
histogram_base::operator=(const histogram_base& o)
{
axes_ = o.axes_;
update_buffers();
return *this;
}
bool
histogram_base::operator==(const histogram_base& 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;
}
histogram_base::size_type
histogram_base::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
histogram_base::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]);
}
}
}
}

13
src/nstore.cpp
View File

@ -25,11 +25,13 @@ nstore::nstore(size_type n, unsigned d) :
size_(n),
depth_(d)
{
if (d == 0)
throw std::invalid_argument("depth may not be zero");
if (d > sizeof(uint64_t))
throw std::invalid_argument("depth > sizeof(uint64_t) is not supported");
create();
BOOST_ASSERT(n > 0);
BOOST_ASSERT(d == sizeof(uint8_t) ||
d == sizeof(uint16_t) ||
d == sizeof(uint32_t) ||
d == sizeof(uint64_t) ||
d == sizeof(wtype));
if (d > 0) create();
}
nstore&
@ -165,6 +167,7 @@ void
nstore::wconvert()
{
BOOST_ASSERT(depth_ < sizeof(wtype));
// realloc is safe if buffer_ is null
buffer_ = std::realloc(buffer_, size_ * sizeof(wtype));
if (!buffer_) throw std::bad_alloc();
size_type i = size_;

6
src/python/histogram.cpp
View File

@ -29,7 +29,7 @@ histogram_init(python::tuple args, python::dict kwargs) {
}
// normal constructor
histogram_base::axes_type axes;
basic_histogram::axes_type axes;
for (unsigned i = 1, n = len(args); i < n; ++i) {
object pa = args[i];
extract<regular_axis> er(pa);
@ -222,12 +222,12 @@ void register_histogram()
using namespace python;
class_<
histogram, bases<histogram_base>,
histogram, bases<basic_histogram>,
shared_ptr<histogram>
>("histogram", no_init)
.def("__init__", raw_function(histogram_init))
// shadowed C++ ctors
.def(init<const histogram_base::axes_type&>())
.def(init<const basic_histogram::axes_type&>())
.add_property("__array_interface__", &histogram_access::histogram_array_interface)
.def("fill", raw_function(histogram_fill))
.add_property("depth", &histogram::depth)

325
src/python/histogram_base.cpp
View File

@ -1,325 +0,0 @@
#include <boost/histogram/axis.hpp>
#include <boost/histogram/histogram_base.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
histogram_base_axis(const histogram_base& self, unsigned i)
{
return apply_visitor(axis_visitor(), self.axis<axis_type>(i));
}
} // namespace
void register_histogram_base() {
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_<histogram_base::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_<histogram_base>("histogram_base", no_init)
.add_property("dim", &histogram_base::dim)
.def("bins", &histogram_base::bins)
.def("shape", &histogram_base::shape)
.def("axis", histogram_base_axis)
;
}
}
}

4
src/python/module.cpp
View File

@ -7,7 +7,7 @@
namespace boost {
namespace histogram {
void register_histogram_base();
void register_basic_histogram();
void register_histogram();
}
}
@ -17,6 +17,6 @@ BOOST_PYTHON_MODULE(histogram)
#ifdef USE_NUMPY
import_array();
#endif
boost::histogram::register_histogram_base();
boost::histogram::register_basic_histogram();
boost::histogram::register_histogram();
}