rename BrainFloat16 -> BFloat16

8 files changed, 74 insertions, 74 deletions

diff --git a/vespalib/CMakeLists.txt b/vespalib/CMakeLists.txt
index 3fd9ee8e209..c51e42176dc 100644
--- a/vespalib/CMakeLists.txt
+++ b/vespalib/CMakeLists.txt
@@ -130,7 +130,7 @@ vespa_define_module(
     src/tests/tutorial/simple
     src/tests/tutorial/threads
     src/tests/typify
-    src/tests/util/brain_float16
+    src/tests/util/bfloat16
     src/tests/util/generationhandler
     src/tests/util/generationhandler_stress
     src/tests/util/md5
diff --git a/vespalib/src/tests/util/bfloat16/CMakeLists.txt b/vespalib/src/tests/util/bfloat16/CMakeLists.txt
new file mode 100644
index 00000000000..39a42e6f148
--- /dev/null
+++ b/vespalib/src/tests/util/bfloat16/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+vespa_add_executable(vespalib_bfloat16_test_app TEST
+    SOURCES
+    bfloat16_test.cpp
+    DEPENDS
+    vespalib
+    GTest::GTest
+)
+vespa_add_test(NAME vespalib_bfloat16_test_app COMMAND vespalib_bfloat16_test_app)
diff --git a/vespalib/src/tests/util/brain_float16/brain_float16_test.cpp b/vespalib/src/tests/util/bfloat16/bfloat16_test.cpp
index 9222b01b000..266037dda86 100644
--- a/vespalib/src/tests/util/brain_float16/brain_float16_test.cpp
+++ b/vespalib/src/tests/util/bfloat16/bfloat16_test.cpp
@@ -1,6 +1,6 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/vespalib/util/brain_float16.h>
+#include <vespa/vespalib/util/bfloat16.h>
 #include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/vespalib/gtest/gtest.h>
 #include <stdio.h>
@@ -11,43 +11,43 @@
 
 using namespace vespalib;
 
-using Limits = std::numeric_limits<BrainFloat16>;
+using Limits = std::numeric_limits<BFloat16>;
 
 static std::vector<float> simple_values = {
     0.0, 1.0, -1.0, -0.0, 1.75, 0x1.02p20, -0x1.02p-20, 0x3.0p-100, 0x7.0p100
 };
 
-TEST(BrainFloat16Test, normal_usage) {
+TEST(BFloat16Test, normal_usage) {
     EXPECT_EQ(sizeof(float), 4);
-    EXPECT_EQ(sizeof(BrainFloat16), 2);
-    BrainFloat16 answer = 42;
+    EXPECT_EQ(sizeof(BFloat16), 2);
+    BFloat16 answer = 42;
     double fortytwo = answer;
     EXPECT_EQ(fortytwo, 42);
-    std::vector<BrainFloat16> vec;
+    std::vector<BFloat16> vec;
     for (float value : simple_values) {
-        BrainFloat16 b = value;
+        BFloat16 b = value;
         float recover = b;
         EXPECT_EQ(value, recover);
     }
-    BrainFloat16 b1 = 0x101;
+    BFloat16 b1 = 0x101;
     EXPECT_EQ(float(b1), 0x100);
-    BrainFloat16 b2 = 0x111;
+    BFloat16 b2 = 0x111;
     EXPECT_EQ(float(b2), 0x110);
 }
 
-TEST(BrainFloat16Test, with_nbostream) {
+TEST(BFloat16Test, with_nbostream) {
     nbostream buf;
-    for (BrainFloat16 value : simple_values) {
+    for (BFloat16 value : simple_values) {
         buf << value;
     }
     for (float value : simple_values) {
-        BrainFloat16 stored;
+        BFloat16 stored;
         buf >> stored;
         EXPECT_EQ(float(stored), value);
     }
 }
 
-TEST(BrainFloat16Test, constants_check) {
+TEST(BFloat16Test, constants_check) {
 	EXPECT_EQ(0x1.0p-7, (1.0/128.0));
 
 	float n_min = Limits::min();
@@ -66,9 +66,9 @@ TEST(BrainFloat16Test, constants_check) {
 	EXPECT_EQ(d_min, n_min / 128.0);
 	EXPECT_GT(eps, std::numeric_limits<float>::epsilon());
 
-	BrainFloat16 try_epsilon = 1.0f + eps;
+	BFloat16 try_epsilon = 1.0f + eps;
 	EXPECT_GT(try_epsilon.to_float(), 1.0f);
-	BrainFloat16 try_half_epsilon = 1.0f + (0.5f * eps);
+	BFloat16 try_half_epsilon = 1.0f + (0.5f * eps);
 	EXPECT_EQ(try_half_epsilon.to_float(), 1.0f);
 
 	EXPECT_LT(big, std::numeric_limits<float>::max());
@@ -81,18 +81,18 @@ TEST(BrainFloat16Test, constants_check) {
 	printf("bfloat16 lowest: %.20g (float has %.20g)\n", low, std::numeric_limits<float>::lowest());
 }
 
-TEST(BrainFloat16Test, traits_check) {
-        EXPECT_TRUE(std::is_trivially_constructible<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_trivially_move_constructible<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_trivially_default_constructible<BrainFloat16>::value);
-        EXPECT_TRUE((std::is_trivially_assignable<BrainFloat16,BrainFloat16>::value));
-        EXPECT_TRUE(std::is_trivially_move_assignable<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_trivially_copy_assignable<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_trivially_copyable<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_trivially_destructible<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_trivial<BrainFloat16>::value);
-        EXPECT_TRUE(std::is_swappable<BrainFloat16>::value);
-        EXPECT_TRUE(std::has_unique_object_representations<BrainFloat16>::value);
+TEST(BFloat16Test, traits_check) {
+        EXPECT_TRUE(std::is_trivially_constructible<BFloat16>::value);
+        EXPECT_TRUE(std::is_trivially_move_constructible<BFloat16>::value);
+        EXPECT_TRUE(std::is_trivially_default_constructible<BFloat16>::value);
+        EXPECT_TRUE((std::is_trivially_assignable<BFloat16,BFloat16>::value));
+        EXPECT_TRUE(std::is_trivially_move_assignable<BFloat16>::value);
+        EXPECT_TRUE(std::is_trivially_copy_assignable<BFloat16>::value);
+        EXPECT_TRUE(std::is_trivially_copyable<BFloat16>::value);
+        EXPECT_TRUE(std::is_trivially_destructible<BFloat16>::value);
+        EXPECT_TRUE(std::is_trivial<BFloat16>::value);
+        EXPECT_TRUE(std::is_swappable<BFloat16>::value);
+        EXPECT_TRUE(std::has_unique_object_representations<BFloat16>::value);
 }
 
 static std::string hexdump(const void *p, size_t sz) {
@@ -112,28 +112,28 @@ static std::string hexdump(const void *p, size_t sz) {
 }
 #define HEX_DUMP(arg) hexdump(&arg, sizeof(arg)).c_str()
 
-TEST(BrainFloat16Test, check_special_values) {
+TEST(BFloat16Test, check_special_values) {
     // we should not need to support HW without normal float support:
     EXPECT_TRUE(std::numeric_limits<float>::has_quiet_NaN);
     EXPECT_TRUE(std::numeric_limits<float>::has_signaling_NaN);
-    EXPECT_TRUE(std::numeric_limits<BrainFloat16>::has_quiet_NaN);
-    EXPECT_TRUE(std::numeric_limits<BrainFloat16>::has_signaling_NaN);
+    EXPECT_TRUE(std::numeric_limits<BFloat16>::has_quiet_NaN);
+    EXPECT_TRUE(std::numeric_limits<BFloat16>::has_signaling_NaN);
     std::feclearexcept(FE_ALL_EXCEPT);
     EXPECT_TRUE(std::fetestexcept(FE_INVALID) == 0);
     float f_inf = std::numeric_limits<float>::infinity();
     float f_neg = -f_inf;
     float f_qnan = std::numeric_limits<float>::quiet_NaN();
     float f_snan = std::numeric_limits<float>::signaling_NaN();
-    BrainFloat16 b_inf = std::numeric_limits<BrainFloat16>::infinity();
-    BrainFloat16 b_qnan = std::numeric_limits<BrainFloat16>::quiet_NaN();
-    BrainFloat16 b_snan = std::numeric_limits<BrainFloat16>::signaling_NaN();
-    BrainFloat16 b_from_f_inf = f_inf;
-    BrainFloat16 b_from_f_neg = f_neg;
-    BrainFloat16 b_from_f_qnan = f_qnan;
-    BrainFloat16 b_from_f_snan = f_snan;
-    EXPECT_EQ(memcmp(&b_inf, &b_from_f_inf, sizeof(BrainFloat16)), 0);
-    EXPECT_EQ(memcmp(&b_qnan, &b_from_f_qnan, sizeof(BrainFloat16)), 0);
-    EXPECT_EQ(memcmp(&b_snan, &b_from_f_snan, sizeof(BrainFloat16)), 0);
+    BFloat16 b_inf = std::numeric_limits<BFloat16>::infinity();
+    BFloat16 b_qnan = std::numeric_limits<BFloat16>::quiet_NaN();
+    BFloat16 b_snan = std::numeric_limits<BFloat16>::signaling_NaN();
+    BFloat16 b_from_f_inf = f_inf;
+    BFloat16 b_from_f_neg = f_neg;
+    BFloat16 b_from_f_qnan = f_qnan;
+    BFloat16 b_from_f_snan = f_snan;
+    EXPECT_EQ(memcmp(&b_inf, &b_from_f_inf, sizeof(BFloat16)), 0);
+    EXPECT_EQ(memcmp(&b_qnan, &b_from_f_qnan, sizeof(BFloat16)), 0);
+    EXPECT_EQ(memcmp(&b_snan, &b_from_f_snan, sizeof(BFloat16)), 0);
     printf("+inf float is '%s' / bf16 is '%s'\n", HEX_DUMP(f_inf), HEX_DUMP(b_from_f_inf));
     printf("-inf float is '%s' / bf16 is '%s'\n", HEX_DUMP(f_neg), HEX_DUMP(b_from_f_neg));
     printf("qNaN float is '%s' / bf16 is '%s'\n", HEX_DUMP(f_qnan), HEX_DUMP(b_from_f_qnan));
diff --git a/vespalib/src/tests/util/brain_float16/CMakeLists.txt b/vespalib/src/tests/util/brain_float16/CMakeLists.txt
deleted file mode 100644
index e975abbf44a..00000000000
--- a/vespalib/src/tests/util/brain_float16/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-vespa_add_executable(vespalib_brain_float16_test_app TEST
-    SOURCES
-    brain_float16_test.cpp
-    DEPENDS
-    vespalib
-    GTest::GTest
-)
-vespa_add_test(NAME vespalib_brain_float16_test_app COMMAND vespalib_brain_float16_test_app)
diff --git a/vespalib/src/vespa/vespalib/objects/nbostream.h b/vespalib/src/vespa/vespalib/objects/nbostream.h
index 2462bcebf5d..7119645622f 100644
--- a/vespalib/src/vespa/vespalib/objects/nbostream.h
+++ b/vespalib/src/vespa/vespalib/objects/nbostream.h
@@ -5,7 +5,7 @@
 #include <vespa/vespalib/stllike/string.h>
 #include <vespa/vespalib/util/array.h>
 #include <vespa/vespalib/util/buffer.h>
-#include <vespa/vespalib/util/brain_float16.h>
+#include <vespa/vespalib/util/bfloat16.h>
 #include "nbo.h"
 
 namespace vespalib {
@@ -39,8 +39,8 @@ public:
     nbostream & operator >> (double & v)   { double n; read8(&n); v = nbo::n2h(n); return *this; }
     nbostream & operator << (float v)      { float n(nbo::n2h(v)); write4(&n); return *this; }
     nbostream & operator >> (float & v)    { float n; read4(&n); v = nbo::n2h(n); return *this; }
-    nbostream & operator << (BrainFloat16 v)   { uint16_t n(nbo::n2h(v.get_bits())); write2(&n); return *this; }
-    nbostream & operator >> (BrainFloat16 & v) { uint16_t n; read2(&n); v.assign_bits(nbo::n2h(n)); return *this; }
+    nbostream & operator << (BFloat16 v)   { uint16_t n(nbo::n2h(v.get_bits())); write2(&n); return *this; }
+    nbostream & operator >> (BFloat16 & v) { uint16_t n; read2(&n); v.assign_bits(nbo::n2h(n)); return *this; }
     nbostream & operator << (int64_t v)    { int64_t n(nbo::n2h(v)); write8(&n); return *this; }
     nbostream & operator >> (int64_t & v)  { int64_t n; read8(&n); v = nbo::n2h(n); return *this; }
     nbostream & operator << (uint64_t v)   { uint64_t n(nbo::n2h(v)); write8(&n); return *this; }
diff --git a/vespalib/src/vespa/vespalib/util/CMakeLists.txt b/vespalib/src/vespa/vespalib/util/CMakeLists.txt
index 15878ebb68f..62d642b76b2 100644
--- a/vespalib/src/vespa/vespalib/util/CMakeLists.txt
+++ b/vespalib/src/vespa/vespalib/util/CMakeLists.txt
@@ -10,7 +10,7 @@ vespa_add_library(vespalib_vespalib_util OBJECT
     backtrace.cpp
     barrier.cpp
     benchmark_timer.cpp
-    brain_float16.cpp
+    bfloat16.cpp
     blockingthreadstackexecutor.cpp
     box.cpp
     child_process.cpp
diff --git a/vespalib/src/vespa/vespalib/util/brain_float16.cpp b/vespalib/src/vespa/vespalib/util/bfloat16.cpp
index fc856e04a25..5713ea66886 100644
--- a/vespalib/src/vespa/vespalib/util/brain_float16.cpp
+++ b/vespalib/src/vespa/vespalib/util/bfloat16.cpp
@@ -1,3 +1,3 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include "brain_float16.h"
+#include "bfloat16.h"
diff --git a/vespalib/src/vespa/vespalib/util/brain_float16.h b/vespalib/src/vespa/vespalib/util/bfloat16.h
index 4e449457eeb..8090f0562c7 100644
--- a/vespalib/src/vespa/vespalib/util/brain_float16.h
+++ b/vespalib/src/vespa/vespalib/util/bfloat16.h
@@ -18,7 +18,7 @@ namespace vespalib {
  * See also:
  * https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
  **/
-class BrainFloat16 {
+class BFloat16 {
 private:
     uint16_t _bits;
     struct TwoU16 {
@@ -26,14 +26,14 @@ private:
         uint16_t u2;
     };
 public:
-    constexpr BrainFloat16(float value) noexcept : _bits(float_to_bits(value)) {}
-    BrainFloat16() noexcept = default;
-    ~BrainFloat16() noexcept = default;
-    constexpr BrainFloat16(const BrainFloat16 &other) noexcept = default;
-    constexpr BrainFloat16(BrainFloat16 &&other) noexcept = default;
-    constexpr BrainFloat16& operator=(const BrainFloat16 &other) noexcept = default;
-    constexpr BrainFloat16& operator=(BrainFloat16 &&other) noexcept = default;
-    constexpr BrainFloat16& operator=(float value) noexcept {
+    constexpr BFloat16(float value) noexcept : _bits(float_to_bits(value)) {}
+    BFloat16() noexcept = default;
+    ~BFloat16() noexcept = default;
+    constexpr BFloat16(const BFloat16 &other) noexcept = default;
+    constexpr BFloat16(BFloat16 &&other) noexcept = default;
+    constexpr BFloat16& operator=(const BFloat16 &other) noexcept = default;
+    constexpr BFloat16& operator=(BFloat16 &&other) noexcept = default;
+    constexpr BFloat16& operator=(float value) noexcept {
         _bits = float_to_bits(value);
         return *this;
     }
@@ -78,7 +78,7 @@ public:
 }
 
 namespace std {
-template<> class numeric_limits<vespalib::BrainFloat16> {
+template<> class numeric_limits<vespalib::BFloat16> {
 public:
     static constexpr bool is_specialized = true;
     static constexpr bool is_signed = true;
@@ -108,19 +108,19 @@ public:
     static constexpr int max_exponent = 128;
     static constexpr int max_exponent10 = 38;
 
-    static constexpr vespalib::BrainFloat16 denorm_min() noexcept { return 0x1.0p-133; }
-    static constexpr vespalib::BrainFloat16 epsilon() noexcept { return 0x1.0p-7; }
-    static constexpr vespalib::BrainFloat16 lowest() noexcept { return -0x1.FEp127; }
-    static constexpr vespalib::BrainFloat16 max() noexcept { return 0x1.FEp127; }
-    static constexpr vespalib::BrainFloat16 min() noexcept { return 0x1.0p-126; }
-    static constexpr vespalib::BrainFloat16 round_error() noexcept { return 1.0; }
-    static constexpr vespalib::BrainFloat16 infinity() noexcept {
+    static constexpr vespalib::BFloat16 denorm_min() noexcept { return 0x1.0p-133; }
+    static constexpr vespalib::BFloat16 epsilon() noexcept { return 0x1.0p-7; }
+    static constexpr vespalib::BFloat16 lowest() noexcept { return -0x1.FEp127; }
+    static constexpr vespalib::BFloat16 max() noexcept { return 0x1.FEp127; }
+    static constexpr vespalib::BFloat16 min() noexcept { return 0x1.0p-126; }
+    static constexpr vespalib::BFloat16 round_error() noexcept { return 1.0; }
+    static constexpr vespalib::BFloat16 infinity() noexcept {
         return std::numeric_limits<float>::infinity();
     }
-    static constexpr vespalib::BrainFloat16 quiet_NaN() noexcept {
+    static constexpr vespalib::BFloat16 quiet_NaN() noexcept {
         return std::numeric_limits<float>::quiet_NaN();
     }
-    static constexpr vespalib::BrainFloat16 signaling_NaN() noexcept {
+    static constexpr vespalib::BFloat16 signaling_NaN() noexcept {
         return std::numeric_limits<float>::signaling_NaN();
     }
 };