Use consistent naming scheme

1 files changed, 18 insertions, 18 deletions

diff --git a/chilbert/Operations.hpp b/chilbert/Operations.hpp
index 37a4b03..24474cc 100644
--- a/chilbert/Operations.hpp
+++ b/chilbert/Operations.hpp
@@ -33,7 +33,7 @@ namespace chilbert {
 /// Reset all bits in `field`
 template <typename T>
 std::enable_if_t<std::is_integral<T>::value>
-resetBits(T& field)
+reset_bits(T& field)
 {
 	field = static_cast<T>(0);
 }
@@ -41,7 +41,7 @@ resetBits(T& field)
 /// Reset all bits in `field`
 template <typename T>
 std::enable_if_t<is_bitvec_v<T>>
-resetBits(T& field)
+reset_bits(T& field)
 {
 	field.reset();
 }
@@ -49,7 +49,7 @@ resetBits(T& field)
 /// Return the `index`th bit in `field`
 template <typename T>
 std::enable_if_t<std::is_integral<T>::value, bool>
-testBit(const T& field, const size_t index)
+test_bit(const T& field, const size_t index)
 {
 	assert(size_t(index) < sizeof(field) * CHAR_BIT);
 	return field & (T{1} << index);
@@ -58,7 +58,7 @@ testBit(const T& field, const size_t index)
 /// Return the `index`th bit in `field`
 template <typename T>
 std::enable_if_t<is_bitvec_v<T>, bool>
-testBit(const T& field, const size_t index)
+test_bit(const T& field, const size_t index)
 {
 	return field.test(index);
 }
@@ -66,27 +66,27 @@ testBit(const T& field, const size_t index)
 /// Set the `index`th bit in `field`
 template <typename T>
 std::enable_if_t<std::is_integral<T>::value>
-setBit(T& field, const size_t index)
+set_bit(T& field, const size_t index)
 {
 	assert(size_t(index) < sizeof(field) * CHAR_BIT);
 	field |= (T{1} << index);
-	assert(testBit(field, index));
+	assert(test_bit(field, index));
 }
 
 /// Set the `index`th bit in `field` to `value`
 template <typename T>
 std::enable_if_t<std::is_integral<T>::value>
-setBit(T& field, const size_t index, const bool value)
+set_bit(T& field, const size_t index, const bool value)
 {
 	assert(size_t(index) < sizeof(field) * CHAR_BIT);
 	field ^= (-T{value} ^ field) & (T{1U} << index);
-	assert(testBit(field, index) == value);
+	assert(test_bit(field, index) == value);
 }
 
 /// Set the `index`th bit in `field`
 template <typename T>
 std::enable_if_t<is_bitvec_v<T>>
-setBit(T& field, const size_t index)
+set_bit(T& field, const size_t index)
 {
 	field.set(index);
 }
@@ -94,7 +94,7 @@ setBit(T& field, const size_t index)
 /// Set the `index`th bit in `field` to `value`
 template <typename T>
 std::enable_if_t<is_bitvec_v<T>>
-setBit(T& field, const size_t index, const bool value)
+set_bit(T& field, const size_t index, const bool value)
 {
 	field.set(index, value);
 }
@@ -119,42 +119,42 @@ pop_count<unsigned long long>(const unsigned long long& field)
 
 /// Return 1 + the index of the least significant 1-bit of `field`, or zero
 template <typename T>
-int ffs(const T field);
+int find_first(const T field);
 
 template <>
 int
-ffs<unsigned long>(const unsigned long field)
+find_first<unsigned long>(const unsigned long field)
 {
 	return __builtin_ffsl(static_cast<long>(field));
 }
 
 template <>
 int
-ffs<unsigned long long>(const unsigned long long field)
+find_first<unsigned long long>(const unsigned long long field)
 {
 	return __builtin_ffsll(static_cast<long long>(field));
 }
 
 /// Calculates the Gray Code of `value` in place
 template <typename T>
-std::enable_if_t<is_bitvec_v<T>> grayCode(T& value);
+std::enable_if_t<is_bitvec_v<T>> gray_code(T& value);
 
 /// Implementation of grayCode for any integral type
 template <typename T>
 std::enable_if_t<std::is_integral<T>::value>
-grayCode(T& value)
+gray_code(T& value)
 {
 	value ^= (value >> 1);
 }
 
 /// Calculates the inverse Gray Code of `value` in place
 template <typename T>
-std::enable_if_t<is_bitvec_v<T>> grayCodeInv(T& value);
+std::enable_if_t<is_bitvec_v<T>> gray_code_inv(T& value);
 
-/// Implementation of grayCodeInv for any integral type
+/// Implementation of gray_code_inv for any integral type
 template <typename T>
 std::enable_if_t<std::is_integral<T>::value>
-grayCodeInv(T& value)
+gray_code_inv(T& value)
 {
 	for (T shift = 1; shift < sizeof(T) * CHAR_BIT; shift <<= 1) {
 		value ^= (value >> shift);