Rename rackCount() to num_racks()

3 files changed, 36 insertions, 36 deletions

diff --git a/chilbert/BigBitVec.hpp b/chilbert/BigBitVec.hpp
index 9306fe5..e7eeeee 100644
--- a/chilbert/BigBitVec.hpp
+++ b/chilbert/BigBitVec.hpp
@@ -47,7 +47,7 @@ public:
 	static constexpr size_t bits_per_rack = sizeof(Rack) * CHAR_BIT;
 
 	explicit CBigBitVec(const size_t bits)
-	  : m_pcRacks{make_racks(num_racks(bits))}
+	  : m_pcRacks{make_racks(calculate_num_racks(bits))}
 	  , m_size{bits}
 	{
 	}
@@ -59,12 +59,12 @@ public:
 	}
 
 	CBigBitVec(const CBigBitVec& vec)
-	  : m_pcRacks{make_racks(vec.rackCount())}
+	  : m_pcRacks{make_racks(vec.num_racks())}
 	  , m_size{vec.m_size}
 	{
 		if (vec.m_pcRacks) {
 			memcpy(
-			  m_pcRacks.get(), vec.m_pcRacks.get(), sizeof(Rack) * rackCount());
+			  m_pcRacks.get(), vec.m_pcRacks.get(), sizeof(Rack) * num_racks());
 		}
 	}
 
@@ -76,7 +76,7 @@ public:
 	/// Set all bits to zero
 	CBigBitVec& reset()
 	{
-		memset(m_pcRacks.get(), 0, sizeof(Rack) * rackCount());
+		memset(m_pcRacks.get(), 0, sizeof(Rack) * num_racks());
 		return *this;
 	}
 
