Changed HalfVector to use std::float16_t when available

ankane · ankane · commit 0b94a2001568 · 2026-03-05T00:55:27.000-08:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 ## 0.3.0 (unreleased)
 
 - Added support for libpqxx 8
+- Changed `HalfVector` to use `std::float16_t` when available
 - Dropped support for libpqxx 7
 - Dropped support for C++17
 
diff --git a/include/pgvector/halfvec.hpp b/include/pgvector/halfvec.hpp
@@ -12,31 +12,42 @@
 #include <utility>
 #include <vector>
 
+#if __STDCPP_FLOAT16_T__
+#include <stdfloat>
+#endif
+
 namespace pgvector {
+
+#if __STDCPP_FLOAT16_T__
+using HalfType = std::float16_t;
+#else
+using HalfType = float;
+#endif
+
 /// A half vector.
 class HalfVector {
   public:
-    /// Creates a half vector from a `std::vector<float>`.
-    explicit HalfVector(const std::vector<float>& value) : value_{value} {}
+    /// Creates a half vector from a `std::vector<pgvector::HalfType>`.
+    explicit HalfVector(const std::vector<HalfType>& value) : value_{value} {}
 
-    /// Creates a half vector from a `std::vector<float>`.
-    explicit HalfVector(std::vector<float>&& value) : value_{std::move(value)} {}
+    /// Creates a half vector from a `std::vector<pgvector::HalfType>`.
+    explicit HalfVector(std::vector<HalfType>&& value) : value_{std::move(value)} {}
 
     /// Creates a half vector from a span.
-    explicit HalfVector(std::span<const float> value) : value_{std::vector<float>(value.begin(), value.end())} {}
+    explicit HalfVector(std::span<const HalfType> value) : value_{std::vector<HalfType>(value.begin(), value.end())} {}
 
     /// Returns the number of dimensions.
     size_t dimensions() const {
         return value_.size();
     }
 
-    /// Returns the half vector as a `std::vector<float>`.
-    operator const std::vector<float>() const {
+    /// Returns the half vector as a `std::vector<pgvector::HalfType>`.
+    operator const std::vector<HalfType>() const {
         return value_;
     }
 
-    /// Returns the half vector as a `std::span<const float>`.
-    operator const std::span<const float>() const {
+    /// Returns the half vector as a `std::span<const pgvector::HalfType>`.
+    operator const std::span<const HalfType>() const {
         return value_;
     }
 
@@ -57,7 +68,6 @@ class HalfVector {
     }
 
   private:
-    // TODO use std::float16_t for C++23
-    std::vector<float> value_;
+    std::vector<HalfType> value_;
 };
 } // namespace pgvector
diff --git a/include/pgvector/pqxx.hpp b/include/pgvector/pqxx.hpp
@@ -93,23 +93,23 @@ template <> struct string_traits<pgvector::HalfVector> {
             throw conversion_error("Malformed halfvec literal");
         }
 
-        std::vector<float> values;
+        std::vector<pgvector::HalfType> values;
         if (text.size() > 2) {
             std::string_view inner = text.substr(1, text.size() - 2);
             size_t start = 0;
             for (size_t i = 0; i < inner.size(); i++) {
                 if (inner[i] == ',') {
-                    values.push_back(string_traits<float>::from_string(inner.substr(start, i - start), c));
+                    values.push_back(static_cast<pgvector::HalfType>(string_traits<float>::from_string(inner.substr(start, i - start), c)));
                     start = i + 1;
                 }
             }
-            values.push_back(string_traits<float>::from_string(inner.substr(start), c));
+            values.push_back(static_cast<pgvector::HalfType>(string_traits<float>::from_string(inner.substr(start), c)));
         }
         return pgvector::HalfVector(std::move(values));
     }
 
     static std::string_view to_buf(std::span<char> buf, const pgvector::HalfVector& value, ctx c = {}) {
-        std::span<const float> values{value};
+        std::span<const pgvector::HalfType> values{value};
 
         // important! size_buffer cannot throw an exception on overflow
         // so perform this check before writing any data
@@ -124,7 +124,7 @@ template <> struct string_traits<pgvector::HalfVector> {
             if (i != 0) {
                 buf[here++] = ',';
             }
-            here += pqxx::into_buf(buf.subspan(here), values[i], c);
+            here += pqxx::into_buf(buf.subspan(here), static_cast<float>(values[i]), c);
         }
 
         buf[here++] = ']';
@@ -133,15 +133,15 @@ template <> struct string_traits<pgvector::HalfVector> {
     }
 
     static size_t size_buffer(const pgvector::HalfVector& value) noexcept {
-        std::span<const float> values{value};
+        std::span<const pgvector::HalfType> values{value};
 
         // cannot throw an exception here on overflow
         // so throw in into_buf
 
         size_t size = 2; // [ and ]
         for (const auto v : values) {
             size += 1; // ,
-            size += string_traits<float>::size_buffer(v);
+            size += string_traits<float>::size_buffer(static_cast<float>(v));
         }
         return size;
     }
diff --git a/test/halfvec_test.cpp b/test/halfvec_test.cpp
@@ -12,7 +12,7 @@ static void test_constructor_vector() {
 }
 
 static void test_constructor_span() {
-    auto vec = HalfVector(std::span<const float>({1, 2, 3}));
+    auto vec = HalfVector(std::span<const pgvector::HalfType>({1, 2, 3}));
     assert_equal(vec.dimensions(), 3u);
 }
 
diff --git a/test/pqxx_test.cpp b/test/pqxx_test.cpp
@@ -49,7 +49,7 @@ void test_halfvec(pqxx::connection &conn) {
 
     pqxx::nontransaction tx(conn);
     auto embedding = pgvector::HalfVector({1, 2, 3});
-    float arr[] = {4, 5, 6};
+    pgvector::HalfType arr[] = {4, 5, 6};
     auto embedding2 = pgvector::HalfVector(std::span{arr, 3});
     tx.exec("INSERT INTO items (half_embedding) VALUES ($1), ($2), ($3)", {embedding, embedding2, std::nullopt});
 
@@ -179,16 +179,20 @@ void test_vector_from_string() {
 
 void test_halfvec_to_string() {
     assert_equal(pqxx::to_string(pgvector::HalfVector({1, 2, 3})), "[1,2,3]");
+#if __STDCPP_FLOAT16_T__
+    assert_equal(pqxx::to_string(pgvector::HalfVector({-1.234567890123f16})), "[-1.234375]");
+#else
     assert_equal(pqxx::to_string(pgvector::HalfVector({-1.234567890123})), "[-1.2345679]");
+#endif
 
     assert_exception<pqxx::conversion_overrun>([] {
-        pqxx::to_string(pgvector::HalfVector(std::vector<float>(16001)));
+        pqxx::to_string(pgvector::HalfVector(std::vector<pgvector::HalfType>(16001)));
     }, "halfvec cannot have more than 16000 dimensions");
 }
 
 void test_halfvec_from_string() {
     assert_equal(pqxx::from_string<pgvector::HalfVector>("[1,2,3]"), pgvector::HalfVector({1, 2, 3}));
-    assert_equal(pqxx::from_string<pgvector::HalfVector>("[]"), pgvector::HalfVector(std::vector<float>{}));
+    assert_equal(pqxx::from_string<pgvector::HalfVector>("[]"), pgvector::HalfVector(std::vector<pgvector::HalfType>{}));
 
     assert_exception<pqxx::conversion_error>([] {
         auto _ = pqxx::from_string<pgvector::HalfVector>("");

Original file line number	Diff line number	Diff line change
`@@ -93,23 +93,23 @@ template <> struct string_traits<pgvector::HalfVector> {`
`93`	`93`	`throw conversion_error("Malformed halfvec literal");`
`94`	`94`	`}`
`95`	`95`
`96`		`- std::vector<float> values;`
	`96`	`+ std::vector<pgvector::HalfType> values;`
`97`	`97`	`if (text.size() > 2) {`
`98`	`98`	`std::string_view inner = text.substr(1, text.size() - 2);`
`99`	`99`	`size_t start = 0;`
`100`	`100`	`for (size_t i = 0; i < inner.size(); i++) {`
`101`	`101`	`if (inner[i] == ',') {`
`102`		`- values.push_back(string_traits<float>::from_string(inner.substr(start, i - start), c));`
	`102`	`+ values.push_back(static_cast<pgvector::HalfType>(string_traits<float>::from_string(inner.substr(start, i - start), c)));`
`103`	`103`	`start = i + 1;`
`104`	`104`	`}`
`105`	`105`	`}`
`106`		`- values.push_back(string_traits<float>::from_string(inner.substr(start), c));`
	`106`	`+ values.push_back(static_cast<pgvector::HalfType>(string_traits<float>::from_string(inner.substr(start), c)));`
`107`	`107`	`}`
`108`	`108`	`return pgvector::HalfVector(std::move(values));`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`static std::string_view to_buf(std::span<char> buf, const pgvector::HalfVector& value, ctx c = {}) {`
`112`		`- std::span<const float> values{value};`
	`112`	`+ std::span<const pgvector::HalfType> values{value};`
`113`	`113`
`114`	`114`	`// important! size_buffer cannot throw an exception on overflow`
`115`	`115`	`// so perform this check before writing any data`
`@@ -124,7 +124,7 @@ template <> struct string_traits<pgvector::HalfVector> {`
`124`	`124`	`if (i != 0) {`
`125`	`125`	`buf[here++] = ',';`
`126`	`126`	`}`
`127`		`- here += pqxx::into_buf(buf.subspan(here), values[i], c);`
	`127`	`+ here += pqxx::into_buf(buf.subspan(here), static_cast<float>(values[i]), c);`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`buf[here++] = ']';`
`@@ -133,15 +133,15 @@ template <> struct string_traits<pgvector::HalfVector> {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`static size_t size_buffer(const pgvector::HalfVector& value) noexcept {`
`136`		`- std::span<const float> values{value};`
	`136`	`+ std::span<const pgvector::HalfType> values{value};`
`137`	`137`
`138`	`138`	`// cannot throw an exception here on overflow`
`139`	`139`	`// so throw in into_buf`
`140`	`140`
`141`	`141`	`size_t size = 2; // [ and ]`
`142`	`142`	`for (const auto v : values) {`
`143`	`143`	`size += 1; // ,`
`144`		`- size += string_traits<float>::size_buffer(v);`
	`144`	`+ size += string_traits<float>::size_buffer(static_cast<float>(v));`
`145`	`145`	`}`
`146`	`146`	`return size;`
`147`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ static void test_constructor_vector() {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`static void test_constructor_span() {`
`15`		`- auto vec = HalfVector(std::span<const float>({1, 2, 3}));`
	`15`	`+ auto vec = HalfVector(std::span<const pgvector::HalfType>({1, 2, 3}));`
`16`	`16`	`assert_equal(vec.dimensions(), 3u);`
`17`	`17`	`}`
`18`	`18`