boost/histogram
2
0
Fork 0
mirror of https://github.com/boostorg/histogram.git synced 2026-01-30 20:02:13 +00:00
Code Issues Projects Releases Wiki Activity

removing zero suppression

Browse Source
This commit is contained in:
Hans Dembinski
2016-07-20 22:04:35 -04:00
parent 73535723d2
commit f5301ece3f
3 changed files with 0 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
build/CMakeLists.txt
View File

@@ -58,11 +58,6 @@ add_executable(axis_test
target_link_libraries(axis_test ${LIBRARIES})
add_test(axis_test axis_test)
add_executable(zero_suppression_test
../test/zero_suppression_test.cpp)
target_link_libraries(zero_suppression_test ${LIBRARIES})
add_test(zero_suppression_test zero_suppression_test)
add_executable(dynamic_storage_test
../test/dynamic_storage_test.cpp)
target_link_libraries(dynamic_storage_test ${LIBRARIES})

152
include/boost/histogram/detail/zero_suppression.hpp
View File

@@ -1,152 +0,0 @@
// Copyright 2015-2016 Hans Dembinski
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef _BOOST_HISTOGRAM_DETAIL_ZERO_SUPPRESSION_HPP_
#define _BOOST_HISTOGRAM_DETAIL_ZERO_SUPPRESSION_HPP_
#include <boost/cstdint.hpp>
#include <boost/histogram/detail/wtype.hpp>
#include <limits>
#include <vector>
namespace boost {
namespace histogram {
namespace detail {
template <typename T>
bool
zero_suppression_encode(std::vector<T>& output, const T* input,
uintptr_t size)
{
const T* input_end = input + size;
T nzero = 0;
for (; input != input_end; ++input) {
if (*input != 0) {
if (nzero) {
if ((size - output.size()) < 2)
return false;
output.push_back(0);
output.push_back(nzero);
nzero = 0;
}
if (output.size() == size)
return false;
output.push_back(*input);
}
else {
++nzero;
if (nzero == 0) { // overflowed to zero
if ((size - output.size()) < 2)
return false;
output.push_back(0);
output.push_back(nzero);
nzero = 0;
}
}
}
if (nzero){
if ((size - output.size()) < 2)
return false;
output.push_back(0);
output.push_back(nzero);
nzero = 0;
}
return true;
}
template <typename T>
void
zero_suppression_decode(T* output, uintptr_t size,
const std::vector<T>& input)
{
const T* inp = &input[0];
const T* output_end = output + size;
while (output != output_end) {
*output = *inp;
if (*inp == 0) {
const uintptr_t nzero = *(++inp);
for (T j = 1; j != nzero; ++j) {
*(++output) = 0;
if (output == output_end)
return;
}
}
++inp;
++output;
}
}
template <>
bool
zero_suppression_encode(std::vector<wtype>& output, const wtype* input,
uintptr_t size)
{
const wtype* input_end = input + size;
uint32_t nzero = 0;
for (; input != input_end; ++input) {
if (*input != 0) {
if (nzero) {
if ((size - output.size()) < 2)
return false;
output.push_back(0);
output.push_back(nzero);
nzero = 0;
}
if (output.size() == size)
return false;
output.push_back(*input);
}
else {
++nzero;
if (nzero == 0) // overflowed to zero
{
if ((size - output.size()) < 2)
return false;
output.push_back(0);
output.push_back(nzero);
nzero = 0;
}
}
}
if (nzero){
if ((size - output.size()) < 2)
return false;
output.push_back(0);
output.push_back(nzero);
nzero = 0;
}
return true;
}
template <>
void
zero_suppression_decode(wtype* output, uintptr_t size,
const std::vector<wtype>& input)
{
const wtype* inp = &input[0];
const wtype* output_end = output + size;
while (output != output_end) {
*output = *inp;
if (*inp == 0) {
const uintptr_t nzero = (++inp)->w;
for (uintptr_t j = 1; j != nzero; ++j) {
*(++output) = 0;
if (output == output_end)
return;
}
}
++inp;
++output;
}
}
}
}
}
#endif

248
test/zero_suppression_test.cpp
View File

@@ -1,248 +0,0 @@
// Copyright 2015-2016 Hans Dembinski
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_TEST_MODULE zero_suppression_test
#include <boost/test/unit_test.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/histogram/detail/zero_suppression.hpp>
#include <iostream>
using namespace boost::histogram::detail;
namespace tt = boost::test_tools;
template <typename T>
void
print(const std::vector<T>& v) {
std::cerr << "[";
for (unsigned i = 0; i < v.size(); ++i) {
std::cerr << v[i] << (i < v.size() - 1 ? ", " : "]");
}
std::cerr << "\n";
}
#define EQUAL_VECTORS(a, b) \
BOOST_CHECK_EQUAL_COLLECTIONS(a.begin(), a.end(), b.begin(), b.end())
BOOST_AUTO_TEST_CASE( codec_no_zero )
{
std::vector<unsigned> a{1, 1, 1}, b, c(3, 0);
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(a, b);
zero_suppression_decode<unsigned>(&c[0], c.size(), b);
EQUAL_VECTORS(a, c);
}
BOOST_AUTO_TEST_CASE( codec_empty )
{
std::vector<unsigned> a, b, c;
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(a, b);
zero_suppression_decode<unsigned>(&c[0], c.size(), b);
EQUAL_VECTORS(a, c);
}
BOOST_AUTO_TEST_CASE( codec_zero_0a )
{
std::vector<uint8_t> a{0}, b;
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()) == false);
}
BOOST_AUTO_TEST_CASE( codec_zero_1a )
{
std::vector<uint8_t> a{1, 0, 0}, b, c{1, 0, 2}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_2a )
{
std::vector<uint8_t> a{0, 0, 1}, b, c{0, 2, 1}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_3a )
{
std::vector<uint8_t> a{0, 0}, b, c{0, 2}, d(2, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_0b )
{
std::vector<unsigned> a{0}, b;
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()) == false);
}
BOOST_AUTO_TEST_CASE( codec_zero_1b )
{
std::vector<unsigned> a{1, 0, 0}, b, c{1, 0, 2}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<unsigned>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_2b )
{
std::vector<unsigned> a{0, 0, 1}, b, c{0, 2, 1}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<unsigned>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_3b )
{
std::vector<unsigned> a{0, 0}, b, c{0, 2}, d(2, 0);
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<unsigned>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_0c )
{
std::vector<uint64_t> a{0}, b;
BOOST_CHECK(zero_suppression_encode<uint64_t>(b, &a[0], a.size()) == false);
}
BOOST_AUTO_TEST_CASE( codec_zero_1c )
{
std::vector<uint64_t> a{1, 0, 0}, b, c{1, 0, 2}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<uint64_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint64_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_2c )
{
std::vector<uint64_t> a{0, 0, 1}, b, c{0, 2, 1}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<uint64_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint64_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_3c )
{
std::vector<uint64_t> a{0, 0}, b, c{0, 2}, d(2, 0);
BOOST_CHECK(zero_suppression_encode<uint64_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint64_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_0d )
{
std::vector<wtype> a{0}, b;
BOOST_CHECK(zero_suppression_encode<wtype>(b, &a[0], a.size()) == false);
}
BOOST_AUTO_TEST_CASE( codec_zero_1d )
{
std::vector<wtype> a{1, 0, 0}, b, c{1, 0, 2}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<wtype>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<wtype>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_2d )
{
std::vector<wtype> a{0, 0, 1}, b, c{0, 2, 1}, d(3, 0);
BOOST_CHECK(zero_suppression_encode<wtype>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<wtype>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_3d )
{
std::vector<wtype> a{0, 0}, b, c{0, 2}, d(2, 0);
BOOST_CHECK(zero_suppression_encode<wtype>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<wtype>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_4 )
{
std::vector<unsigned> a{0, 0, 0, 1, 0}, b, c{0, 3, 1, 0, 1}, d(5, 0);
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<unsigned>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_5 )
{
std::vector<unsigned> a{0, 1, 0, 0, 0}, b, c{0, 1, 1, 0, 3}, d(5, 0);
BOOST_CHECK(zero_suppression_encode<unsigned>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<unsigned>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_6 )
{
std::vector<uint8_t> a(255, 0), b, c{0, 255}, d(255, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_7 )
{
std::vector<uint8_t> a(256, 0), b, c{0, 0}, d(256, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_8 )
{
std::vector<uint8_t> a(257, 0), b, c{0, 0, 0, 1}, d(257, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_9 )
{
std::vector<uint8_t> a(1000, 0), b, c{0, 0, 0, 0, 0, 0, 0, 232}, d(1000, 0);
BOOST_CHECK(zero_suppression_encode<uint8_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint8_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_10 )
{
std::vector<uint16_t> a(1000, 0), b, c{0, 1000}, d(1000, 0);
BOOST_CHECK(zero_suppression_encode<uint16_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint16_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}
BOOST_AUTO_TEST_CASE( codec_zero_11 )
{
std::vector<uint16_t> a(65536, 0), b, c{0, 0}, d(65536, 0);
BOOST_CHECK(zero_suppression_encode<uint16_t>(b, &a[0], a.size()));
EQUAL_VECTORS(b, c);
zero_suppression_decode<uint16_t>(&d[0], d.size(), b);
EQUAL_VECTORS(a, d);
}