ZeroRunLengthEncoding class

alib2data/src/common/ZeroRunLengthEncoding.hpp

+/*
+ * ZeroRunLengthEncoding.hpp
+ *
+ *  Created on: 23. 2. 2017
+ *	  Author: Jan Travnicek
+ */
+
+#ifndef ZERO_RUN_LENGTHPP_ENCODING_HPP_
+#define ZERO_RUN_LENGTHPP_ENCODING_HPP_
+
+#include <list>
+
+/* Canonical representation kept by all operations is in form of blocks of pairs run and word, where each word must contain at least one set bit, with exception of the last word.
+ * Empty sequence of bits is represented by empty list of elements and size equal to zero.
+ * If the size of the representation is divisible by sizeof ( unsigned ) * 8 then the last block must either be of nonzero run or its word must contain at least one set bit. This is not with contradiction with the first line.
+ *
+ * Examples:
+ *                  least significant bit
+ *                  v
+ *   size = 32 [(0, 00000000000000000000000000000000)] is representing 32 times zero
+ *   size = 32 [(0, 00000000000000000000000000000001)] is representing 31 times zero and one
+ *   size = 33 [(1, 00000000000000000000000000000000)] is representing 31 times zero
+ *   size = 64 [(0, 00000000000000000000000000000001), (0, 00000000000000000000000000000000)] is representing 31 times zero, one and 32 times zero
+ * */
+
+namespace common {
+
+class ZeroRunLengthEncoding {
+	struct element {
+		unsigned run;
+		unsigned word;
+	};
+
+	std::list < element > m_Data;
+	size_t m_Size;
+
+	static inline unsigned getMask ( size_t dist ) {
+		return ( ( 1u ) << dist ) - 1;
+	}
+
+	void packData ( ) {
+		size_t sizeWithin = m_Size % ( sizeof ( unsigned ) * 8 );
+		long long sizeBlocks = m_Size / ( sizeof ( unsigned ) * 8 ) + ( bool ) sizeWithin;
+		unsigned mask = getMask ( sizeWithin );
+
+		// crop by size
+		std::list < element >::iterator elementIter;
+		for ( elementIter = m_Data.begin ( ); elementIter != m_Data.end ( ); ++ elementIter ) {
+			sizeBlocks -= elementIter->run + 1;
+			if ( sizeBlocks <= 0 )
+				break;
+		}
+
+		if ( sizeBlocks == 0 ) { // sizeBlocks is negative or 0
+			if ( mask != 0 )
+				elementIter->word &= mask;
+			++ elementIter;
+		} else {
+			elementIter->run += sizeBlocks; //sizeBlocks is negative
+			elementIter->word = 0;
+			++ elementIter;
+		}
+
+		for ( ; elementIter != m_Data.end ( ); ++ elementIter ) {
+			m_Data.erase ( elementIter );
+		}
+
+		// erase not needed blocks
+		unsigned runCarry = 0;
+		for ( elementIter = m_Data.begin ( ); elementIter != m_Data.end ( ); ++ elementIter ) {
+			while ( elementIter->word == 0 && std::next ( elementIter ) != m_Data.end ( ) ) {
+				runCarry += elementIter->run + 1;
+				elementIter = m_Data.erase ( elementIter );
+			}
+			elementIter->run += runCarry;
+			runCarry = 0;
+		}
+	}
+
+public:
+	ZeroRunLengthEncoding ( ) : m_Size ( 0 ) { }
+
+	ZeroRunLengthEncoding ( const std::vector < bool > & raw ) : m_Size ( 0 ) {
+		for ( bool boolean : raw ) {
+			push_back ( boolean );
+		}
+	}
+
+	void push_back ( bool boolean ) {
+		size_t sizeWithin = m_Size % ( sizeof ( unsigned ) * 8 );
+
+		if ( m_Data.size ( ) == 0 ) {
+			m_Data.push_back ( element { 0, 0 } );
+		} else if ( sizeWithin == 0 && m_Data.back ( ).word == 0 ) {
+			m_Data.back ( ).run += 1;
+		} else if ( sizeWithin == 0 && m_Data.back ( ).word != 0 ) {
+			m_Data.push_back ( element { 0, 0 } );
+		}
+
+		m_Data.back ( ).word |= boolean << sizeWithin;
+		m_Size += 1;
+	}
+
+	operator std::vector < bool > ( ) const {
+		std::vector < bool > res;
+
+		for ( const element & elem : m_Data ) {
+			for ( unsigned i = 0; i < elem.run ; ++i )
+				for ( unsigned j = 0; j < sizeof ( unsigned ) * 8; ++j )
+					res.push_back ( false );
+
+			for ( unsigned i = 0; i < sizeof ( unsigned ) * 8; ++i ) {
+				res.push_back ( elem.word & 1 << i );
+			}
+		}
+
+		res.resize ( m_Size );
+
+		return res;
+	}
+
+	const std::list < element > & data ( ) {
+		return m_Data;
+	}
+
+	void resize ( size_t size ) {
+		m_Size = size;
+
+		packData ( );
+	}
+
+	friend ZeroRunLengthEncoding & operator <<= ( ZeroRunLengthEncoding & A, size_t dist ) {
+		if ( A.m_Size == 0 || dist == 0 )
+			return A;
+
+		size_t distBlocks = dist / ( sizeof ( unsigned ) * 8 );
+		size_t distWithin = dist % ( sizeof ( unsigned ) * 8 );
+		size_t backDist = sizeof ( unsigned ) * 8 - distWithin;
+
+		// shift by block
+		A.m_Data.front ( ).run += distBlocks;
+
+		if ( distWithin == 0 ) {
+			A.packData ( );
+			return A;
+		}
+
+		unsigned shiftedWord = 0;
+
+		for ( auto elementIter = A.m_Data.begin ( ); elementIter != A.m_Data.end ( ); ++ elementIter ) {
+			if ( shiftedWord != 0 && elementIter->run != 0 ) {
+				// shift into new block borrow from this run
+				elementIter->run -= 1;
+
+				elementIter = A.m_Data.insert ( elementIter, element { 0, shiftedWord } );
+
+				shiftedWord = 0;
+			} else {
+				unsigned tmp = elementIter->word >> backDist;
+				elementIter->word = elementIter->word << distWithin | shiftedWord;
+				shiftedWord = tmp;
+			}
+		}
+
+		A.packData ( );
+
+		return A;
+	}
+
+	friend ZeroRunLengthEncoding operator << ( ZeroRunLengthEncoding A, size_t dist ) {
+		A <<= dist;
+		return A;
+	}
+
+	friend std::ostream & operator << ( std::ostream & out, const common::ZeroRunLengthEncoding::element & elem ) {
+		out << "(" << elem.run << ", ";
+		for ( unsigned i = 0; i < sizeof ( elem.word ) * 8; ++ i )
+			out << (bool) ( elem.word & 1 << i );
+		out << ")";
+		return out;
+	}
+
+
+};
+
+} /* namespace common */
+
+#endif /* ZERO_RUN_LENGTHPP_ENCODING_HPP_ */

