simplify

alib2algo/src/stringology/compression/ArithmeticCompression.h

@@ -43,12 +43,13 @@ public:
 		for ( size_t index = 0; index < source.size ( ) + 1; ++ index ) {
-			unsigned prob_low, prob_high, prob_count;
+			unsigned prob_low, prob_high;
+			unsigned prob_count = model.getCount ( );
 			if ( index >= source.size ( ) )
-				std::tie ( prob_low, prob_high, prob_count ) = model.getProbabilityEof ( );
+				std::tie ( prob_low, prob_high ) = model.getProbabilityEof ( );
 			else {
-				std::tie ( prob_low, prob_high, prob_count ) = model.getProbability ( source [ index ] );
+				std::tie ( prob_low, prob_high ) = model.getProbability ( source [ index ] );
 				model.update ( source [ index ] );
 			}

alib2algo/src/stringology/compression/ArithmeticDecompression.h

@@ -60,8 +60,9 @@ public:
 				break;
 			char c;
-			unsigned prob_low, prob_high, prob_count;
-			std::tie ( prob_low, prob_high, prob_count, c ) = model.getChar ( scaled_value );
+			unsigned prob_low, prob_high;
+			unsigned prob_count = model.getCount ( );
+			std::tie ( prob_low, prob_high, c ) = model.getChar ( scaled_value );
 			model.update ( c );
 			result += c;

alib2algo/src/stringology/compression/ArithmeticModel.h

@@ -8,57 +8,52 @@
 template < class SymbolType >
 class ArithmeticModel {
-	ext::map < ext::variant < void, SymbolType >, unsigned > m_low_cumulative_frequency;
-	unsigned m_global_high;
+	ext::map < SymbolType, unsigned > m_high_cumulative_frequency;
+	unsigned m_global_high; // EOF is with probability 1/n (ie its low is m_global_high - 1 and hight is m_global_high) with cumulative frequency right below the m_global_high
 public:
 	ArithmeticModel ( const ext::set < SymbolType > & alphabet ) {
-		m_low_cumulative_frequency.insert ( std::make_pair ( ext::variant < void, SymbolType >::template from < void > ( ), 0 ) );
-		for ( const SymbolType & symbol : alphabet )
-			m_low_cumulative_frequency.insert ( std::make_pair ( symbol, 0 ) );
-
 		unsigned frequency = 0;
-		for ( std::pair < const ext::variant < void, SymbolType >, unsigned > & entry : m_low_cumulative_frequency )
-			entry.second = frequency ++;
-
-		m_global_high = frequency;
+		for ( const SymbolType & symbol : alphabet )
+			m_high_cumulative_frequency.insert ( std::make_pair ( symbol, ++ frequency ) );
+		m_global_high = frequency + 1;
 	}
 	void update ( const ext::variant < void, SymbolType > & symbol ) {
-		for ( auto i = std::next ( m_low_cumulative_frequency.find ( symbol ) ); i != m_low_cumulative_frequency.end ( ) ; ++ i )
+		for ( auto i = m_high_cumulative_frequency.find ( symbol ); i != m_high_cumulative_frequency.end ( ) ; ++ i )
 			i->second += 1;
 		m_global_high += 1;
 	}
-	std::tuple < unsigned, unsigned, unsigned > getProbability ( const ext::variant < void, SymbolType > & c ) const {
-		auto i = m_low_cumulative_frequency.find ( c );
-		unsigned high_prob = m_global_high;
-		if ( std::next ( i ) != m_low_cumulative_frequency.end ( ) ) {
-			high_prob = std::next ( i )->second;
-		}
-		return std::make_tuple ( i->second, high_prob, m_global_high );
+	std::tuple < unsigned, unsigned > getProbability ( const SymbolType & c ) const {
+		auto i = m_high_cumulative_frequency.find ( c );
+		unsigned low_prob = 0;
+
+		if ( i != m_high_cumulative_frequency.begin ( ) )
+			low_prob = std::prev ( i )->second;
+
+		return std::make_tuple ( low_prob, i->second );
 	}
-	std::tuple < unsigned, unsigned, unsigned > getProbabilityEof ( ) const {
-		return getProbability ( ext::variant < void, SymbolType >::template from < void > ( ) );
+	std::tuple < unsigned, unsigned > getProbabilityEof ( ) const {
+		return std::make_tuple ( m_global_high - 1, m_global_high );
 	}
-	std::tuple < unsigned, unsigned, unsigned, SymbolType > getChar ( unsigned scaled_value ) const {
-		for ( auto i = m_low_cumulative_frequency.begin ( ); std::next ( i ) != m_low_cumulative_frequency.end ( ); ++ i )
-			if ( scaled_value < std::next ( i )->second ) {
-				unsigned high_prob = m_global_high;
-				if ( std::next ( i ) != m_low_cumulative_frequency.end ( ) ) {
-					high_prob = std::next ( i )->second;
-				}
-				return std::make_tuple ( i->second, high_prob, m_global_high, i->first.template get < SymbolType > ( ) );
+	std::tuple < unsigned, unsigned, SymbolType > getChar ( unsigned scaled_value ) const {
+		for ( auto i = m_high_cumulative_frequency.begin ( ); i != m_high_cumulative_frequency.end ( ); ++ i )
+			if ( scaled_value < i->second ) {
+				unsigned low_prob = 0;
+
+				if ( i != m_high_cumulative_frequency.begin ( ) )
+					low_prob = std::prev ( i )->second;
+
+				return std::make_tuple ( low_prob, i->second, i->first );
 			}
 		throw std::logic_error("error");
 	}
 	bool isEof ( unsigned scaled_value ) const {
-		unsigned prob_low, prob_high, prob_count;
-		std::tie ( prob_low, prob_high, prob_count ) = getProbabilityEof ( );
-		return scaled_value >= prob_low && scaled_value < prob_high;
+		return scaled_value == m_global_high - 1;
 	}
 	unsigned getCount ( ) const {