Standardize on "floating-point" rather than "floating point"

Author: trflynn89

bench/util/table.hpp

@@ -169,7 +169,7 @@ class Table
 
     /**
      * Helper to determine if a numeric value is zero (if integral), or close enough to zero (if
-     * floating point).
+     * floating-point).
      *
      * @tparam T The numeric type of the value to test.
      *

fly/fly.hpp

@@ -163,10 +163,10 @@ constexpr bool supports_consteval()
 }
 
 /**
- * Compile-time helper function to determine if floating point charconv operations (std::from_chars,
+ * Compile-time helper function to determine if floating-point charconv operations (std::from_chars,
  * std::to_chars) are supported.
  *
- * @return True if the compiler supports floating point charconv operations.
+ * @return True if the compiler supports floating-point charconv operations.
  */
 constexpr bool supports_floating_point_charconv()
 {

fly/types/json/json.hpp

@@ -78,7 +78,7 @@ namespace fly {
  *
  *     A JSON boolean, number, or null value may be created from analogous C++ plain-old-data types.
  *     Internally, 64-bit integers are used for storing integer numbers and long doubles for
- *     floating point numbers. The signedness of the 64-bit integer is the same as the integer from
+ *     floating-point numbers. The signedness of the 64-bit integer is the same as the integer from
  *     which the JSON value is created. For example:
  *
  *         fly::Json json = true;
@@ -145,7 +145,7 @@ namespace fly {
  *         convert based on whether the value is empty. JSON numbers will convert based on whether
  *         the value is non-zero. Null JSON values always convert to false.
  *
- *         JSON numbers may be converted to any numeric type. For example, a floating point JSON
+ *         JSON numbers may be converted to any numeric type. For example, a floating-point JSON
  *         value may be converted to an integer.
  *
  * Lastly, this class defines the canonical interfaces of STL container types. This includes element
@@ -276,13 +276,13 @@ class Json
     Json(T value) noexcept;
 
     /**
-     * Floating point constructor. Intializes the Json instance to a floating point value. The
-     * SFINAE declaration allows construction of a floating point value from any floating point type
+     * Floating-point constructor. Intializes the Json instance to a floating-point value. The
+     * SFINAE declaration allows construction of a floating-point value from any floating-point type
      * (e.g. float, double).
      *
-     * @tparam T The floating point type.
+     * @tparam T The floating-point type.
      *
-     * @param value The floating point value.
+     * @param value The floating-point value.
      */
     template <typename T, enable_if<JsonTraits::is_floating_point<T>> = 0>
     Json(T value) noexcept;
@@ -1335,9 +1335,9 @@ class Json
      * Equality operator. Compares two Json instances for equality. They are equal if one of the
      * following is true:
      *
-     * 1. One of the two JSON types are floating point, the other is a numeric type (signed,
+     * 1. One of the two JSON types are floating-point, the other is a numeric type (signed,
      *    unsigned, or float) and have approximately the same value after converting both types to
-     *    floating point. Approximation is determined by comparing the difference between the two
+     *    floating-point. Approximation is determined by comparing the difference between the two
      *    values to the machine epsilon.
      * 2. The two Json instances are an integer type (signed or unsigned) and have the same value
      *    after converting the second Json value to the same type as the first Json value.

fly/types/string/detail/converter.hpp

@@ -12,9 +12,9 @@ namespace fly::detail {
 /**
  * Helper struct to convert a std::string to a plain-old-data type, e.g. int or float.
  *
- * Ideally, this entire helper can be removed when the STL supports floating point types with
+ * Ideally, this entire helper can be removed when the STL supports floating-point types with
  * std::from_chars. However, only integral types are currently supported. Thus, integral types will
- * use std::from_chars, and floating point types will use the std::stof family of functions.
+ * use std::from_chars, and floating-point types will use the std::stof family of functions.
  *
  * https://en.cppreference.com/w/cpp/compiler_support
  *

fly/types/string/detail/format_specifier.hpp

@@ -55,7 +55,7 @@ namespace fly::detail {
  *        Integral types - If binary, octal, or hexadecimal presentation types are used, the
  *        alternate form inserts 0b, 0, or 0x prefixes, respectively, before the value.
  *
- *        Floating point types - A decimal point character will always be inserted even if no digits
+ *        Floating-point types - A decimal point character will always be inserted even if no digits
  *        follow it.
  *
  *     4. A zero-padding indicator (a literal "0" character). If present, the value is padded with
@@ -70,15 +70,15 @@ namespace fly::detail {
  *
  *        String types - precision specifies the maxiumum number of characters to be used.
  *
- *        Floating point types - precision specifies the formatting precision.
+ *        Floating-point types - precision specifies the formatting precision.
  *
  *     7. A locale-specific form indicator (a literal "L" character). It may only be used for the
  *        following value types:
  *
  *        Integral types - locale-specific form inserts appropriate digit group separator
  *        characters.
  *
- *        Floating point types - locale-specific form inserts appropriate digit group and radix
+ *        Floating-point types - locale-specific form inserts appropriate digit group and radix
  *        separator characters.
  *
  *        Boolean types - locale-specific form uses the appropriate string for textual
@@ -95,7 +95,7 @@ namespace fly::detail {
  *
  *        Integral types - Valid presentations: none, "c", b", "B", "o", "d", "x", "X".
  *
- *        Floating point types - Valid presentations: none, "a", A", "e", "E", "f", "F", "g", "G".
+ *        Floating-point types - Valid presentations: none, "a", A", "e", "E", "f", "F", "g", "G".
  *
  *        Boolean types - Valid presentations: none, "c", s", b", "B", "o", "d", "x", "X".
  *
@@ -316,7 +316,7 @@ struct BasicFormatSpecifier
      * Parse the precision argument of the replacement field.
      *
      * It is an error the precision was specified, but the type of the corresponding format
-     * parameter is not a string or floating point type.
+     * parameter is not a string or floating-point type.
      *
      * It is an error if a decimal was parsed and was not followed by a non-negative precision or a
      * replacement field.
@@ -337,7 +337,7 @@ struct BasicFormatSpecifier
      * Parse the optional locale-specific form of the replacement field.
      *
      * It is an error the locale-specific form was specified, but the type of the corresponding
-     * format parameter is not an integral, floating point, or boolean type.
+     * format parameter is not an integral, floating-point, or boolean type.
      *
      * @param context The context holding the format string parsing state.
      */
@@ -708,7 +708,7 @@ constexpr void BasicFormatSpecifier<CharType>::validate(FormatParseContext &cont
         if ((parameter_type != ParameterType::String) &&
             (parameter_type != ParameterType::FloatingPoint))
         {
-            context.on_error("Precision may only be used for string and floating point types");
+            context.on_error("Precision may only be used for string and floating-point types");
         }
         else if (m_precision_position)
         {
@@ -777,7 +777,7 @@ constexpr void BasicFormatSpecifier<CharType>::validate_type(
             (m_type != Type::General))
         {
             context.on_error(
-                "Floating point types must be formatted with {} or one of {:aAeEfFgG}");
+                "Floating-point types must be formatted with {} or one of {:aAeEfFgG}");
         }
     }
     else if (parameter_type == ParameterType::Boolean)

fly/types/string/formatters.hpp

@@ -234,9 +234,9 @@ struct Formatter<T, CharType, fly::enable_if<std::is_floating_point<T>>>
     explicit Formatter(FormatSpecifier &&specifier) noexcept;
 
     /**
-     * Format a single replacement field with the provided floating point value.
+     * Format a single replacement field with the provided floating-point value.
      *
-     * Currently, not all major compilers support std::to_chars for floating point values. If it is
+     * Currently, not all major compilers support std::to_chars for floating-point values. If it is
      * supported by the compiler, then std::to_chars is used for the conversion, and the result is
      * further formatted according to the replacement field specification. If it is not supported,
      * an IO stream is used to format the value.
@@ -255,7 +255,7 @@ struct Formatter<T, CharType, fly::enable_if<std::is_floating_point<T>>>
 #if defined(FLY_COMPILER_SUPPORTS_FP_CHARCONV)
 
     /**
-     * Structure to hold the information needed to fully format a floating point value as a string.
+     * Structure to hold the information needed to fully format a floating-point value as a string.
      */
     struct FloatConversionResult
     {
@@ -266,15 +266,15 @@ struct Formatter<T, CharType, fly::enable_if<std::is_floating_point<T>>>
     };
 
     /**
-     * Convert a floating point value to a string.
+     * Convert a floating-point value to a string.
      *
-     * Internally, std::to_chars is used for the conversion, which does not handle all floating
-     * point formatting options, such as alternate form. So rather than creating a fully-formatted
-     * string, this method returns a structure holding the information needed to format the value as
-     * a string.
+     * Internally, std::to_chars is used for the conversion, which does not handle all
+     * floating-point formatting options, such as alternate form. So rather than creating a
+     * fully-formatted string, this method returns a structure holding the information needed to
+     * format the value as a string.
      *
      * @param value The value to convert.
-     * @param precision The floating point precision to use.
+     * @param precision The floating-point precision to use.
      *
      * @return A structure holding the information needed to fully format the value as a string.
      */

test/types/string/converter.cpp

@@ -315,7 +315,7 @@ CATCH_TEMPLATE_TEST_CASE("Converter", "[string]", char, wchar_t, char8_t, char16
         CATCH_CHECK_FALSE(BasicString::template convert<std::uint64_t>(s));
     }
 
-    CATCH_SECTION("Convert a string to a floating point decimal")
+    CATCH_SECTION("Convert a string to a floating-point decimal")
     {
         string_type s;
 

test/types/string/format.cpp

@@ -306,7 +306,7 @@ CATCH_TEMPLATE_TEST_CASE("Format", "[string]", char, wchar_t, char8_t, char16_t,
         test_format(FMT("{:#X}"), FMT("0X1"), 1);
     }
 
-    CATCH_SECTION("Alternate form preserves decimal for floating point types")
+    CATCH_SECTION("Alternate form preserves decimal for floating-point types")
     {
         test_format(FMT("{:#.0g}"), FMT("1."), 1.0);
     }
@@ -387,7 +387,7 @@ CATCH_TEMPLATE_TEST_CASE("Format", "[string]", char, wchar_t, char8_t, char16_t,
         test_format(FMT("{:3}"), FMT("123456"), 123456);
     }
 
-    CATCH_SECTION("Precision value sets floating point precision")
+    CATCH_SECTION("Precision value sets floating-point precision")
     {
         test_format(FMT("{:.3f}"), FMT("1.000"), 1.0);
         test_format(FMT("{:.2f}"), FMT("3.14"), 3.14159);
@@ -429,7 +429,7 @@ CATCH_TEMPLATE_TEST_CASE("Format", "[string]", char, wchar_t, char8_t, char16_t,
         test_format(FMT("{:.0s}"), FMT(""), FLY_STR(char_type, "abcdef"));
     }
 
-    CATCH_SECTION("Precision position sets floating point precision")
+    CATCH_SECTION("Precision position sets floating-point precision")
     {
         test_format(FMT("{:.{}f}"), FMT("1.000"), 1.0, 3);
         test_format(FMT("{0:.{1}f}"), FMT("3.14"), 3.14159, 2);

test/types/string/format_string.cpp

@@ -129,7 +129,7 @@ constexpr const char *s_bad_width_position = "Position of width parameter must b
 constexpr const char *s_missing_precision =
     "Expected a non-negative precision or nested replacement field after decimal";
 constexpr const char *s_bad_precision =
-    "Precision may only be used for string and floating point types";
+    "Precision may only be used for string and floating-point types";
 constexpr const char *s_bad_precision_position =
     "Position of precision parameter must be an integral type";
 constexpr const char *s_bad_locale =
@@ -141,7 +141,7 @@ constexpr const char *s_bad_pointer = "Pointer types must be formatted with {} o
 constexpr const char *s_bad_integer =
     "Integral types must be formatted with {} or one of {:cbBodxX}";
 constexpr const char *s_bad_float =
-    "Floating point types must be formatted with {} or one of {:aAeEfFgG}";
+    "Floating-point types must be formatted with {} or one of {:aAeEfFgG}";
 constexpr const char *s_bad_bool = "Boolean types must be formatted with {} or one of {:csbBodxX}";
 
 #endif
@@ -837,7 +837,7 @@ CATCH_TEMPLATE_TEST_CASE(
         test_error(make_format(FMT("{:.-1}"), 1), s_missing_precision);
     }
 
-    CATCH_SECTION("Precision value only valid for string and floating point types")
+    CATCH_SECTION("Precision value only valid for string and floating-point types")
     {
         test_error(make_format(FMT("{:.1}"), 1), s_bad_precision);
     }
@@ -848,7 +848,7 @@ CATCH_TEMPLATE_TEST_CASE(
         test_error(make_format(FMT("{0:.{1}}"), s, s), s_bad_precision_position);
     }
 
-    CATCH_SECTION("Precision position only valid for string and floating point types")
+    CATCH_SECTION("Precision position only valid for string and floating-point types")
     {
         test_error(make_format(FMT("{:.{}}"), 1, 1), s_bad_precision);
         test_error(make_format(FMT("{0:.{1}}"), 1, 1), s_bad_precision);