alib2data/test-src/common/ZeroRunLengthEncodingTest.cpp

+#include "ZeroRunLengthEncodingTest.h"
+
+#include <common/ZeroRunLengthEncoding.hpp>
+
+#define CPPUNIT_IMPLY( x, y )			CPPUNIT_ASSERT ( !( x ) || ( y ) )
+#define CPPUNIT_EXCLUSIVE_OR( x, y )	CPPUNIT_ASSERT ( ( !( x ) && ( y ) ) || ( ( x ) && !( y ) ) )
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION ( ZeroRunLengthEncodingTest, "common" );
+CPPUNIT_TEST_SUITE_REGISTRATION ( ZeroRunLengthEncodingTest );
+
+void ZeroRunLengthEncodingTest::setUp ( ) {
+}
+
+void ZeroRunLengthEncodingTest::tearDown ( ) {
+}
+
+void ZeroRunLengthEncodingTest::testVectorCompatibility() {
+	std::vector < bool > orig;
+	for ( int i = 0; i < 1000; ++i ) {
+		orig.push_back ( false );
+	}
+	for ( int i = 0; i < 20; ++i ) {
+		orig.push_back ( true );
+		orig.push_back ( true );
+		orig.push_back ( false );
+		orig.push_back ( true );
+		orig.push_back ( true );
+		orig.push_back ( false );
+		orig.push_back ( true );
+		orig.push_back ( false );
+		orig.push_back ( false );
+		orig.push_back ( true );
+	}
+	for ( int i = 0; i < 1000; ++i ) {
+		orig.push_back ( false );
+	}
+	orig.push_back ( true );
+	orig.push_back ( true );
+	orig.push_back ( false );
+	orig.push_back ( true );
+	orig.push_back ( true );
+	orig.push_back ( false );
+	orig.push_back ( true );
+	orig.push_back ( false );
+	orig.push_back ( false );
+	orig.push_back ( true );
+
+	common::ZeroRunLengthEncoding compressed ( orig );
+	std::vector < bool > copy ( compressed );
+
+	std::cout << orig << std::endl;
+	std::cout << copy << std::endl;
+	std::cout << compressed.data ( ) << std::endl;
+
+	CPPUNIT_ASSERT ( orig == copy );
+}
+
+void testOffset ( int /* offset */ ) {
+/*	unsigned long long shadow = 0x2A76B147D6521C87ULL;
+	std::vector < bool > data;
+
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8 + offset; ++ i ) {
+		data.push_back ( true );
+	}
+
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+
+	data >>= sizeof ( unsigned long long ) * 6 - 1;
+
+	std::vector < bool > ref;
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 2 + offset; ++ i ) {
+		ref.push_back ( true );
+	}
+
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		ref.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+
+	ref.resize ( 128 + offset );
+
+	std::cout << "data = " << data << std::endl;
+	std::cout << "ref  = " << ref << std::endl;
+
+	CPPUNIT_ASSERT ( data == ref );*/
+}
+
+void ZeroRunLengthEncodingTest::testShifts2() {
+/*	unsigned long long shadow = 0x2A76B147D6521C87ULL;
+	std::vector < bool > data;
+
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+
+	shadow >>= 10;
+	data >>= 10;
+
+	std::vector < bool > ref;
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		ref.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+
+	// std::cout << "data = " << data << std::endl;
+	// std::cout << "ref  = " << ref << std::endl;
+
+	CPPUNIT_ASSERT ( data == ref );
+
+	for ( unsigned long i = - sizeof ( unsigned long long ) / 2 ; i < sizeof ( unsigned long long ) * 8; ++ i )
+		testOffset ( i ); */
+}
+
+void ZeroRunLengthEncodingTest::testShifts3() {
+/*	unsigned long long shadow = 0x2A76B147D6521C87ULL;
+	std::vector < bool > data;
+
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+
+	std::vector < bool > data2 = data;
+	data2 >>= 64;
+
+	data >>= 32;
+	data >>= 16;
+	data >>= 8;
+	data >>= 4;
+	data >>= 2;
+	data >>= 1;
+	data >>= 1;
+
+	std::cout << "data  = " << data  << std::endl;
+	std::cout << "data2 = " << data2 << std::endl;
+
+	data2 >>= 1;
+	data2 >>= 2;
+	data2 >>= 4;
+	data2 >>= 8;
+	data2 >>= 16;
+	data2 >>= 32;
+	data2 >>= 1;
+
+	data >>= 27;
+	data >>= 17;
+	data >>= 13;
+	data >>= 7;
+
+	std::cout << "data  = " << data  << std::endl;
+	std::cout << "data2 = " << data2 << std::endl;
+
+	CPPUNIT_ASSERT ( data2 == data );*/
+}
+
+void testOffset2 ( size_t size, size_t shift ) {
+	unsigned long long shadow = 0x2A76B147D6521C87ULL;
+	std::vector < bool > ref;
+	while ( ref.size ( ) < size ) {
+		for ( size_t i = 0; i < sizeof ( unsigned long long ) * 8; ++i ) {
+			ref.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+		}
+		for ( size_t i = 0; i < 100; ++i ) {
+			ref.push_back ( false );
+		}
+	}
+	ref.resize ( size );
+
+	common::ZeroRunLengthEncoding data = ref;
+	data <<= shift;
+	ref <<= shift;
+
+	std::cout << "size = " << size << std::endl;
+	std::cout << "shift = " << shift << std::endl;
+	std::cout << "data = " << data.data ( ) << std::endl;
+	std::cout << "ref = " << common::ZeroRunLengthEncoding ( ref ).data ( ) << std::endl;
+
+	CPPUNIT_ASSERT ( data == common::ZeroRunLengthEncoding ( ref ) );
+}
+
+void ZeroRunLengthEncodingTest::testShifts4() {
+	for ( size_t shift = 0 ; shift < 100; ++ shift ) {
+		testOffset2 ( 0, shift );
+		testOffset2 ( 31, shift );
+		testOffset2 ( 32, shift );
+		testOffset2 ( 33, shift );
+		testOffset2 ( 63, shift );
+		testOffset2 ( 64, shift );
+		testOffset2 ( 65, shift );
+		testOffset2 ( 1023, shift );
+		testOffset2 ( 1024, shift );
+		testOffset2 ( 1025, shift );
+		testOffset2 ( 2000, shift );
+
+	}
+}
+
+void ZeroRunLengthEncodingTest::testShifts5() {
+	unsigned long long shadow = 0x2A76B147D6521C87ULL;
+	common::ZeroRunLengthEncoding data;
+
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+	for ( unsigned i = 0; i < sizeof ( unsigned long long ) * 8; ++ i ) {
+		data.push_back ( ( bool ) ( shadow & ( 1ULL << i ) ) );
+	}
+
+	common::ZeroRunLengthEncoding data2 = data;
+	data2 <<= 64;
+
+	data <<= 32;
+	data <<= 16;
+	data <<= 8;
+	data <<= 4;
+	data <<= 2;
+	data <<= 1;
+	data <<= 1;
+
+	std::cout << "data  = " << data.data ( )  << std::endl;
+	std::cout << "data2 = " << data2.data ( ) << std::endl;
+
+	data2 <<= 1;
+	data2 <<= 2;
+	data2 <<= 4;
+	data2 <<= 8;
+	data2 <<= 16;
+	data2 <<= 32;
+	data2 <<= 1;
+
+	data <<= 27;
+	data <<= 17;
+	data <<= 13;
+	data <<= 7;
+
+	std::cout << "data  = " << data.data ( )  << std::endl;
+	std::cout << "data2 = " << data2.data ( ) << std::endl;
+
+	CPPUNIT_ASSERT ( data2 == data );
+}

alib2data/test-src/common/ZeroRunLengthEncodingTest.h

+#ifndef ZERO_RUN_LENGTH_ENCODING_TEST_H_
+#define ZERO_RUN_LENGTH_ENCODING_TEST_H_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class ZeroRunLengthEncodingTest : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( ZeroRunLengthEncodingTest );
+  CPPUNIT_TEST( testVectorCompatibility );
+  CPPUNIT_TEST( testShifts2 );
+  CPPUNIT_TEST( testShifts3 );
+  CPPUNIT_TEST( testShifts4 );
+  CPPUNIT_TEST( testShifts5 );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void testVectorCompatibility();
+  void testShifts2();
+  void testShifts3();
+  void testShifts4();
+  void testShifts5();
+};
+
+#endif  // ZERO_RUN_LENGTH_ENCODING_TEST_H_