@@ -84,10 +84,10 @@ public:
 	CBigBitVec& set()
 	{
 		if (m_size) {
-			memset(m_pcRacks.get(), 0xFF, sizeof(Rack) * rackCount());
+			memset(m_pcRacks.get(), 0xFF, sizeof(Rack) * num_racks());
 			const auto pad = m_size % bits_per_rack;
 			if (pad) {
-				m_pcRacks[rackCount() - 1] |= ~Rack{0} >> pad;
+				m_pcRacks[num_racks() - 1] |= ~Rack{0} >> pad;
 			}
 		}
 
@@ -101,7 +101,7 @@ public:
 
 		m_pcRacks[m.rack] &= (m.mask - 1);
 
-		for (size_t i = m.rack + 1; i < rackCount(); ++i) {
+		for (size_t i = m.rack + 1; i < num_racks(); ++i) {
 			m_pcRacks[i] = 0;
 		}
 
@@ -110,9 +110,9 @@ public:
 
 	bool operator==(const CBigBitVec& vec) const
 	{
-		return (rackCount() == vec.rackCount() &&
-		        (rackCount() == 0 ||
-		         !memcmp(racks(), vec.racks(), rackCount() * sizeof(Rack))));
+		return (num_racks() == vec.num_racks() &&
+		        (num_racks() == 0 ||
+		         !memcmp(racks(), vec.racks(), num_racks() * sizeof(Rack))));
 	}
 
 	bool operator!=(const CBigBitVec& vec) const { return !(*this == vec); }
@@ -121,8 +121,8 @@ public:
 	{
 		assert(size() == vec.size());
 
-		for (size_t ri = 0; ri < rackCount(); ++ri) {
-			size_t i = rackCount() - ri - 1;
+		for (size_t ri = 0; ri < num_racks(); ++ri) {
+			size_t i = num_racks() - ri - 1;
 			if (m_pcRacks[i] < vec.m_pcRacks[i]) {
 				return true;
 			} else if (m_pcRacks[i] > vec.m_pcRacks[i]) {
@@ -134,15 +134,15 @@ public:
 
 	CBigBitVec& operator=(const CBigBitVec& vec)
 	{
-		if (rackCount() < vec.rackCount()) {
-			m_pcRacks = make_racks(vec.rackCount());
+		if (num_racks() < vec.num_racks()) {
+			m_pcRacks = make_racks(vec.num_racks());
 			m_size    = vec.m_size;
 			memcpy(
-			  m_pcRacks.get(), vec.m_pcRacks.get(), sizeof(Rack) * rackCount());
-		} else if (vec.rackCount() > 0) {
+			  m_pcRacks.get(), vec.m_pcRacks.get(), sizeof(Rack) * num_racks());
+		} else if (vec.num_racks() > 0) {
 			m_size = vec.m_size;
 			memcpy(
-			  m_pcRacks.get(), vec.m_pcRacks.get(), sizeof(Rack) * rackCount());
+			  m_pcRacks.get(), vec.m_pcRacks.get(), sizeof(Rack) * num_racks());
 		} else {
 			m_size = 0;
 			m_pcRacks.reset();
@@ -208,7 +208,7 @@ public:
 
 	CBigBitVec& operator&=(const CBigBitVec& vec)
 	{
-		for (size_t i = 0; i < std::min(rackCount(), vec.rackCount()); ++i) {
+		for (size_t i = 0; i < std::min(num_racks(), vec.num_racks()); ++i) {
 			m_pcRacks[i] &= vec.m_pcRacks[i];
 		}
 
@@ -217,7 +217,7 @@ public:
 
 	CBigBitVec& operator|=(const CBigBitVec& vec)
 	{
-		for (size_t i = 0; i < std::min(rackCount(), vec.rackCount()); ++i) {
+		for (size_t i = 0; i < std::min(num_racks(), vec.num_racks()); ++i) {
 			m_pcRacks[i] |= vec.m_pcRacks[i];
 		}
 
@@ -226,7 +226,7 @@ public:
 
 	CBigBitVec& operator^=(const CBigBitVec& vec)
 	{
-		for (size_t i = 0; i < std::min(rackCount(), vec.rackCount()); ++i) {
+		for (size_t i = 0; i < std::min(num_racks(), vec.num_racks()); ++i) {
 			m_pcRacks[i] ^= vec.m_pcRacks[i];
 		}
 
@@ -246,7 +246,7 @@ public:
 
 		if (index.rack > 0) {
 			// Shift entire racks
-			for (size_t i = rackCount() - 1; i >= index.rack; --i) {
+			for (size_t i = num_racks() - 1; i >= index.rack; --i) {
 				m_pcRacks[i] = m_pcRacks[i - index.rack];
 			}
 			for (size_t i = 0; i < index.rack; ++i) {
@@ -258,7 +258,7 @@ public:
 			// Shift bits within racks
 			size_t bi = bits_per_rack - index.bit;
 			size_t i;
-			for (i = rackCount() - 1; i >= index.rack + 1; --i) {
+			for (i = num_racks() - 1; i >= index.rack + 1; --i) {
 				m_pcRacks[i] <<= index.bit;
 				m_pcRacks[i] |= m_pcRacks[i - 1] >> bi;
 			}
@@ -282,10 +282,10 @@ public:
 		if (index.rack > 0) {
 			// Shift entire racks
 			size_t i;
-			for (i = 0; i < rackCount() - index.rack; ++i) {
+			for (i = 0; i < num_racks() - index.rack; ++i) {
 				m_pcRacks[i] = m_pcRacks[i + index.rack];
 			}
-			for (; i < rackCount(); ++i) {
+			for (; i < num_racks(); ++i) {
 				m_pcRacks[i] = 0;
 			}
 		}
@@ -294,7 +294,7 @@ public:
 			// Shift bits within racks
 			size_t bi = bits_per_rack - index.bit;
 			size_t i;
-			for (i = 0; i < rackCount() - index.rack - 1; ++i) {
+			for (i = 0; i < num_racks() - index.rack - 1; ++i) {
 				m_pcRacks[i] >>= index.bit;
 				m_pcRacks[i] |= m_pcRacks[i + 1] << bi;
 			}
@@ -343,7 +343,7 @@ public:
 	/// Return true iff all bits are zero
 	bool none() const
 	{
-		for (size_t i = 0; i < rackCount(); ++i) {
+		for (size_t i = 0; i < num_racks(); ++i) {
 			if (m_pcRacks[i]) {
 				return false;
 			}
@@ -354,7 +354,7 @@ public:
 	/// Return 1 + the index of the first set bit, or 0 if there are none
 	size_t find_first() const
 	{
-		for (size_t i = 0; i < rackCount(); ++i) {
+		for (size_t i = 0; i < num_racks(); ++i) {
 			const int j = ffs(m_pcRacks[i]);
 			if (j) {
 				return (i * bits_per_rack) + static_cast<size_t>(j);
@@ -367,7 +367,7 @@ public:
 	size_t count() const
 	{
 		size_t c = 0;
-		for (size_t i = 0; i < rackCount(); ++i) {
+		for (size_t i = 0; i < num_racks(); ++i) {
 			c += static_cast<size_t>(pop_count(m_pcRacks[i]));
 		}
 		return c;
@@ -376,7 +376,7 @@ public:
 	/// Flip all bits (one's complement)
 	CBigBitVec& flip()
 	{
-		for (size_t i = 0; i < rackCount(); ++i) {
+		for (size_t i = 0; i < num_racks(); ++i) {
 			m_pcRacks[i] = ~m_pcRacks[i];
 		}
 		return *this;
@@ -391,7 +391,7 @@ public:
 	const Rack* racks() const { return m_pcRacks.get(); }
 
 	/// Return the number of racks
-	size_t rackCount() const { return num_racks(m_size); }
+	size_t num_racks() const { return calculate_num_racks(m_size); }
 
 	Mask mask(const size_t i = 0) const
 	{
@@ -420,7 +420,7 @@ private:
 
 	using RacksPtr = std::unique_ptr<Rack[], RacksDeleter>;
 
-	static size_t num_racks(const size_t bits)
+	static size_t calculate_num_racks(const size_t bits)
 	{
 		return (std::max(bits, size_t(1)) + bits_per_rack - 1) / bits_per_rack;
 	}
@@ -446,7 +446,7 @@ grayCode(CBigBitVec& value)
 {
 	CBigBitVec::Rack s = 0;
 
-	for (intptr_t i = static_cast<intptr_t>(value.rackCount() - 1); i >= 0;
+	for (intptr_t i = static_cast<intptr_t>(value.num_racks() - 1); i >= 0;
 	     --i) {
 		const auto t = value.racks()[i] & 1;
 		grayCode(value.racks()[i]);
@@ -461,7 +461,7 @@ grayCodeInv(CBigBitVec& value)
 {
 	CBigBitVec::Rack s = 0;
 
-	for (intptr_t i = static_cast<intptr_t>(value.rackCount() - 1); i >= 0;
+	for (intptr_t i = static_cast<intptr_t>(value.num_racks() - 1); i >= 0;
 	     --i) {
 		auto& rack = value.racks()[i];
 		grayCodeInv(rack);
diff --git a/chilbert/FixBitVec.hpp b/chilbert/FixBitVec.hpp
index d4313ba..99ed1ee 100644
--- a/chilbert/FixBitVec.hpp
+++ b/chilbert/FixBitVec.hpp
@@ -267,7 +267,7 @@ public:
 	const Rack* racks() const { return &m_rack; }
 
 	/// Return the number of racks
-	int rackCount() const { return 1; }
+	int num_racks() const { return 1; }
 
 	template <class BitVec>
 	class iterator_base : public Mask
diff --git a/test/test_hilbert.cpp b/test/test_hilbert.cpp
index 005c110..e3a0daf 100644
--- a/test/test_hilbert.cpp
+++ b/test/test_hilbert.cpp
@@ -70,7 +70,7 @@ to_big_int(const T& vec)
 	mpz_t ia;
 	mpz_init(ia);
 	mpz_import(
-	  ia, vec.rackCount(), -1, sizeof(chilbert::FBV_UINT), 0, 0, vec.racks());
+	  ia, vec.num_racks(), -1, sizeof(chilbert::FBV_UINT), 0, 0, vec.racks());
 	const mpz_class num(ia);
 	mpz_clear(ia);
 	return num;
@@ -90,7 +90,7 @@ from_big_int(const mpz_class& num)
 	           0,
 	           0,
 	           num.get_mpz_t());
-	assert(count <= static_cast<size_t>(vec.rackCount()));
+	assert(count <= static_cast<size_t>(vec.num_racks()));
 	return vec;
 }