Rename bit vector types

4 files changed, 84 insertions, 82 deletions

diff --git a/chilbert/BigBitVec.hpp b/chilbert/DynamicBitVec.hpp
index be6e5e0..ab7d00b 100644
--- a/chilbert/BigBitVec.hpp
+++ b/chilbert/DynamicBitVec.hpp
@@ -16,8 +16,8 @@
   this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-#ifndef CHILBERT_BIGBITVEC_HPP
-#define CHILBERT_BIGBITVEC_HPP
+#ifndef CHILBERT_DYNAMICBITVEC_HPP
+#define CHILBERT_DYNAMICBITVEC_HPP
 
 #include "chilbert/BitVecIndex.hpp"
 #include "chilbert/BitVecIterator.hpp"
@@ -33,7 +33,7 @@
 
 namespace chilbert {
 
-class CBigBitVec : public MultiBitVec<CBigBitVec>
+class DynamicBitVec : public MultiBitVec<DynamicBitVec>
 {
 public:
 	struct RacksDeleter
@@ -49,19 +49,19 @@ public:
 	using RacksPtr      = std::unique_ptr<Rack[], RacksDeleter>;
 	using ConstRacksPtr = std::unique_ptr<const Rack[], NullDeleter>;
 
-	explicit CBigBitVec(const size_t bits)
+	explicit DynamicBitVec(const size_t bits)
 	  : m_racks{make_racks(calculate_num_racks(bits))}
 	  , m_size{bits}
 	{
 	}
 
-	CBigBitVec(const size_t bits, const Rack value)
-	  : CBigBitVec{bits}
+	DynamicBitVec(const size_t bits, const Rack value)
+	  : DynamicBitVec{bits}
 	{
 		m_racks[0] = value;
 	}
 
-	CBigBitVec(const CBigBitVec& vec)
+	DynamicBitVec(const DynamicBitVec& vec)
 	  : m_racks{make_racks(vec.num_racks())}
 	  , m_size{vec.m_size}
 	{
@@ -70,9 +70,9 @@ public:
 		}
 	}
 
-	CBigBitVec(CBigBitVec&& vec) = default;
+	DynamicBitVec(DynamicBitVec&& vec) = default;
 
-	CBigBitVec& operator=(const CBigBitVec& vec)
+	DynamicBitVec& operator=(const DynamicBitVec& vec)
 	{
 		if (num_racks() < vec.num_racks()) {
 			m_racks = make_racks(vec.num_racks());
@@ -89,7 +89,7 @@ public:
 		return *this;
 	}
 
-	CBigBitVec& operator=(CBigBitVec&& vec) = default;
+	DynamicBitVec& operator=(DynamicBitVec&& vec) = default;
 
 	/// Return the size in bits
 	size_t size() const { return m_size; }
@@ -124,23 +124,23 @@ private:
 };
 
 template <>
-struct is_bitvec<CBigBitVec>
+struct is_bitvec<DynamicBitVec>
 {
 	constexpr static bool value = true;
 };
 
 template <>
 void
-gray_code(CBigBitVec& value)
+gray_code(DynamicBitVec& value)
 {
-	gray_code(static_cast<MultiBitVec<CBigBitVec>&>(value));
+	gray_code(static_cast<MultiBitVec<DynamicBitVec>&>(value));
 }
 
 template <>
 void
-gray_code_inv(CBigBitVec& value)
+gray_code_inv(DynamicBitVec& value)
 {
-	gray_code_inv(static_cast<MultiBitVec<CBigBitVec>&>(value));
+	gray_code_inv(static_cast<MultiBitVec<DynamicBitVec>&>(value));
 }
 
 } // namespace chilbert
diff --git a/chilbert/Hilbert.ipp b/chilbert/Hilbert.ipp
index 81eb7fd..0b02fba 100644
--- a/chilbert/Hilbert.ipp
+++ b/chilbert/Hilbert.ipp
@@ -19,10 +19,10 @@
 #ifndef CHILBERT_ALGORITHM_HPP
 #define CHILBERT_ALGORITHM_HPP
 
-#include "chilbert/BigBitVec.hpp"
-#include "chilbert/FixBitVec.hpp"
+#include "chilbert/DynamicBitVec.hpp"
 #include "chilbert/GrayCodeRank.hpp"
 #include "chilbert/Hilbert.hpp"
+#include "chilbert/SmallBitVec.hpp"
 #include "chilbert/StaticBitVec.hpp"
 
 #include <cassert>
@@ -50,8 +50,8 @@ num_bits(const T&, std::enable_if_t<std::is_integral<T>::value>* = nullptr)
 template <class T>
 size_t
 num_bits(const T& vec,
-         std::enable_if_t<std::is_same<T, CFixBitVec>::value ||
-                          std::is_same<T, CBigBitVec>::value>* = nullptr)
+         std::enable_if_t<std::is_same<T, SmallBitVec>::value ||
+                          std::is_same<T, DynamicBitVec>::value>* = nullptr)
 {
 	return vec.size();
 }
