GH-15168: [GLib] Add support for half float (#15169)

* Closes: #15168

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>

c_glib/arrow-glib/array-builder.cpp

@@ -402,6 +402,9 @@ G_BEGIN_DECLS
  * #GArrowUInt64ArrayBuilder is the class to create a new
  * #GArrowUInt64Array.
  *
+ * #GArrowHalfFloatArrayBuilder is the class to creating a new
+ * #GArrowHalfFloatArray.
+ *
  * #GArrowFloatArrayBuilder is the class to creating a new
  * #GArrowFloatArray.
  *
@@ -2599,6 +2602,99 @@ garrow_uint64_array_builder_append_nulls(GArrowUInt64ArrayBuilder *builder,
 }
 
 
+G_DEFINE_TYPE(GArrowHalfFloatArrayBuilder,
+              garrow_half_float_array_builder,
+              GARROW_TYPE_ARRAY_BUILDER)
+
+static void
+garrow_half_float_array_builder_init(GArrowHalfFloatArrayBuilder *builder)
+{
+}
+
+static void
+garrow_half_float_array_builder_class_init(
+  GArrowHalfFloatArrayBuilderClass *klass)
+{
+}
+
+/**
+ * garrow_half_float_array_builder_new:
+ *
+ * Returns: A newly created #GArrowHalfFloatArrayBuilder.
+ *
+ * Since: 11.0.0
+ */
+GArrowHalfFloatArrayBuilder *
+garrow_half_float_array_builder_new(void)
+{
+  auto builder = garrow_array_builder_new(arrow::float16(),
+                                          nullptr,
+                                          "[half-float-array-builder][new]");
+  return GARROW_HALF_FLOAT_ARRAY_BUILDER(builder);
+}
+
+/**
+ * garrow_half_float_array_builder_append_value:
+ * @builder: A #GArrowHalfFloatArrayBuilder.
+ * @value: A 16-bit float value.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ *
+ * Since: 11.0.0
+ */
+gboolean
+garrow_half_float_array_builder_append_value(
+  GArrowHalfFloatArrayBuilder *builder,
+  guint16 value,
+  GError **error)
+{
+  return garrow_array_builder_append_value<arrow::HalfFloatBuilder *>
+    (GARROW_ARRAY_BUILDER(builder),
+     value,
+     error,
+     "[half-float-array-builder][append-value]");
+}
+
+/**
+ * garrow_half_float_array_builder_append_values:
+ * @builder: A #GArrowHalfFloatArrayBuilder.
+ * @values: (array length=values_length): The array of 16-bit float.
+ * @values_length: The length of `values`.
+ * @is_valids: (nullable) (array length=is_valids_length): The array of
+ *   boolean that shows whether the Nth value is valid or not. If the
+ *   Nth `is_valids` is %TRUE, the Nth `values` is valid value. Otherwise
+ *   the Nth value is null value.
+ * @is_valids_length: The length of `is_valids`.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Append multiple values at once. It's more efficient than multiple
+ * `append` and `append_null` calls.
+ *
+ * Returns: %TRUE on success, %FALSE if there was an error.
+ *
+ * Since: 11.0.0
+ */
+gboolean
+garrow_half_float_array_builder_append_values(
+  GArrowHalfFloatArrayBuilder *builder,
+  const guint16 *values,
+  gint64 values_length,
+  const gboolean *is_valids,
+  gint64 is_valids_length,
+  GError **error)
+{
+  return garrow_array_builder_append_values<arrow::HalfFloatBuilder *>
+    (GARROW_ARRAY_BUILDER(builder),
+     values,
+     values_length,
+     is_valids,
+     is_valids_length,
+     error,
+     "[half-float-array-builder][append-values]");
+}
+
+
 G_DEFINE_TYPE(GArrowFloatArrayBuilder,
               garrow_float_array_builder,
               GARROW_TYPE_ARRAY_BUILDER)
@@ -6494,6 +6590,9 @@ garrow_array_builder_new_raw(arrow::ArrayBuilder *arrow_builder,
     case arrow::Type::type::INT64:
       type = GARROW_TYPE_INT64_ARRAY_BUILDER;
       break;
+    case arrow::Type::type::HALF_FLOAT:
+      type = GARROW_TYPE_HALF_FLOAT_ARRAY_BUILDER;
+      break;
     case arrow::Type::type::FLOAT:
       type = GARROW_TYPE_FLOAT_ARRAY_BUILDER;
       break;

c_glib/arrow-glib/array-builder.h

@@ -550,6 +550,38 @@ gboolean garrow_uint64_array_builder_append_nulls(GArrowUInt64ArrayBuilder *buil
 #endif
 
 
+#define GARROW_TYPE_HALF_FLOAT_ARRAY_BUILDER    \
+  (garrow_half_float_array_builder_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowHalfFloatArrayBuilder,
+                         garrow_half_float_array_builder,
+                         GARROW,
+                         HALF_FLOAT_ARRAY_BUILDER,
+                         GArrowArrayBuilder)
+struct _GArrowHalfFloatArrayBuilderClass
+{
+  GArrowArrayBuilderClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_11_0
+GArrowHalfFloatArrayBuilder *
+garrow_half_float_array_builder_new(void);
+
+GARROW_AVAILABLE_IN_11_0
+gboolean
+garrow_half_float_array_builder_append_value(
+  GArrowHalfFloatArrayBuilder *builder,
+  guint16 value,
+  GError **error);
+GARROW_AVAILABLE_IN_11_0
+gboolean garrow_half_float_array_builder_append_values(
+  GArrowHalfFloatArrayBuilder *builder,
+  const guint16 *values,
+  gint64 values_length,
+  const gboolean *is_valids,
+  gint64 is_valids_length,
+  GError **error);
+
+
 #define GARROW_TYPE_FLOAT_ARRAY_BUILDER (garrow_float_array_builder_get_type())
 G_DECLARE_DERIVABLE_TYPE(GArrowFloatArrayBuilder,
                          garrow_float_array_builder,

c_glib/arrow-glib/basic-array.cpp

@@ -1844,6 +1844,83 @@ garrow_uint64_array_get_values(GArrowUInt64Array *array,
 }
 
 
+G_DEFINE_TYPE(GArrowHalfFloatArray,
+              garrow_half_float_array,
+              GARROW_TYPE_NUMERIC_ARRAY)
+
+static void
+garrow_half_float_array_init(GArrowHalfFloatArray *object)
+{
+}
+
+static void
+garrow_half_float_array_class_init(GArrowHalfFloatArrayClass *klass)
+{
+}
+
+/**
+ * garrow_half_float_array_new:
+ * @length: The number of elements.
+ * @data: The binary data in Arrow format of the array.
+ * @null_bitmap: (nullable): The bitmap that shows null elements. The
+ *   N-th element is null when the N-th bit is 0, not null otherwise.
+ *   If the array has no null elements, the bitmap must be %NULL and
+ *   @n_nulls is 0.
+ * @n_nulls: The number of null elements. If -1 is specified, the
+ *   number of nulls are computed from @null_bitmap.
+ *
+ * Returns: A newly created #GArrowHalfFloatArray.
+ *
+ * Since: 11.0.0
+ */
+GArrowHalfFloatArray *
+garrow_half_float_array_new(gint64 length,
+                            GArrowBuffer *data,
+                            GArrowBuffer *null_bitmap,
+                            gint64 n_nulls)
+{
+  auto array = garrow_primitive_array_new<arrow::HalfFloatType>(length,
+                                                                data,
+                                                                null_bitmap,
+                                                                n_nulls);
+  return GARROW_HALF_FLOAT_ARRAY(array);
+}
+
+/**
+ * garrow_half_float_array_get_value:
+ * @array: A #GArrowHalfFloatArray.
+ * @i: The index of the target value.
+ *
+ * Returns: The @i-th value.
+ *
+ * Since: 11.0.0
+ */
+guint16
+garrow_half_float_array_get_value(GArrowHalfFloatArray *array,
+                                  gint64 i)
+{
+  auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array));
+  return std::static_pointer_cast<arrow::HalfFloatArray>(arrow_array)->Value(i);
+}
+
+/**
+ * garrow_half_float_array_get_values:
+ * @array: A #GArrowHalfFloatArray.
+ * @length: (out): The number of values.
+ *
+ * Returns: (array length=length): The raw values.
+ *
+ * Since: 11.0.0
+ */
+const guint16 *
+garrow_half_float_array_get_values(GArrowHalfFloatArray *array,
+                                   gint64 *length)
+{
+  auto arrow_array = garrow_array_get_raw(GARROW_ARRAY(array));
+  return garrow_array_get_values_raw<arrow::HalfFloatType>(arrow_array, length);
+}
+
+
 G_DEFINE_TYPE(GArrowFloatArray,
               garrow_float_array,
               GARROW_TYPE_NUMERIC_ARRAY)
@@ -3490,6 +3567,9 @@ garrow_array_new_raw_valist(std::shared_ptr<arrow::Array> *arrow_array,
   case arrow::Type::type::INT64:
     type = GARROW_TYPE_INT64_ARRAY;
     break;
+  case arrow::Type::type::HALF_FLOAT:
+    type = GARROW_TYPE_HALF_FLOAT_ARRAY;
+    break;
   case arrow::Type::type::FLOAT:
     type = GARROW_TYPE_FLOAT_ARRAY;
     break;

c_glib/arrow-glib/basic-array.h

@@ -345,6 +345,35 @@ const guint64 *garrow_uint64_array_get_values(GArrowUInt64Array *array,
                                               gint64 *length);
 
 
+#define GARROW_TYPE_HALF_FLOAT_ARRAY (garrow_half_float_array_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowHalfFloatArray,
+                         garrow_half_float_array,
+                         GARROW,
+                         HALF_FLOAT_ARRAY,
+                         GArrowNumericArray)
+struct _GArrowHalfFloatArrayClass
+{
+  GArrowNumericArrayClass parent_class;
+};
+
+
+GARROW_AVAILABLE_IN_11_0
+GArrowHalfFloatArray *
+garrow_half_float_array_new(gint64 length,
+                            GArrowBuffer *data,
+                            GArrowBuffer *null_bitmap,
+                            gint64 n_nulls);
+
+GARROW_AVAILABLE_IN_11_0
+guint16
+garrow_half_float_array_get_value(GArrowHalfFloatArray *array,
+                                  gint64 i);
+GARROW_AVAILABLE_IN_11_0
+const guint16*
+garrow_half_float_array_get_values(GArrowHalfFloatArray *array,
+                                   gint64 *length);
+
+
 #define GARROW_TYPE_FLOAT_ARRAY (garrow_float_array_get_type())
 G_DECLARE_DERIVABLE_TYPE(GArrowFloatArray,
                          garrow_float_array,

c_glib/arrow-glib/basic-data-type.cpp

@@ -58,6 +58,9 @@ G_BEGIN_DECLS
  *
  * #GArrowUInt64DataType is a class for the 64-bit unsigned integer data type.
  *
+ * #GArrowHalfFloatDataType is a class for the 16-bit floating point
+ * data type.
+ *
  * #GArrowFloatDataType is a class for the 32-bit floating point data
  * type.
  *
@@ -741,6 +744,39 @@ garrow_floating_point_data_type_class_init(GArrowFloatingPointDataTypeClass *kla
 }
 
 
+G_DEFINE_TYPE(GArrowHalfFloatDataType,
+              garrow_half_float_data_type,
+              GARROW_TYPE_FLOATING_POINT_DATA_TYPE)
+
+static void
+garrow_half_float_data_type_init(GArrowHalfFloatDataType *object)
+{
+}
+
+static void
+garrow_half_float_data_type_class_init(GArrowHalfFloatDataTypeClass *klass)
+{
+}
+
+/**
+ * garrow_half_float_data_type_new:
+ *
+ * Returns: The newly created half float data type.
+ *
+ * Since: 11.0.0
+ */
+GArrowHalfFloatDataType *
+garrow_half_float_data_type_new(void)
+{
+  auto arrow_data_type = arrow::float16();
+  auto data_type =
+    GARROW_HALF_FLOAT_DATA_TYPE(g_object_new(GARROW_TYPE_HALF_FLOAT_DATA_TYPE,
+                                             "data-type", &arrow_data_type,
+                                             NULL));
+  return data_type;
+}
+
+
 G_DEFINE_TYPE(GArrowFloatDataType,
               garrow_float_data_type,
               GARROW_TYPE_FLOATING_POINT_DATA_TYPE)
@@ -2114,6 +2150,9 @@ garrow_data_type_new_raw(std::shared_ptr<arrow::DataType> *arrow_data_type)
   case arrow::Type::type::INT64:
     type = GARROW_TYPE_INT64_DATA_TYPE;
     break;
+  case arrow::Type::type::HALF_FLOAT:
+    type = GARROW_TYPE_HALF_FLOAT_DATA_TYPE;
+    break;
   case arrow::Type::type::FLOAT:
     type = GARROW_TYPE_FLOAT_DATA_TYPE;
     break;

c_glib/arrow-glib/basic-data-type.h

@@ -254,6 +254,21 @@ struct _GArrowFloatingPointDataTypeClass
 };
 
 
+#define GARROW_TYPE_HALF_FLOAT_DATA_TYPE (garrow_half_float_data_type_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowHalfFloatDataType,
+                         garrow_half_float_data_type,
+                         GARROW,
+                         HALF_FLOAT_DATA_TYPE,
+                         GArrowFloatingPointDataType)
+struct _GArrowHalfFloatDataTypeClass
+{
+  GArrowFloatingPointDataTypeClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_11_0
+GArrowHalfFloatDataType *garrow_half_float_data_type_new(void);
+
+
 #define GARROW_TYPE_FLOAT_DATA_TYPE (garrow_float_data_type_get_type())
 G_DECLARE_DERIVABLE_TYPE(GArrowFloatDataType,
                          garrow_float_data_type,