more cleanup
diff --git a/cpc/include/cpc_compressor_impl.hpp b/cpc/include/cpc_compressor_impl.hpp
index 9b1fce7..bb73a71 100644
--- a/cpc/include/cpc_compressor_impl.hpp
+++ b/cpc/include/cpc_compressor_impl.hpp
@@ -52,7 +52,7 @@
uint8_t* cpc_compressor<A>::make_inverse_permutation(const uint8_t* permu, int length) {
uint8_t* inverse = new uint8_t[length]; // use new for global initialization
for (int i = 0; i < length; i++) {
- inverse[permu[i]] = i;
+ inverse[permu[i]] = static_cast<uint8_t>(i);
}
for (int i = 0; i < length; i++) {
if (permu[inverse[i]] != i) throw std::logic_error("inverse permutation error");
@@ -70,7 +70,7 @@
const int encoding_entry = encoding_table[byte_value];
const int code_value = encoding_entry & 0xfff;
const int code_length = encoding_entry >> 12;
- const int decoding_entry = (code_length << 8) | byte_value;
+ const uint16_t decoding_entry = (code_length << 8) | byte_value;
const int garbage_length = 12 - code_length;
const int num_copies = 1 << garbage_length;
for (int garbage_bits = 0; garbage_bits < num_copies; garbage_bits++) {
@@ -397,7 +397,7 @@
template<typename A>
void cpc_compressor<A>::uncompress_sliding_window(const uint32_t* data, size_t data_words, vector_u8<A>& window,
uint8_t lg_k, uint32_t num_coupons) const {
- const size_t k = 1 << lg_k;
+ const uint32_t k = 1 << lg_k;
window.resize(k); // zeroing not needed here (unlike the Hybrid Flavor)
const uint8_t pseudo_phase = determine_pseudo_phase(lg_k, num_coupons);
low_level_uncompress_bytes(window.data(), k, decoding_tables_for_high_entropy_byte[pseudo_phase], data, data_words);
@@ -743,7 +743,7 @@
if (count < 1) throw std::invalid_argument("golomb_choose_number_of_base_bits: count < 1");
const uint64_t quotient = (k - count) / count; // integer division
if (quotient == 0) return 0;
- else return long_floor_log2_of_long(quotient);
+ else return floor_log2_of_long(quotient);
}
} /* namespace datasketches */
diff --git a/cpc/include/cpc_util.hpp b/cpc/include/cpc_util.hpp
index 1a33b3a..12cdb82 100644
--- a/cpc/include/cpc_util.hpp
+++ b/cpc/include/cpc_util.hpp
@@ -31,9 +31,9 @@
else return quotient + 1;
}
-static inline uint64_t long_floor_log2_of_long(uint64_t x) {
- if (x < 1) throw std::invalid_argument("long_floor_log2_of_long: bad argument");
- uint64_t p = 0;
+static inline uint8_t floor_log2_of_long(uint64_t x) {
+ if (x < 1) throw std::invalid_argument("floor_log2_of_long: bad argument");
+ uint8_t p = 0;
uint64_t y = 1;
while (true) {
if (y == x) return p;
diff --git a/cpc/include/u32_table.hpp b/cpc/include/u32_table.hpp
index fe228a5..a000c39 100644
--- a/cpc/include/u32_table.hpp
+++ b/cpc/include/u32_table.hpp
@@ -42,7 +42,7 @@
u32_table(const A& allocator);
u32_table(uint8_t lg_size, uint8_t num_valid_bits, const A& allocator);
- inline size_t get_num_items() const;
+ inline uint32_t get_num_items() const;
inline const uint32_t* get_slots() const;
inline uint8_t get_lg_size() const;
inline void clear();
@@ -69,10 +69,10 @@
uint8_t lg_size; // log2 of number of slots
uint8_t num_valid_bits;
- size_t num_items;
+ uint32_t num_items;
vector_u32<A> slots;
- inline size_t lookup(uint32_t item) const;
+ inline uint32_t lookup(uint32_t item) const;
inline void must_insert(uint32_t item);
inline void rebuild(uint8_t new_lg_size);
};
diff --git a/cpc/include/u32_table_impl.hpp b/cpc/include/u32_table_impl.hpp
index bf8ece9..c3c9501 100644
--- a/cpc/include/u32_table_impl.hpp
+++ b/cpc/include/u32_table_impl.hpp
@@ -48,7 +48,7 @@
}
template<typename A>
-size_t u32_table<A>::get_num_items() const {
+uint32_t u32_table<A>::get_num_items() const {
return num_items;
}
@@ -70,7 +70,7 @@
template<typename A>
bool u32_table<A>::maybe_insert(uint32_t item) {
- const size_t index = lookup(item);
+ const uint32_t index = lookup(item);
if (slots[index] == item) return false;
if (slots[index] != UINT32_MAX) throw std::logic_error("could not insert");
slots[index] = item;
@@ -83,7 +83,7 @@
template<typename A>
bool u32_table<A>::maybe_delete(uint32_t item) {
- const size_t index = lookup(item);
+ const uint32_t index = lookup(item);
if (slots[index] == UINT32_MAX) return false;
if (slots[index] != item) throw std::logic_error("item does not exist");
if (num_items == 0) throw std::logic_error("delete error");
@@ -124,11 +124,11 @@
}
template<typename A>
-size_t u32_table<A>::lookup(uint32_t item) const {
- const size_t size = 1 << lg_size;
- const size_t mask = size - 1;
+uint32_t u32_table<A>::lookup(uint32_t item) const {
+ const uint32_t size = 1 << lg_size;
+ const uint32_t mask = size - 1;
const uint8_t shift = num_valid_bits - lg_size;
- size_t probe = item >> shift;
+ uint32_t probe = item >> shift;
if (probe > mask) throw std::logic_error("probe out of range");
while (slots[probe] != item && slots[probe] != UINT32_MAX) {
probe = (probe + 1) & mask;
@@ -139,7 +139,7 @@
// counts and resizing must be handled by the caller
template<typename A>
void u32_table<A>::must_insert(uint32_t item) {
- const size_t index = lookup(item);
+ const uint32_t index = lookup(item);
if (slots[index] == item) throw std::logic_error("item exists");
if (slots[index] != UINT32_MAX) throw std::logic_error("could not insert");
slots[index] = item;
@@ -148,13 +148,13 @@
template<typename A>
void u32_table<A>::rebuild(uint8_t new_lg_size) {
if (new_lg_size < 2) throw std::logic_error("lg_size must be >= 2");
- const size_t old_size = 1 << lg_size;
- const size_t new_size = 1 << new_lg_size;
+ const uint32_t old_size = 1 << lg_size;
+ const uint32_t new_size = 1 << new_lg_size;
if (new_size <= num_items) throw std::logic_error("new_size <= num_items");
vector_u32<A> old_slots = std::move(slots);
slots = vector_u32<A>(new_size, UINT32_MAX, old_slots.get_allocator());
lg_size = new_lg_size;
- for (size_t i = 0; i < old_size; i++) {
+ for (uint32_t i = 0; i < old_size; i++) {
if (old_slots[i] != UINT32_MAX) {
must_insert(old_slots[i]);
}