@@ -316,15 +316,15 @@ coords_to_compact_index(const P* const      p,
 	size_t* const ds = new size_t[m];
 
 	if (mn > FBV_BITS) {
-		CBigBitVec h(mn);
-		detail::coords_to_index<P, CBigBitVec, I>(
+		DynamicBitVec h(mn);
+		detail::coords_to_index<P, DynamicBitVec, I>(
 		  p, m, n, h, std::move(scratch), ds);
-		compact_index<CBigBitVec, HC>(ms, ds, n, m, h, hc);
+		compact_index<DynamicBitVec, HC>(ms, ds, n, m, h, hc);
 	} else {
-		CFixBitVec h(mn);
-		detail::coords_to_index<P, CFixBitVec, I>(
+		SmallBitVec h(mn);
+		detail::coords_to_index<P, SmallBitVec, I>(
 		  p, m, n, h, std::move(scratch), ds);
-		compact_index<CFixBitVec, HC>(ms, ds, n, m, h, hc);
+		compact_index<SmallBitVec, HC>(ms, ds, n, m, h, hc);
 	}
 
 	delete[] ds;
@@ -415,10 +415,11 @@ coords_to_index(const P* const p, const size_t m, const size_t n, H& h)
 
 	if (n <= FBV_BITS) {
 		// Intermediate variables will fit in fixed width
-		detail::coords_to_index<P, H, CFixBitVec>(p, m, n, h, CFixBitVec(n));
+		detail::coords_to_index<P, H, SmallBitVec>(p, m, n, h, SmallBitVec(n));
 	} else {
-		// Otherwise, they must be BigBitVecs
-		detail::coords_to_index<P, H, CBigBitVec>(p, m, n, h, CBigBitVec(n));
+		// Otherwise, they must be DynamicBitVecs
+		detail::coords_to_index<P, H, DynamicBitVec>(
+		  p, m, n, h, DynamicBitVec(n));
 	}
 }
 
@@ -433,10 +434,11 @@ index_to_coords(P* const p, const size_t m, const size_t n, const H& h)
 
 	if (n <= FBV_BITS) {
 		// Intermediate variables will fit in fixed width
-		detail::index_to_coords<P, H, CFixBitVec>(p, m, n, h, CFixBitVec(n));
+		detail::index_to_coords<P, H, SmallBitVec>(p, m, n, h, SmallBitVec(n));
 	} else {
-		// Otherwise, they must be BigBitVecs
-		detail::index_to_coords<P, H, CBigBitVec>(p, m, n, h, CBigBitVec(n));
+		// Otherwise, they must be DynamicBitVecs
+		detail::index_to_coords<P, H, DynamicBitVec>(
+		  p, m, n, h, DynamicBitVec(n));
 	}
 }
 
@@ -453,12 +455,12 @@ coords_to_compact_index(const P* const      p,
 
 	if (n <= FBV_BITS) {
 		// Intermediate variables will fit in fixed width
-		detail::coords_to_compact_index<P, HC, CFixBitVec>(
-		  p, ms, n, hc, CFixBitVec(n), M, m);
+		detail::coords_to_compact_index<P, HC, SmallBitVec>(
+		  p, ms, n, hc, SmallBitVec(n), M, m);
 	} else {
-		// Otherwise, they must be BigBitVecs
-		detail::coords_to_compact_index<P, HC, CBigBitVec>(
-		  p, ms, n, hc, CBigBitVec(n), M, m);
+		// Otherwise, they must be DynamicBitVecs
+		detail::coords_to_compact_index<P, HC, DynamicBitVec>(
+		  p, ms, n, hc, DynamicBitVec(n), M, m);
 	}
 }
 
@@ -475,13 +477,13 @@ compact_index_to_coords(P* const      p,
 
 	if (n <= FBV_BITS) {
 		// Intermediate variables will fit in fixed width
-		CFixBitVec scratch(n);
-		detail::compact_index_to_coords<P, HC, CFixBitVec>(
+		SmallBitVec scratch(n);
+		detail::compact_index_to_coords<P, HC, SmallBitVec>(
 		  p, ms, n, hc, std::move(scratch), M, m);
 	} else {
-		// Otherwise, they must be BigBitVecs
-		CBigBitVec scratch(n);
-		detail::compact_index_to_coords<P, HC, CBigBitVec>(
+		// Otherwise, they must be DynamicBitVecs
+		DynamicBitVec scratch(n);
+		detail::compact_index_to_coords<P, HC, DynamicBitVec>(
 		  p, ms, n, hc, std::move(scratch), M, m);
 	}
 }
diff --git a/chilbert/FixBitVec.hpp b/chilbert/SmallBitVec.hpp
index 8cd3d72..f11dab0 100644
--- a/chilbert/FixBitVec.hpp
+++ b/chilbert/SmallBitVec.hpp
@@ -16,8 +16,8 @@
   this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-#ifndef CHILBERT_FIXBITVEC_HPP
-#define CHILBERT_FIXBITVEC_HPP
+#ifndef CHILBERT_SMALLBITVEC_HPP
+#define CHILBERT_SMALLBITVEC_HPP
 
 #include "chilbert/Operations.hpp"
 
@@ -40,7 +40,7 @@ typedef uint64_t FBV_UINT;
 #define FBV1S (~FBV_UINT{0})
 #define FBVN1S(n) (n == FBV_BITS ? FBV1S : (FBV1 << n) - 1)
 
-class CFixBitVec
+class SmallBitVec
 {
 public:
 	using Rack = uintptr_t;
@@ -69,7 +69,7 @@ public:
 		}
 
 	private:
-		friend class CFixBitVec;
+		friend class SmallBitVec;
 
 		Mask(const size_t index)
 		  : m_mask{index < bits_per_rack ? Rack{1} << index : 0}
@@ -79,14 +79,14 @@ public:
 		Rack m_mask;
 	};
 
-	explicit CFixBitVec(const size_t bits)
+	explicit SmallBitVec(const size_t bits)
 	  : m_rack{0}
 	  , m_size{bits}
 	{
 		assert(bits <= bits_per_rack);
 	}
 
-	CFixBitVec(const size_t bits, const Rack value)
+	SmallBitVec(const size_t bits, const Rack value)
 	  : m_rack{value}
 	  , m_size{bits}
 	{
@@ -97,14 +97,14 @@ public:
 	size_t size() const { return m_size; }
 
 	/// Set all bits to one
-	CFixBitVec& set()
+	SmallBitVec& set()
 	{
 		m_rack = FBV1S & FBVN1S(size());
 		return *this;
 	}
 
 	/// Set all bits to zero
-	CFixBitVec& reset()
+	SmallBitVec& reset()
 	{
 		m_rack = 0;
 		return *this;
@@ -117,98 +117,98 @@ public:
 	bool test(const size_t index) const { return test(mask(index)); }
 
 	/// Set the bit covered by `mask` to 1
-	CFixBitVec& set(const Mask mask)
+	SmallBitVec& set(const Mask mask)
 	{
 		m_rack |= mask.m_mask;
 		return *this;
 	}
 
 	/// Set the `index`th bit to 1
-	CFixBitVec& set(const size_t index) { return set(mask(index)); }
+	SmallBitVec& set(const size_t index) { return set(mask(index)); }
 
 	/// Reset the bit covered by `mask` to 0
-	CFixBitVec& reset(const Mask mask)
+	SmallBitVec& reset(const Mask mask)
 	{
 		m_rack &= ~mask.m_mask;
 		return *this;
 	}
 
 	/// Reset the `index`th bit to 0
-	CFixBitVec& reset(const size_t index) { return reset(mask(index)); }
+	SmallBitVec& reset(const size_t index) { return reset(mask(index)); }
 
 	/// Set the bit covered by `mask` to `value`
-	CFixBitVec& set(const Mask mask, const bool value)
+	SmallBitVec& set(const Mask mask, const bool value)
 	{
 		m_rack ^= (-Rack{value} ^ m_rack) & mask.m_mask;
 		return *this;
 	}
 
 	/// Set the `index`th bit to `value`
-	CFixBitVec& set(const size_t index, const bool value)
+	SmallBitVec& set(const size_t index, const bool value)
 	{
 		return set(mask(index), value);
 	}
 
 	/// Flip the value of the bit covered by `mask`
-	CFixBitVec& flip(const Mask mask)
+	SmallBitVec& flip(const Mask mask)
 	{
 		m_rack ^= mask.m_mask;
 		return *this;
 	}
 
 	/// Flip the value of the `index`th bit
-	CFixBitVec& flip(const size_t index) { return flip(mask(index)); }
+	SmallBitVec& flip(const size_t index) { return flip(mask(index)); }
 
-	bool operator==(const CFixBitVec& vec) const
+	bool operator==(const SmallBitVec& vec) const
 	{
 		return m_rack == vec.m_rack;
 	}
 
-	bool operator!=(const CFixBitVec& vec) const
+	bool operator!=(const SmallBitVec& vec) const
 	{
 		return m_rack != vec.m_rack;
 	}
 
-	bool operator<(const CFixBitVec& vec) const { return m_rack < vec.m_rack; }
+	bool operator<(const SmallBitVec& vec) const { return m_rack < vec.m_rack; }
 
-	CFixBitVec& operator=(const Rack i)
+	SmallBitVec& operator=(const Rack i)
 	{
 		m_rack = i;
 		return *this;
 	}
 
-	CFixBitVec& operator&=(const CFixBitVec& vec)
+	SmallBitVec& operator&=(const SmallBitVec& vec)
 	{
 		m_rack &= vec.m_rack;
 		return *this;
 	}
 
-	CFixBitVec& operator|=(const CFixBitVec& vec)
+	SmallBitVec& operator|=(const SmallBitVec& vec)
 	{
 		m_rack |= vec.m_rack;
 		return *this;
 	}
 
-	CFixBitVec& operator^=(const CFixBitVec& vec)
+	SmallBitVec& operator^=(const SmallBitVec& vec)
 	{
 		m_rack ^= vec.m_rack;
 		return *this;
 	}
 
-	CFixBitVec& operator^=(const Rack i)
+	SmallBitVec& operator^=(const Rack i)
 	{
 		m_rack ^= i;
 		return *this;
 	}
 
-	CFixBitVec& operator<<=(const size_t bits)
+	SmallBitVec& operator<<=(const size_t bits)
 	{
 		assert(bits < size());
 		m_rack <<= bits;
 		return *this;
 	}
 
-	CFixBitVec& operator>>=(const size_t bits)
+	SmallBitVec& operator>>=(const size_t bits)
 	{
 		assert(bits < size());
 		m_rack >>= bits;
@@ -216,7 +216,7 @@ public:
 	}
 
 	/// Right-rotate by `bits` positions
-	CFixBitVec& rotr(const size_t bits)
+	SmallBitVec& rotr(const size_t bits)
 	{
 		if (bits > 0 && bits < size()) {
 			assert(bits <= bits_per_rack);
@@ -228,7 +228,7 @@ public:
 	}
 
 	/// Left-rotate by `bits` positions
-	CFixBitVec& rotl(const size_t bits)
+	SmallBitVec& rotl(const size_t bits)
 	{
 		if (bits > 0 && bits < size()) {
 			assert(bits <= bits_per_rack);
@@ -252,7 +252,7 @@ public:
 	size_t count() const { return static_cast<size_t>(pop_count(m_rack)); }
 
 	/// Flip all bits (one's complement)
-	CFixBitVec& flip()
+	SmallBitVec& flip()
 	{
 		m_rack = ~m_rack;
 		return *this;
@@ -308,27 +308,27 @@ public:
 		BitVec* m_vec;
 	};
 
-	class iterator : public iterator_base<CFixBitVec>
+	class iterator : public iterator_base<SmallBitVec>
 	{
 	public:
 		void set() { m_vec->set(*this); }
 		void reset() { m_vec->reset(*this); }
 
 	private:
-		friend class CFixBitVec;
+		friend class SmallBitVec;
 
-		iterator(CFixBitVec& vec, const size_t index)
+		iterator(SmallBitVec& vec, const size_t index)
 		  : iterator_base{vec, index}
 		{
 		}
 	};
 
-	class const_iterator : public iterator_base<const CFixBitVec>
+	class const_iterator : public iterator_base<const SmallBitVec>
 	{
 	private:
-		friend class CFixBitVec;
+		friend class SmallBitVec;
 
-		const_iterator(const CFixBitVec& vec, const size_t index)
+		const_iterator(const SmallBitVec& vec, const size_t index)
 		  : iterator_base{vec, index}
 		{
 		}
@@ -360,23 +360,23 @@ private:
 };
 
 template <>
-struct is_bitvec<CFixBitVec>
+struct is_bitvec<SmallBitVec>
 {
 	constexpr static bool value = true;
 };
 
 template <>
 void
-gray_code(CFixBitVec& value)
+gray_code(SmallBitVec& value)
 {
 	value.rack() ^= (value.rack() >> 1);
 }
 
 template <>
 void
-gray_code_inv(CFixBitVec& value)
+gray_code_inv(SmallBitVec& value)
 {
-	gray_code_inv<CFixBitVec::Rack>(value.rack());
+	gray_code_inv<SmallBitVec::Rack>(value.rack());
 }
 
 } // namespace chilbert
diff --git a/chilbert/StaticBitVec.hpp b/chilbert/StaticBitVec.hpp
index 64b8c99..24152e1 100644
--- a/chilbert/StaticBitVec.hpp
+++ b/chilbert/StaticBitVec.hpp
@@ -45,13 +45,13 @@ public:
 
 	StaticBitVec() = default;
 
-	/// Constructor for compatibility with CBigBitVec
+	/// Constructor for compatibility with DynamicBitVec
 	explicit StaticBitVec(const size_t bits)
 	{
 		assert(bits == size());
 	}
 
-	/// Constructor for compatibility with CBigBitVec
+	/// Constructor for compatibility with DynamicBitVec
 	StaticBitVec(const size_t bits, const Rack value)
 	  : StaticBitVec{bits}
 	{