From e85cb4f40cbc16e43b9c6c466da52e07b7098e60 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 9 Sep 2021 05:14:36 -0400
Subject: [PATCH 01/10] testing waters with StructScalar and arithmetic
 infrastructure

---
 cpp/src/arrow/compute/api_scalar.cc           |  5 +--
 cpp/src/arrow/compute/api_scalar.h            | 17 +++++++--
 .../kernels/base_arithmetic_internal.h        | 36 +++++++++++++++++++
 .../compute/kernels/scalar_arithmetic.cc      | 28 +++++++++++++--
 4 files changed, 79 insertions(+), 7 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 3bdff691778..e044b6bcb41 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -672,13 +672,14 @@ Result<Datum> RoundToMultiple(const Datum& arg, RoundToMultipleOptions options,
   }
 
 SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
+SCALAR_ARITHMETIC_BINARY(Subtract, "subtract", "subtract_checked")
+SCALAR_ARITHMETIC_BINARY(Multiply, "multiply", "multiply_checked")
 SCALAR_ARITHMETIC_BINARY(Divide, "divide", "divide_checked")
+SCALAR_ARITHMETIC_BINARY(Divmod, "divmod", "divmod_checked")
 SCALAR_ARITHMETIC_BINARY(Logb, "logb", "logb_checked")
-SCALAR_ARITHMETIC_BINARY(Multiply, "multiply", "multiply_checked")
 SCALAR_ARITHMETIC_BINARY(Power, "power", "power_checked")
 SCALAR_ARITHMETIC_BINARY(ShiftLeft, "shift_left", "shift_left_checked")
 SCALAR_ARITHMETIC_BINARY(ShiftRight, "shift_right", "shift_right_checked")
-SCALAR_ARITHMETIC_BINARY(Subtract, "subtract", "subtract_checked")
 SCALAR_EAGER_BINARY(Atan2, "atan2")
 SCALAR_EAGER_UNARY(Floor, "floor")
 SCALAR_EAGER_UNARY(Ceil, "ceil")
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 7d86a555ec8..cbb187df1ce 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -571,8 +571,7 @@ Result<Datum> Multiply(const Datum& left, const Datum& right,
                        ExecContext* ctx = NULLPTR);
 
 /// \brief Divide two values. Array values must be the same length. If either
-/// argument is null the result will be null. For integer types, if there is
-/// a zero divisor, an error will be raised.
+/// argument is null the result will be null. If divisor is zero, an error will be raised.
 ///
 /// \param[in] left the dividend
 /// \param[in] right the divisor
@@ -584,6 +583,20 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
                      ArithmeticOptions options = ArithmeticOptions(),
                      ExecContext* ctx = NULLPTR);
 
+/// \brief Calculate the quotient and remainder between two values. Array values must be
+/// the same length. If either argument is null the result will be null. If divisor is
+/// zero, an error will be raised.
+///
+/// \param[in] left the dividend
+/// \param[in] right the divisor
+/// \param[in] options arithmetic options (enable/disable overflow checking), optional
+/// \param[in] ctx the function execution context, optional
+/// \return the elementwise quotient and remainder
+ARROW_EXPORT
+Result<Datum> Divmod(const Datum& left, const Datum& right,
+                     ArithmeticOptions options = ArithmeticOptions(),
+                     ExecContext* ctx = NULLPTR);
+
 /// \brief Negate values.
 ///
 /// If argument is null the result will be null.
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index f416881ccb8..95fff62a430 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -425,6 +425,42 @@ struct DivideChecked {
   }
 };
 
+template <typename T>
+const std::shared_ptr<DataType>& DivmodType() {
+  // TODO(edponce): Need to find a way of mapping T to DataType.
+  static auto type = struct_({field("quotient", int64()), field("remainder", int64())});
+  return type;
+}
+
+struct Divmod {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_point<T, StructScalar> Call(KernelContext*, Arg0 left,
+                                                        Arg1 right, Status*) {
+    auto quotient = std::floor(left / right);
+    auto remainder = std::fmod(left, right);
+    ScalarVector values = {std::make_shared<T>(quotient), std::make_shared<T>(remainder)};
+    return StructScalar(std::move(values), DivmodType<T>());
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_c_integer<T, StructScalar> Call(KernelContext*, Arg0 left, Arg1 right,
+                                                   Status* st) {
+    T quotient;
+    T remainder = 0;
+    if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &quotient))) {
+      if (right == 0) {
+        *st = Status::Invalid("divide by zero");
+      } else {
+        quotient = 0;
+      }
+    } else {
+      remainder = left % right;
+    }
+    ScalarVector values = {std::make_shared<T>(quotient), std::make_shared<T>(remainder)};
+    return StructScalar(std::move(values), DivmodType<T>());
+  }
+};
+
 struct Negate {
   template <typename T, typename Arg>
   static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg arg, Status*) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 984c3b56538..d189518b8c0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -17,6 +17,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <functional>
 #include <limits>
 #include <memory>
 #include <utility>
@@ -79,9 +80,6 @@ bool IsPositive(const Scalar& scalar) {
   return visitor.result;
 }
 
-// N.B. take care not to conflict with type_traits.h as that can cause surprises in a
-// unity build
-
 // Bitwise operations
 
 struct BitWiseNot {
@@ -1373,6 +1371,17 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNull(std::string name,
   return func;
 }
 
+template <typename Op>
+std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNullStructOutType(
+    std::string name, const FunctionDoc* doc, std::shared_ptr<DataType> out_type) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
+  for (const auto& ty : NumericTypes()) {
+    auto exec = ArithmeticExecFromOp<ScalarBinaryNotNullEqualTypes, Op>(ty);
+    DCHECK_OK(func->AddKernel({ty, ty}, out_type, exec));
+  }
+  return func;
+}
+
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
                                                             FunctionDoc doc) {
@@ -1699,6 +1708,14 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"dividend", "divisor"}};
 
+const FunctionDoc divmod_doc{
+    "Calculate the quotient and remainder",
+    ("Integer division by zero returns an error. However, integer overflow\n"
+     "wraps around, and floating-point division by zero returns an infinite.\n"
+     "Use function \"divmod_checked\" if you want to get an error\n"
+     "in all the aforementioned cases."),
+    {"dividend", "divisor"}};
+
 const FunctionDoc negate_doc{"Negate the argument element-wise",
                              ("Results will wrap around on integer overflow.\n"
                               "Use function \"negate_checked\" if you want overflow\n"
@@ -2201,6 +2218,11 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
 
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
+  // ----------------------------------------------------------------------
+  auto divmod = MakeArithmeticFunctionNotNullStructOutType<Divmod>("divmod", divmod_doc,
+                                                                   DivmodType<int64_t>());
+  DCHECK_OK(registry->AddFunction(std::move(divmod)));
+
   // ----------------------------------------------------------------------
   auto negate = MakeUnaryArithmeticFunction<Negate>("negate", negate_doc);
   AddDecimalUnaryKernels<Negate>(negate.get());

From 68554d820ee3fa1b4f6f4f2d3ede6bef85acbb4f Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 21 Sep 2021 05:10:10 -0400
Subject: [PATCH 02/10] update placeholder kernels and add visitor support for
 StructScalar

---
 .../kernels/base_arithmetic_internal.h        | 60 +++++++++++--------
 .../arrow/compute/kernels/codegen_internal.h  | 49 ++++++++++++++-
 .../compute/kernels/scalar_arithmetic.cc      | 51 ++++++++++++++--
 3 files changed, 129 insertions(+), 31 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 95fff62a430..625e00e3030 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -425,39 +425,49 @@ struct DivideChecked {
   }
 };
 
-template <typename T>
-const std::shared_ptr<DataType>& DivmodType() {
-  // TODO(edponce): Need to find a way of mapping T to DataType.
-  static auto type = struct_({field("quotient", int64()), field("remainder", int64())});
-  return type;
+std::shared_ptr<DataType> DivmodType(const std::shared_ptr<DataType>& ty) {
+  std::vector<std::shared_ptr<arrow::Field>> fields{field("quotient", ty),
+                                                    field("remainder", ty)};
+  return struct_(fields);
 }
 
 struct Divmod {
+  // TODO(edponce): mod() should support integer types too.
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<T, StructScalar> Call(KernelContext*, Arg0 left,
-                                                        Arg1 right, Status*) {
+  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext*, Arg0 left,
+                                                           Arg1 right, Status*) {
     auto quotient = std::floor(left / right);
     auto remainder = std::fmod(left, right);
-    ScalarVector values = {std::make_shared<T>(quotient), std::make_shared<T>(remainder)};
-    return StructScalar(std::move(values), DivmodType<T>());
+    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+    // TODO(edponce): How to only call DivmodType once (before processing)?
+    // This is a static method so there is not state.
+    auto ty = CTypeTraits<Arg0>::type_singleton();
+    return StructScalar(std::move(values), DivmodType(ty));
   }
+};
 
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_c_integer<T, StructScalar> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                   Status* st) {
-    T quotient;
-    T remainder = 0;
-    if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &quotient))) {
-      if (right == 0) {
-        *st = Status::Invalid("divide by zero");
-      } else {
-        quotient = 0;
-      }
-    } else {
-      remainder = left % right;
-    }
-    ScalarVector values = {std::make_shared<T>(quotient), std::make_shared<T>(remainder)};
-    return StructScalar(std::move(values), DivmodType<T>());
+struct DivmodChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext*, Arg0 left,
+                                                           Arg1 right, Status* st) {
+    // Arg0 quotient;
+    // Arg0 remainder = 0;
+    // if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &quotient))) {
+    //   if (right == 0) {
+    //     *st = Status::Invalid("divide by zero");
+    //   } else {
+    //     quotient = 0;
+    //   }
+    // } else {
+    //   remainder = left % right;
+    // }
+    auto quotient = std::floor(left / right);
+    auto remainder = std::fmod(left, right);
+    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+    // TODO(edponce): How to only call DivmodType once (before processing)?
+    // This is a static method so there is not state.
+    auto ty = CTypeTraits<Arg0>::type_singleton();
+    return StructScalar(std::move(values), DivmodType(ty));
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index a6ede14176c..0a8cbb4bd3c 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -189,6 +189,11 @@ struct GetOutputType<Decimal256Type> {
   using T = Decimal256;
 };
 
+template <>
+struct GetOutputType<StructType> {
+  using T = StructScalar;
+};
+
 // ----------------------------------------------------------------------
 // enable_if helpers for C types
 
@@ -322,6 +327,24 @@ struct OutputArrayWriter<Type, enable_if_c_number_or_decimal<Type>> {
   }
 };
 
+template <typename Type>
+struct OutputArrayWriter<Type, enable_if_struct<Type>> {
+  using T = typename TypeTraits<Type>::ScalarType;
+  T* values;
+
+  explicit OutputArrayWriter(ArrayData* data) : values(data->GetMutableValues<T>(1)) {}
+
+  void Write(T value) { *values++ = value; }
+
+  // Note that this doesn't write the null bitmap, which should be consistent
+  // with Write / WriteNull calls
+  void WriteNull() { *values++ = T(null()); }
+
+  void WriteAllNull(int64_t length) {
+    std::memset(static_cast<void*>(values), 0, sizeof(T) * length);
+  }
+};
+
 // (Un)box Scalar to / from C++ value
 
 template <typename Type, typename Enable = void>
@@ -400,7 +423,16 @@ struct BoxScalar<Decimal256Type> {
   static void Box(T val, Scalar* out) { checked_cast<ScalarType*>(out)->value = val; }
 };
 
-// A VisitArraySpanInline variant that calls its visitor function with logical
+template <>
+struct BoxScalar<StructType> {
+  using T = StructScalar;
+  using ScalarType = T;
+  static void Box(T val, Scalar* out) {
+    checked_cast<ScalarType*>(out)->value = std::move(val.value);
+  }
+};
+
+// A VisitArrayDataInline variant that calls its visitor function with logical
 // values, such as Decimal128 rather than util::string_view.
 
 template <typename T, typename VisitFunc, typename NullFunc>
@@ -555,6 +587,21 @@ struct OutputAdapter<Type, enable_if_base_binary<Type>> {
   }
 };
 
+template <typename Type>
+struct OutputAdapter<Type, enable_if_struct<Type>> {
+  using T = typename TypeTraits<Type>::ScalarType;
+
+  template <typename Generator>
+  static Status Write(KernelContext*, Datum* out, Generator&& generator) {
+    ArrayData* out_arr = out->mutable_array();
+    auto out_data = out_arr->GetMutableValues<T>(1);
+    for (int64_t i = 0; i < out_arr->length; ++i) {
+      *out_data++ = generator();
+    }
+    return Status::OK();
+  }
+};
+
 // A kernel exec generator for unary functions that addresses both array and
 // scalar inputs and dispatches input iteration and output writing to other
 // templates
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index d189518b8c0..c23cc5b0af6 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1061,6 +1061,19 @@ ArrayKernelExec GenerateArithmeticFloatingPoint(detail::GetTypeId get_id) {
   }
 }
 
+template <template <typename... Args> class KernelGenerator, typename Op>
+ArrayKernelExec GenerateStructFloatingPoint(detail::GetTypeId get_id) {
+  switch (get_id.id) {
+    case Type::FLOAT:
+      return KernelGenerator<StructType, FloatType, Op>::Exec;
+    case Type::DOUBLE:
+      return KernelGenerator<StructType, DoubleType, Op>::Exec;
+    default:
+      DCHECK(false);
+      return ExecFail;
+  }
+}
+
 // resolve decimal binary operation output type per *casted* args
 template <typename OutputGetter>
 Result<TypeHolder> ResolveDecimalBinaryOperationOutput(
@@ -1371,13 +1384,30 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNull(std::string name,
   return func;
 }
 
+template <typename Op>
+std::shared_ptr<ScalarFunction> MakeArithmeticFunctionStructOutType(
+    std::string name, const FunctionDoc* doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
+  for (const auto& ty : FloatingPointTypes()) {
+    // TODO(edponce): Allow DivmodType as function parameter so that this can
+    // be used by other kernels?
+    auto out_ty = DivmodType(ty);
+    auto exec = GenerateStructFloatingPoint<ScalarBinaryEqualTypes, Op>(ty);
+    DCHECK_OK(func->AddKernel({ty, ty}, out_ty, exec));
+  }
+  return func;
+}
+
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNullStructOutType(
-    std::string name, const FunctionDoc* doc, std::shared_ptr<DataType> out_type) {
+    std::string name, const FunctionDoc* doc) {
   auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
-  for (const auto& ty : NumericTypes()) {
-    auto exec = ArithmeticExecFromOp<ScalarBinaryNotNullEqualTypes, Op>(ty);
-    DCHECK_OK(func->AddKernel({ty, ty}, out_type, exec));
+  for (const auto& ty : FloatingPointTypes()) {
+    // TODO(edponce): Allow DivmodType as function parameter so that this can
+    // be used by other kernels?
+    auto out_ty = DivmodType(ty);
+    auto exec = GenerateStructFloatingPoint<ScalarBinaryNotNullEqualTypes, Op>(ty);
+    DCHECK_OK(func->AddKernel({ty, ty}, out_ty, exec));
   }
   return func;
 }
@@ -1711,11 +1741,17 @@ const FunctionDoc div_checked_doc{
 const FunctionDoc divmod_doc{
     "Calculate the quotient and remainder",
     ("Integer division by zero returns an error. However, integer overflow\n"
-     "wraps around, and floating-point division by zero returns an infinite.\n"
+     "wraps around, and floating-point division by zero returns infinity.\n"
      "Use function \"divmod_checked\" if you want to get an error\n"
      "in all the aforementioned cases."),
     {"dividend", "divisor"}};
 
+const FunctionDoc divmod_checked_doc{
+    "Calculate the quotient and remainder",
+    ("Integer division by zero returns an error, or when integer overflow is\n"
+     "encountered. Floating-point division by zero returns infinity."),
+    {"dividend", "divisor"}};
+
 const FunctionDoc negate_doc{"Negate the argument element-wise",
                              ("Results will wrap around on integer overflow.\n"
                               "Use function \"negate_checked\" if you want overflow\n"
@@ -2223,6 +2259,11 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
                                                                    DivmodType<int64_t>());
   DCHECK_OK(registry->AddFunction(std::move(divmod)));
 
+  // ----------------------------------------------------------------------
+  auto divmod_checked = MakeArithmeticFunctionNotNullStructOutType<DivmodChecked>(
+      "divmod_checked", divmod_checked_doc);
+  DCHECK_OK(registry->AddFunction(std::move(divmod_checked)));
+
   // ----------------------------------------------------------------------
   auto negate = MakeUnaryArithmeticFunction<Negate>("negate", negate_doc);
   AddDecimalUnaryKernels<Negate>(negate.get());

From 1215cb0573834b72f8bf0dc49a5afef7a2f8d65e Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 21 Sep 2021 17:38:37 -0400
Subject: [PATCH 03/10] update divmod kernels and add integer support

---
 .../kernels/base_arithmetic_internal.h        | 54 +++++++++++--------
 .../compute/kernels/scalar_arithmetic.cc      | 42 +++++----------
 2 files changed, 44 insertions(+), 52 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 625e00e3030..e8289cc7224 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -425,49 +425,57 @@ struct DivideChecked {
   }
 };
 
-std::shared_ptr<DataType> DivmodType(const std::shared_ptr<DataType>& ty) {
+std::shared_ptr<DataType> MakeDivmodType(const std::shared_ptr<DataType>& ty) {
   std::vector<std::shared_ptr<arrow::Field>> fields{field("quotient", ty),
                                                     field("remainder", ty)};
   return struct_(fields);
 }
 
 struct Divmod {
-  // TODO(edponce): mod() should support integer types too.
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext*, Arg0 left,
-                                                           Arg1 right, Status*) {
-    auto quotient = std::floor(left / right);
+  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
+                                                           Arg1 right, Status* st) {
+    auto div = Divide::Call<Arg0>(ctx, left, right, st);
+    auto quotient = std::floor(div);
     auto remainder = std::fmod(left, right);
     ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    // TODO(edponce): How to only call DivmodType once (before processing)?
+    // TODO(edponce): How to only call MakeDivmodType once (before processing)?
     // This is a static method so there is not state.
     auto ty = CTypeTraits<Arg0>::type_singleton();
-    return StructScalar(std::move(values), DivmodType(ty));
+    return StructScalar(std::move(values), MakeDivmodType(ty));
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
+                                                      Arg1 right, Status* st) {
+    auto quotient = Divide::Call<Arg0>(ctx, left, right, st);
+    auto remainder = left % right;
+    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+    auto ty = CTypeTraits<Arg0>::type_singleton();
+    return StructScalar(std::move(values), MakeDivmodType(ty));
   }
 };
 
 struct DivmodChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext*, Arg0 left,
+  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                            Arg1 right, Status* st) {
-    // Arg0 quotient;
-    // Arg0 remainder = 0;
-    // if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &quotient))) {
-    //   if (right == 0) {
-    //     *st = Status::Invalid("divide by zero");
-    //   } else {
-    //     quotient = 0;
-    //   }
-    // } else {
-    //   remainder = left % right;
-    // }
-    auto quotient = std::floor(left / right);
+    auto div = DivideChecked::Call<Arg0>(ctx, left, right, st);
+    auto quotient = std::floor(div);
     auto remainder = std::fmod(left, right);
     ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    // TODO(edponce): How to only call DivmodType once (before processing)?
-    // This is a static method so there is not state.
     auto ty = CTypeTraits<Arg0>::type_singleton();
-    return StructScalar(std::move(values), DivmodType(ty));
+    return StructScalar(std::move(values), MakeDivmodType(ty));
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
+                                                      Arg1 right, Status* st) {
+    auto quotient = DivideChecked::Call<Arg0>(ctx, left, right, st);
+    auto remainder = left % right;
+    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+    auto ty = CTypeTraits<Arg0>::type_singleton();
+    return StructScalar(std::move(values), MakeDivmodType(ty));
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index c23cc5b0af6..59338d6b125 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -17,7 +17,6 @@
 
 #include <algorithm>
 #include <cmath>
-#include <functional>
 #include <limits>
 #include <memory>
 #include <utility>
@@ -1061,19 +1060,6 @@ ArrayKernelExec GenerateArithmeticFloatingPoint(detail::GetTypeId get_id) {
   }
 }
 
-template <template <typename... Args> class KernelGenerator, typename Op>
-ArrayKernelExec GenerateStructFloatingPoint(detail::GetTypeId get_id) {
-  switch (get_id.id) {
-    case Type::FLOAT:
-      return KernelGenerator<StructType, FloatType, Op>::Exec;
-    case Type::DOUBLE:
-      return KernelGenerator<StructType, DoubleType, Op>::Exec;
-    default:
-      DCHECK(false);
-      return ExecFail;
-  }
-}
-
 // resolve decimal binary operation output type per *casted* args
 template <typename OutputGetter>
 Result<TypeHolder> ResolveDecimalBinaryOperationOutput(
@@ -1386,13 +1372,12 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNull(std::string name,
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeArithmeticFunctionStructOutType(
-    std::string name, const FunctionDoc* doc) {
+    std::string name, const FunctionDoc* doc,
+    std::function<std::shared_ptr<DataType>(std::shared_ptr<DataType>)> MakeStructType) {
   auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
-  for (const auto& ty : FloatingPointTypes()) {
-    // TODO(edponce): Allow DivmodType as function parameter so that this can
-    // be used by other kernels?
-    auto out_ty = DivmodType(ty);
-    auto exec = GenerateStructFloatingPoint<ScalarBinaryEqualTypes, Op>(ty);
+  for (const auto& ty : NumericTypes()) {
+    auto out_ty = MakeStructType(ty);
+    auto exec = GenerateNumeric<ScalarBinaryEqualTypes, StructType, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, out_ty, exec));
   }
   return func;
@@ -1400,13 +1385,12 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionStructOutType(
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNullStructOutType(
-    std::string name, const FunctionDoc* doc) {
+    std::string name, const FunctionDoc* doc,
+    std::function<std::shared_ptr<DataType>(std::shared_ptr<DataType>)> MakeStructType) {
   auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
-  for (const auto& ty : FloatingPointTypes()) {
-    // TODO(edponce): Allow DivmodType as function parameter so that this can
-    // be used by other kernels?
-    auto out_ty = DivmodType(ty);
-    auto exec = GenerateStructFloatingPoint<ScalarBinaryNotNullEqualTypes, Op>(ty);
+  for (const auto& ty : NumericTypes()) {
+    auto out_ty = MakeStructType(ty);
+    auto exec = GenerateNumeric<ScalarBinaryNotNullEqualTypes, StructType, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, out_ty, exec));
   }
   return func;
@@ -2255,13 +2239,13 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto divmod = MakeArithmeticFunctionNotNullStructOutType<Divmod>("divmod", divmod_doc,
-                                                                   DivmodType<int64_t>());
+  auto divmod =
+      MakeArithmeticFunctionStructOutType<Divmod>("divmod", divmod_doc, MakeDivmodType);
   DCHECK_OK(registry->AddFunction(std::move(divmod)));
 
   // ----------------------------------------------------------------------
   auto divmod_checked = MakeArithmeticFunctionNotNullStructOutType<DivmodChecked>(
-      "divmod_checked", divmod_checked_doc);
+      "divmod_checked", divmod_checked_doc, MakeDivmodType);
   DCHECK_OK(registry->AddFunction(std::move(divmod_checked)));
 
   // ----------------------------------------------------------------------

From 742eef991017a79271c5224f0476037abfb6c49b Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 22 Sep 2021 00:28:08 -0400
Subject: [PATCH 04/10] use fast mod, restructure kernels

---
 .../kernels/base_arithmetic_internal.h        | 48 ++++++++++---------
 .../compute/kernels/scalar_arithmetic.cc      |  2 +
 2 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index e8289cc7224..8da156b2424 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -425,34 +425,43 @@ struct DivideChecked {
   }
 };
 
+template <typename T>
+static inline constexpr enable_if_c_numeric<T> FastMod(T dividend, T divisor,
+                                                       T quotient) {
+  return dividend - quotient * divisor;
+}
+
 std::shared_ptr<DataType> MakeDivmodType(const std::shared_ptr<DataType>& ty) {
   std::vector<std::shared_ptr<arrow::Field>> fields{field("quotient", ty),
                                                     field("remainder", ty)};
   return struct_(fields);
 }
 
+template <typename T, typename Arg>
+static inline enable_if_c_numeric<Arg, StructScalar> MakeDivmodStruct(Arg quotient,
+                                                                      Arg remainder) {
+  ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+  // TODO(edponce): How to only call MakeDivmodType once (before processing)?
+  // `Call()` is a static method and invoked directly so there is no state.
+  auto ty = CTypeTraits<Arg>::type_singleton();
+  return StructScalar(std::move(values), MakeDivmodType(ty));
+}
+
 struct Divmod {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                            Arg1 right, Status* st) {
-    auto div = Divide::Call<Arg0>(ctx, left, right, st);
-    auto quotient = std::floor(div);
-    auto remainder = std::fmod(left, right);
-    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    // TODO(edponce): How to only call MakeDivmodType once (before processing)?
-    // This is a static method so there is not state.
-    auto ty = CTypeTraits<Arg0>::type_singleton();
-    return StructScalar(std::move(values), MakeDivmodType(ty));
+    auto quotient = std::floor(Divide::Call<Arg0>(ctx, left, right, st));
+    auto remainder = FastMod<Arg0>(left, right, quotient);
+    return MakeDivmodStruct<T>(quotient, remainder);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                       Arg1 right, Status* st) {
     auto quotient = Divide::Call<Arg0>(ctx, left, right, st);
-    auto remainder = left % right;
-    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    auto ty = CTypeTraits<Arg0>::type_singleton();
-    return StructScalar(std::move(values), MakeDivmodType(ty));
+    auto remainder = FastMod<Arg0>(left, right, quotient);
+    return MakeDivmodStruct<T>(quotient, remainder);
   }
 };
 
@@ -460,22 +469,17 @@ struct DivmodChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                            Arg1 right, Status* st) {
-    auto div = DivideChecked::Call<Arg0>(ctx, left, right, st);
-    auto quotient = std::floor(div);
-    auto remainder = std::fmod(left, right);
-    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    auto ty = CTypeTraits<Arg0>::type_singleton();
-    return StructScalar(std::move(values), MakeDivmodType(ty));
+    auto quotient = std::floor(DivideChecked::Call<Arg0>(ctx, left, right, st));
+    auto remainder = FastMod<Arg0>(left, right, quotient);
+    return MakeDivmodStruct<T>(quotient, remainder);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                       Arg1 right, Status* st) {
     auto quotient = DivideChecked::Call<Arg0>(ctx, left, right, st);
-    auto remainder = left % right;
-    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    auto ty = CTypeTraits<Arg0>::type_singleton();
-    return StructScalar(std::move(values), MakeDivmodType(ty));
+    auto remainder = FastMod<Arg0>(left, right, quotient);
+    return MakeDivmodStruct<T>(quotient, remainder);
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 59338d6b125..fc2285b8828 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -65,11 +65,13 @@ struct IsPositiveVisitor {
     result = scalar.value > 0;
     return Status::OK();
   }
+
   template <typename... Ts>
   Status Visit(const DecimalScalar<Ts...>& scalar) {
     result = scalar.value > 0;
     return Status::OK();
   }
+
   Status Visit(const Scalar& scalar) { return Status::OK(); }
 };
 

From d2cbdc307c2b8598c81050ca2f866b9ad55fd1c7 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 22 Sep 2021 04:06:01 -0400
Subject: [PATCH 05/10] add DivmodUtil

---
 .../kernels/base_arithmetic_internal.h        | 66 +++++++++----------
 .../arrow/compute/kernels/codegen_internal.h  |  2 +-
 .../compute/kernels/scalar_arithmetic.cc      |  6 +-
 3 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 8da156b2424..5c22e490ba7 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -425,61 +425,61 @@ struct DivideChecked {
   }
 };
 
-template <typename T>
-static inline constexpr enable_if_c_numeric<T> FastMod(T dividend, T divisor,
-                                                       T quotient) {
-  return dividend - quotient * divisor;
-}
-
-std::shared_ptr<DataType> MakeDivmodType(const std::shared_ptr<DataType>& ty) {
-  std::vector<std::shared_ptr<arrow::Field>> fields{field("quotient", ty),
-                                                    field("remainder", ty)};
-  return struct_(fields);
-}
-
-template <typename T, typename Arg>
-static inline enable_if_c_numeric<Arg, StructScalar> MakeDivmodStruct(Arg quotient,
-                                                                      Arg remainder) {
-  ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-  // TODO(edponce): How to only call MakeDivmodType once (before processing)?
-  // `Call()` is a static method and invoked directly so there is no state.
-  auto ty = CTypeTraits<Arg>::type_singleton();
-  return StructScalar(std::move(values), MakeDivmodType(ty));
-}
+struct DivmodUtil {
+  template <typename T>
+  static constexpr enable_if_c_number<T> FastMod(T dividend, T divisor, T quotient) {
+    return dividend - quotient * divisor;
+  }
+
+  /// Create a StructType instance for Divmod kernels.
+  static std::shared_ptr<DataType> MakeDivmodOutType(
+      const std::shared_ptr<DataType>& ty) {
+    return struct_({field("quotient", ty), field("remainder", ty)});
+  }
+
+  template <typename T>
+  static enable_if_c_number<T, StructScalar> MakeDivmodStruct(T quotient, T remainder) {
+    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+    // TODO(edponce): How to only call MakeDivmodOutType once (before processing)?
+    // `Call()` is a static method and invoked directly so there is no state.
+    auto ty = CTypeTraits<T>::type_singleton();
+    return StructScalar(std::move(values), MakeDivmodOutType(ty));
+  }
+};
 
 struct Divmod {
-  template <typename T, typename Arg0, typename Arg1>
+  template <typename OutType, typename Arg0, typename Arg1>
   static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                            Arg1 right, Status* st) {
     auto quotient = std::floor(Divide::Call<Arg0>(ctx, left, right, st));
-    auto remainder = FastMod<Arg0>(left, right, quotient);
-    return MakeDivmodStruct<T>(quotient, remainder);
+    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
+    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
+  template <typename OutType, typename Arg0, typename Arg1>
   static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                       Arg1 right, Status* st) {
     auto quotient = Divide::Call<Arg0>(ctx, left, right, st);
-    auto remainder = FastMod<Arg0>(left, right, quotient);
-    return MakeDivmodStruct<T>(quotient, remainder);
+    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
+    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
   }
 };
 
 struct DivmodChecked {
-  template <typename T, typename Arg0, typename Arg1>
+  template <typename OutType, typename Arg0, typename Arg1>
   static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                            Arg1 right, Status* st) {
     auto quotient = std::floor(DivideChecked::Call<Arg0>(ctx, left, right, st));
-    auto remainder = FastMod<Arg0>(left, right, quotient);
-    return MakeDivmodStruct<T>(quotient, remainder);
+    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
+    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
+  template <typename OutType, typename Arg0, typename Arg1>
   static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
                                                       Arg1 right, Status* st) {
     auto quotient = DivideChecked::Call<Arg0>(ctx, left, right, st);
-    auto remainder = FastMod<Arg0>(left, right, quotient);
-    return MakeDivmodStruct<T>(quotient, remainder);
+    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
+    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 0a8cbb4bd3c..d99c54f8795 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -426,7 +426,7 @@ struct BoxScalar<Decimal256Type> {
 template <>
 struct BoxScalar<StructType> {
   using T = StructScalar;
-  using ScalarType = T;
+  using ScalarType = StructScalar;
   static void Box(T val, Scalar* out) {
     checked_cast<ScalarType*>(out)->value = std::move(val.value);
   }
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index fc2285b8828..84fef9e9b20 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -2241,13 +2241,13 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto divmod =
-      MakeArithmeticFunctionStructOutType<Divmod>("divmod", divmod_doc, MakeDivmodType);
+  auto divmod = MakeArithmeticFunctionStructOutType<Divmod>(
+      "divmod", divmod_doc, DivmodUtil::MakeDivmodOutType);
   DCHECK_OK(registry->AddFunction(std::move(divmod)));
 
   // ----------------------------------------------------------------------
   auto divmod_checked = MakeArithmeticFunctionNotNullStructOutType<DivmodChecked>(
-      "divmod_checked", divmod_checked_doc, MakeDivmodType);
+      "divmod_checked", divmod_checked_doc, DivmodUtil::MakeDivmodOutType);
   DCHECK_OK(registry->AddFunction(std::move(divmod_checked)));
 
   // ----------------------------------------------------------------------

From 7b3ad78e0c7723f51a89985904b715841e2c1e77 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 18 Jul 2022 22:57:37 -0400
Subject: [PATCH 06/10] refactor divmod, minor comments and var changes

---
 cpp/src/arrow/compute/api_scalar.h            | 13 +--
 .../kernels/base_arithmetic_internal.h        | 60 +------------
 .../arrow/compute/kernels/codegen_internal.h  |  3 +
 .../compute/kernels/scalar_arithmetic.cc      | 87 +++++++++++++++++--
 4 files changed, 93 insertions(+), 70 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index cbb187df1ce..2d1b89ad048 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -583,17 +583,18 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
                      ArithmeticOptions options = ArithmeticOptions(),
                      ExecContext* ctx = NULLPTR);
 
-/// \brief Calculate the quotient and remainder between two values. Array values must be
-/// the same length. If either argument is null the result will be null. If divisor is
-/// zero, an error will be raised.
+/// \brief Calculate the quotient and remainder between two values.
 ///
-/// \param[in] left the dividend
-/// \param[in] right the divisor
+/// Array values must be the same length. If either argument is null,
+/// then the result will be null. If divisor is zero, an error will be raised.
+///
+/// \param[in] dividend the dividend
+/// \param[in] divisor the divisor
 /// \param[in] options arithmetic options (enable/disable overflow checking), optional
 /// \param[in] ctx the function execution context, optional
 /// \return the elementwise quotient and remainder
 ARROW_EXPORT
-Result<Datum> Divmod(const Datum& left, const Datum& right,
+Result<Datum> Divmod(const Datum& dividend, const Datum& divisor,
                      ArithmeticOptions options = ArithmeticOptions(),
                      ExecContext* ctx = NULLPTR);
 
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 5c22e490ba7..d1900150dd2 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -383,7 +383,7 @@ struct Divide {
   static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
                                          Status* st) {
     if (right == Arg1()) {
-      *st = Status::Invalid("Divide by zero");
+      *st = Status::Invalid("divide by zero");
       return T();
     } else {
       return left / right;
@@ -425,64 +425,6 @@ struct DivideChecked {
   }
 };
 
-struct DivmodUtil {
-  template <typename T>
-  static constexpr enable_if_c_number<T> FastMod(T dividend, T divisor, T quotient) {
-    return dividend - quotient * divisor;
-  }
-
-  /// Create a StructType instance for Divmod kernels.
-  static std::shared_ptr<DataType> MakeDivmodOutType(
-      const std::shared_ptr<DataType>& ty) {
-    return struct_({field("quotient", ty), field("remainder", ty)});
-  }
-
-  template <typename T>
-  static enable_if_c_number<T, StructScalar> MakeDivmodStruct(T quotient, T remainder) {
-    ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-    // TODO(edponce): How to only call MakeDivmodOutType once (before processing)?
-    // `Call()` is a static method and invoked directly so there is no state.
-    auto ty = CTypeTraits<T>::type_singleton();
-    return StructScalar(std::move(values), MakeDivmodOutType(ty));
-  }
-};
-
-struct Divmod {
-  template <typename OutType, typename Arg0, typename Arg1>
-  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
-                                                           Arg1 right, Status* st) {
-    auto quotient = std::floor(Divide::Call<Arg0>(ctx, left, right, st));
-    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
-    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
-  }
-
-  template <typename OutType, typename Arg0, typename Arg1>
-  static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
-                                                      Arg1 right, Status* st) {
-    auto quotient = Divide::Call<Arg0>(ctx, left, right, st);
-    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
-    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
-  }
-};
-
-struct DivmodChecked {
-  template <typename OutType, typename Arg0, typename Arg1>
-  static enable_if_floating_point<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
-                                                           Arg1 right, Status* st) {
-    auto quotient = std::floor(DivideChecked::Call<Arg0>(ctx, left, right, st));
-    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
-    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
-  }
-
-  template <typename OutType, typename Arg0, typename Arg1>
-  static enable_if_c_integer<Arg0, StructScalar> Call(KernelContext* ctx, Arg0 left,
-                                                      Arg1 right, Status* st) {
-    auto quotient = DivideChecked::Call<Arg0>(ctx, left, right, st);
-    auto remainder = DivmodUtil::FastMod<Arg0>(left, right, quotient);
-    return DivmodUtil::MakeDivmodStruct(quotient, remainder);
-  }
-};
-
 struct Negate {
   template <typename T, typename Arg>
   static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg arg, Status*) {
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index d99c54f8795..3c860557cae 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -226,6 +226,9 @@ using enable_if_decimal_value =
     enable_if_t<std::is_same<Decimal128, T>::value || std::is_same<Decimal256, T>::value,
                 R>;
 
+template <typename T, typename R = T>
+using enable_if_c_number = enable_if_t<has_c_type<T>::value && !is_boolean_type<T>::value, R>;
+
 // ----------------------------------------------------------------------
 // Iteration / value access utilities
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 84fef9e9b20..40ccff90e89 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -646,7 +646,7 @@ struct RoundOptionsWrapper<RoundOptions> : public OptionsWrapper<RoundOptions> {
   explicit RoundOptionsWrapper(OptionsType options) : OptionsWrapper(std::move(options)) {
     // Only positive exponents for powers of 10 are used because combining
     // multiply and division operations produced more stable rounding than
-    // using multiply-only.  Refer to NumPy's round implementation:
+    // using multiply-only. Refer to NumPy's round implementation:
     // https://github.com/numpy/numpy/blob/7b2f20b406d27364c812f7a81a9c901afbd3600c/numpy/core/src/multiarray/calculation.c#L589
     pow10 = RoundUtil::Pow10(std::abs(options.ndigits));
   }
@@ -706,7 +706,7 @@ struct RoundOptionsWrapper<RoundToMultipleOptions>
   }
 };
 
-template <typename ArrowType, RoundMode RndMode, typename Enable = void>
+template <typename ArrowType, RoundMode kRoundMode, typename Enable = void>
 struct Round {
   using CType = typename TypeTraits<ArrowType>::CType;
   using State = RoundOptionsWrapper<RoundOptions>;
@@ -728,13 +728,13 @@ struct Round {
     auto frac = round_val - std::floor(round_val);
     if (frac != T(0)) {
       // Use std::round() if in tie-breaking mode and scaled value is not 0.5.
-      if ((RndMode >= RoundMode::HALF_DOWN) && (frac != T(0.5))) {
+      if ((kRoundMode >= RoundMode::HALF_DOWN) && (frac != T(0.5))) {
         round_val = std::round(round_val);
       } else {
-        round_val = RoundImpl<CType, RndMode>::Round(round_val);
+        round_val = RoundImpl<CType, kRoundMode>::Round(round_val);
       }
       // Equality check is ommitted so that the common case of 10^0 (integer rounding)
-      // uses multiply-only
+      // uses multiply-only.
       round_val = ndigits > 0 ? (round_val / pow10) : (round_val * pow10);
       if (!std::isfinite(round_val)) {
         *st = Status::Invalid("overflow occurred during rounding");
@@ -1001,6 +1001,83 @@ struct Trunc {
   }
 };
 
+// struct DivmodUtil {
+//   /// Create a StructType instance for Divmod kernels.
+//   static std::shared_ptr<DataType> MakeDivmodOutType(
+//       const std::shared_ptr<DataType>& ty) {
+//     return struct_({field("quotient", ty), field("remainder", ty)});
+//   }
+
+//   template <typename T>
+//   static enable_if_c_number<T, StructScalar> MakeDivmodStruct(T quotient, T remainder) {
+//     ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
+//     // TODO(edponce): How to only call MakeDivmodOutType once (before processing)?
+//     // `Call()` is a static method and invoked directly so there is no state.
+//     auto ty = CTypeTraits<T>::type_singleton();
+//     return StructScalar(std::move(values), MakeDivmodOutType(ty));
+//   }
+// };
+
+struct Divmod {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    auto quotient = std::floor(dividend / divisor);
+    auto remainder = dividend - quotient * divisor;
+    return {quotient, remainder};
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    auto quotient = dividend / divisor;
+    auto remainder = dividend - quotient * divisor;
+    return {quotient, remainder};
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    std::pair<Arg0, Arg0> pair;
+    *st = dividend.Divide(divisor).Value(&pair);
+    const auto& quotient = pair.first;
+    const auto& remainder = pair.second;
+    return {quotient, remainder};
+  }
+};
+
+struct DivmodChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    auto quotient = std::floor(DivideChecked::Call<Arg0>(ctx, dividend, divisor, st));
+    if (!st->ok) {
+        return {0, 0};
+    }
+    auto remainder = dividend - quotient * divisor;
+    return {quotient, remainder};
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    auto quotient = DivideChecked::Call<Arg0>(ctx, dividend, divisor, st);
+    if (!st->ok) {
+        return {0, 0};
+    }
+    auto remainder = dividend - quotient * divisor;
+    return {quotient, remainder};
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    std::pair<Arg0, Arg0> pair;
+    *st = dividend.Divide(divisor).Value(&pair);
+    if (!st->ok()) {
+      *st = Status::Invalid("division error");
+      return {T(), T()};
+    }
+    const auto& quotient = pair.first;
+    const auto& remainder = pair.second;
+    return {quotient, remainder};
+  }
+};
+
 // Generate a kernel given a bitwise arithmetic functor. Assumes the
 // functor treats all integer types of equal width identically
 template <template <typename... Args> class KernelGenerator, typename Op>

From b2270a02e599d0c5dea1e1a15110ce21baa66032 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Jul 2022 00:27:52 -0400
Subject: [PATCH 07/10] use FixedSizeListScalar

---
 cpp/src/arrow/array/builder_nested.h          |  10 +-
 .../compute/kernels/scalar_arithmetic.cc      | 124 ++++++++++--------
 2 files changed, 73 insertions(+), 61 deletions(-)

diff --git a/cpp/src/arrow/array/builder_nested.h b/cpp/src/arrow/array/builder_nested.h
index 306d861b09f..d4725dc851f 100644
--- a/cpp/src/arrow/array/builder_nested.h
+++ b/cpp/src/arrow/array/builder_nested.h
@@ -371,14 +371,14 @@ class ARROW_EXPORT MapBuilder : public ArrayBuilder {
 /// \brief Builder class for fixed-length list array value types
 class ARROW_EXPORT FixedSizeListBuilder : public ArrayBuilder {
  public:
-  /// Use this constructor to define the built array's type explicitly. If value_builder
-  /// has indeterminate type, this builder will also.
+  /// Use this constructor to infer the built array's type. If value_builder has
+  /// indeterminate type, this builder will also infer it.
   FixedSizeListBuilder(MemoryPool* pool,
                        std::shared_ptr<ArrayBuilder> const& value_builder,
                        int32_t list_size);
 
-  /// Use this constructor to infer the built array's type. If value_builder has
-  /// indeterminate type, this builder will also.
+  /// Use this constructor to define the built array's type explicitly. If value_builder
+  /// has indeterminate type, this builder will also infer it.
   FixedSizeListBuilder(MemoryPool* pool,
                        std::shared_ptr<ArrayBuilder> const& value_builder,
                        const std::shared_ptr<DataType>& type);
@@ -401,7 +401,7 @@ class ARROW_EXPORT FixedSizeListBuilder : public ArrayBuilder {
 
   /// \brief Vector append
   ///
-  /// If passed, valid_bytes wil be read and any zero byte
+  /// If passed, valid_bytes will be read and any zero byte
   /// will cause the corresponding slot to be null
   ///
   /// This function affects only the validity bitmap; the child values must be appended
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 40ccff90e89..253367efad5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1001,81 +1001,93 @@ struct Trunc {
   }
 };
 
-// struct DivmodUtil {
-//   /// Create a StructType instance for Divmod kernels.
-//   static std::shared_ptr<DataType> MakeDivmodOutType(
-//       const std::shared_ptr<DataType>& ty) {
-//     return struct_({field("quotient", ty), field("remainder", ty)});
-//   }
-
-//   template <typename T>
-//   static enable_if_c_number<T, StructScalar> MakeDivmodStruct(T quotient, T remainder) {
-//     ScalarVector values = {MakeScalar(quotient), MakeScalar(remainder)};
-//     // TODO(edponce): How to only call MakeDivmodOutType once (before processing)?
-//     // `Call()` is a static method and invoked directly so there is no state.
-//     auto ty = CTypeTraits<T>::type_singleton();
-//     return StructScalar(std::move(values), MakeDivmodOutType(ty));
-//   }
-// };
-
+// TODO(edponce): Move builders to function state and reset.
 struct Divmod {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
-    auto quotient = std::floor(dividend / divisor);
-    auto remainder = dividend - quotient * divisor;
-    return {quotient, remainder};
-  }
+  static enable_if_floating_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    T quotient = std::floor(dividend / divisor);
+    T remainder = dividend - quotient * divisor;
 
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
-    auto quotient = dividend / divisor;
-    auto remainder = dividend - quotient * divisor;
-    return {quotient, remainder};
+    NumericBuilder<T> builder;
+    builder.Append(quotient);
+    builder.Append(remainder);
+    std::shared_ptr<Array> array;
+    builder.Finish(&array);
+    FixedSizeListScalar list(array, builder.type())
+    return list;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
-    std::pair<Arg0, Arg0> pair;
-    *st = dividend.Divide(divisor).Value(&pair);
-    const auto& quotient = pair.first;
-    const auto& remainder = pair.second;
-    return {quotient, remainder};
-  }
+  static enable_if_integer_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    T quotient = dividend / divisor;
+    T remainder = dividend - quotient * divisor;
+
+    NumericBuilder<T> builder;
+    builder.Append(quotient);
+    builder.Append(remainder);
+    std::shared_ptr<Array> array;
+    builder.Finish(&array);
+    FixedSizeListScalar list(array, builder.type())
+    return list;
+  }
+
+  // template <typename T, typename Arg0, typename Arg1>
+  // static enable_if_decimal_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+  //   std::pair<T, T> pair;
+  //   *st = dividend.Divide(divisor).Value(&pair);
+  //   const auto& quotient = pair.first;
+  //   const auto& remainder = pair.second;
+  //   return {quotient, remainder};
+  // }
 };
 
 struct DivmodChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
-    auto quotient = std::floor(DivideChecked::Call<Arg0>(ctx, dividend, divisor, st));
+  static enable_if_floating_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    T quotient = std::floor(DivideChecked::Call<T, Arg0, Arg1>(ctx, dividend, divisor, st));
     if (!st->ok) {
         return {0, 0};
     }
-    auto remainder = dividend - quotient * divisor;
-    return {quotient, remainder};
+    T remainder = dividend - quotient * divisor;
+
+    NumericBuilder<T> builder;
+    builder.Append(quotient);
+    builder.Append(remainder);
+    std::shared_ptr<Array> array;
+    builder.Finish(&array);
+    FixedSizeListScalar list(array, builder.type())
+    return list;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
-    auto quotient = DivideChecked::Call<Arg0>(ctx, dividend, divisor, st);
+  static enable_if_integer_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    T quotient = DivideChecked::Call<T, Arg0, Arg1>(ctx, dividend, divisor, st);
     if (!st->ok) {
         return {0, 0};
     }
-    auto remainder = dividend - quotient * divisor;
-    return {quotient, remainder};
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
-    std::pair<Arg0, Arg0> pair;
-    *st = dividend.Divide(divisor).Value(&pair);
-    if (!st->ok()) {
-      *st = Status::Invalid("division error");
-      return {T(), T()};
-    }
-    const auto& quotient = pair.first;
-    const auto& remainder = pair.second;
-    return {quotient, remainder};
-  }
+    T remainder = dividend - quotient * divisor;
+
+    NumericBuilder<T> builder;
+    builder.Append(quotient);
+    builder.Append(remainder);
+    std::shared_ptr<Array> array;
+    builder.Finish(&array);
+    FixedSizeListScalar list(array, builder.type())
+    return list;
+  }
+
+  // template <typename T, typename Arg0, typename Arg1>
+  // static enable_if_decimal_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+  //   std::pair<T, T> pair;
+  //   *st = dividend.Divide(divisor).Value(&pair);
+  //   if (!st->ok()) {
+  //     *st = Status::Invalid("division error");
+  //     return {T(), T()};
+  //   }
+  //   const auto& quotient = pair.first;
+  //   const auto& remainder = pair.second;
+  //   return {quotient, remainder};
+  // }
 };
 
 // Generate a kernel given a bitwise arithmetic functor. Assumes the

From d38f80d54ae5b7151c79aa531b12b962adf09ddc Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Jul 2022 11:08:42 -0400
Subject: [PATCH 08/10] replace quotient term, minor changes

---
 .../compute/kernels/scalar_arithmetic.cc      | 66 ++++++++++---------
 1 file changed, 36 insertions(+), 30 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 253367efad5..abe147da1d8 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -899,6 +899,7 @@ struct RoundToMultiple<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
     std::pair<CType, CType> pair;
     *st = arg.Divide(multiple).Value(&pair);
     if (!st->ok()) return arg;
+    auto& quotient = pair.first;
     const auto& remainder = pair.second;
     if (remainder == 0) return arg;
     if (kRoundMode >= RoundMode::HALF_DOWN) {
@@ -909,25 +910,25 @@ struct RoundToMultiple<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
         // decimal value, but rather manipulating the multiple
         switch (kRoundMode) {
           case RoundMode::HALF_DOWN:
-            if (remainder.Sign() < 0) pair.first -= 1;
+            if (remainder.Sign() < 0) quotient -= 1;
             break;
           case RoundMode::HALF_UP:
-            if (remainder.Sign() >= 0) pair.first += 1;
+            if (remainder.Sign() >= 0) quotient += 1;
             break;
           case RoundMode::HALF_TOWARDS_ZERO:
             // Do nothing
             break;
           case RoundMode::HALF_TOWARDS_INFINITY:
-            pair.first += remainder.Sign() >= 0 ? 1 : -1;
+            quotient += remainder.Sign() >= 0 ? 1 : -1;
             break;
           case RoundMode::HALF_TO_EVEN:
-            if (pair.first.low_bits() % 2 != 0) {
-              pair.first += remainder.Sign() >= 0 ? 1 : -1;
+            if (quotient.low_bits() % 2 != 0) {
+              quotient += remainder.Sign() >= 0 ? 1 : -1;
             }
             break;
           case RoundMode::HALF_TO_ODD:
-            if (pair.first.low_bits() % 2 == 0) {
-              pair.first += remainder.Sign() >= 0 ? 1 : -1;
+            if (quotient.low_bits() % 2 == 0) {
+              quotient += remainder.Sign() >= 0 ? 1 : -1;
             }
             break;
           default:
@@ -936,12 +937,12 @@ struct RoundToMultiple<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
       } else if (remainder.Sign() >= 0) {
         // Positive, round up/down
         if (remainder > half_multiple) {
-          pair.first += 1;
+          quotient += 1;
         }
       } else {
         // Negative, round up/down
         if (remainder < neg_half_multiple) {
-          pair.first -= 1;
+          quotient -= 1;
         }
       }
     } else {
@@ -949,22 +950,22 @@ struct RoundToMultiple<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
       // decimal value, but rather manipulating the multiple
       switch (kRoundMode) {
         case RoundMode::DOWN:
-          if (remainder.Sign() < 0) pair.first -= 1;
+          if (remainder.Sign() < 0) quotient -= 1;
           break;
         case RoundMode::UP:
-          if (remainder.Sign() >= 0) pair.first += 1;
+          if (remainder.Sign() >= 0) quotient += 1;
           break;
         case RoundMode::TOWARDS_ZERO:
           // Do nothing
           break;
         case RoundMode::TOWARDS_INFINITY:
-          pair.first += remainder.Sign() >= 0 ? 1 : -1;
+          quotient += remainder.Sign() >= 0 ? 1 : -1;
           break;
         default:
           DCHECK(false);
       }
     }
-    CType round_val = pair.first * multiple;
+    CType round_val = quotient * multiple;
     if (!round_val.FitsInPrecision(ty.precision())) {
       *st = Status::Invalid("Rounded value ", round_val.ToString(ty.scale()),
                             " does not fit in precision of ", ty);
@@ -1013,7 +1014,7 @@ struct Divmod {
     builder.Append(remainder);
     std::shared_ptr<Array> array;
     builder.Finish(&array);
-    FixedSizeListScalar list(array, builder.type())
+    FixedSizeListScalar list(array);
     return list;
   }
 
@@ -1027,7 +1028,7 @@ struct Divmod {
     builder.Append(remainder);
     std::shared_ptr<Array> array;
     builder.Finish(&array);
-    FixedSizeListScalar list(array, builder.type())
+    FixedSizeListScalar list(array);
     return list;
   }
 
@@ -1045,34 +1046,39 @@ struct DivmodChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
     T quotient = std::floor(DivideChecked::Call<T, Arg0, Arg1>(ctx, dividend, divisor, st));
-    if (!st->ok) {
-        return {0, 0};
+    T remainder;
+    if (!st->ok()) {
+        quotient = 0;
+        remainder = 0;
+    } else {
+      remainder = dividend - quotient * divisor;
     }
-    T remainder = dividend - quotient * divisor;
 
     NumericBuilder<T> builder;
     builder.Append(quotient);
     builder.Append(remainder);
     std::shared_ptr<Array> array;
     builder.Finish(&array);
-    FixedSizeListScalar list(array, builder.type())
+    FixedSizeListScalar list(array);
     return list;
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_integer_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
     T quotient = DivideChecked::Call<T, Arg0, Arg1>(ctx, dividend, divisor, st);
-    if (!st->ok) {
+    T remainder;
+    if (!st->ok()) {
         return {0, 0};
+    } else {
+      remainder = dividend - quotient * divisor;
     }
-    T remainder = dividend - quotient * divisor;
 
     NumericBuilder<T> builder;
     builder.Append(quotient);
     builder.Append(remainder);
     std::shared_ptr<Array> array;
     builder.Finish(&array);
-    FixedSizeListScalar list(array, builder.type())
+    FixedSizeListScalar list(array);
     return list;
   }
 
@@ -2330,14 +2336,14 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto divmod = MakeArithmeticFunctionStructOutType<Divmod>(
-      "divmod", divmod_doc, DivmodUtil::MakeDivmodOutType);
-  DCHECK_OK(registry->AddFunction(std::move(divmod)));
-
-  // ----------------------------------------------------------------------
-  auto divmod_checked = MakeArithmeticFunctionNotNullStructOutType<DivmodChecked>(
-      "divmod_checked", divmod_checked_doc, DivmodUtil::MakeDivmodOutType);
-  DCHECK_OK(registry->AddFunction(std::move(divmod_checked)));
+  // auto divmod = MakeArithmeticFunctionStructOutType<Divmod>(
+  //     "divmod", divmod_doc, DivmodUtil::MakeDivmodOutType);
+  // DCHECK_OK(registry->AddFunction(std::move(divmod)));
+
+  // // ----------------------------------------------------------------------
+  // auto divmod_checked = MakeArithmeticFunctionNotNullStructOutType<DivmodChecked>(
+  //     "divmod_checked", divmod_checked_doc, DivmodUtil::MakeDivmodOutType);
+  // DCHECK_OK(registry->AddFunction(std::move(divmod_checked)));
 
   // ----------------------------------------------------------------------
   auto negate = MakeUnaryArithmeticFunction<Negate>("negate", negate_doc);

From fc1eae92ff6c01d40ba5694f8de667a364fa4f3e Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 5 Sep 2022 20:32:38 -0400
Subject: [PATCH 09/10] order function regs, update output type comment

---
 cpp/src/arrow/compute/api_scalar.cc | 8 ++++----
 cpp/src/arrow/compute/api_scalar.h  | 3 ++-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index e044b6bcb41..d9d62e06240 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -648,9 +648,9 @@ SCALAR_ARITHMETIC_UNARY(Ln, "ln", "ln_checked")
 SCALAR_ARITHMETIC_UNARY(Log10, "log10", "log10_checked")
 SCALAR_ARITHMETIC_UNARY(Log1p, "log1p", "log1p_checked")
 SCALAR_ARITHMETIC_UNARY(Log2, "log2", "log2_checked")
-SCALAR_ARITHMETIC_UNARY(Sqrt, "sqrt", "sqrt_checked")
 SCALAR_ARITHMETIC_UNARY(Negate, "negate", "negate_checked")
 SCALAR_ARITHMETIC_UNARY(Sin, "sin", "sin_checked")
+SCALAR_ARITHMETIC_UNARY(Sqrt, "sqrt", "sqrt_checked")
 SCALAR_ARITHMETIC_UNARY(Tan, "tan", "tan_checked")
 SCALAR_EAGER_UNARY(Atan, "atan")
 SCALAR_EAGER_UNARY(Sign, "sign")
@@ -672,17 +672,17 @@ Result<Datum> RoundToMultiple(const Datum& arg, RoundToMultipleOptions options,
   }
 
 SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
-SCALAR_ARITHMETIC_BINARY(Subtract, "subtract", "subtract_checked")
-SCALAR_ARITHMETIC_BINARY(Multiply, "multiply", "multiply_checked")
 SCALAR_ARITHMETIC_BINARY(Divide, "divide", "divide_checked")
 SCALAR_ARITHMETIC_BINARY(Divmod, "divmod", "divmod_checked")
 SCALAR_ARITHMETIC_BINARY(Logb, "logb", "logb_checked")
+SCALAR_ARITHMETIC_BINARY(Multiply, "multiply", "multiply_checked")
 SCALAR_ARITHMETIC_BINARY(Power, "power", "power_checked")
 SCALAR_ARITHMETIC_BINARY(ShiftLeft, "shift_left", "shift_left_checked")
 SCALAR_ARITHMETIC_BINARY(ShiftRight, "shift_right", "shift_right_checked")
+SCALAR_ARITHMETIC_BINARY(Subtract, "subtract", "subtract_checked")
 SCALAR_EAGER_BINARY(Atan2, "atan2")
-SCALAR_EAGER_UNARY(Floor, "floor")
 SCALAR_EAGER_UNARY(Ceil, "ceil")
+SCALAR_EAGER_UNARY(Floor, "floor")
 SCALAR_EAGER_UNARY(Trunc, "trunc")
 
 Result<Datum> MaxElementWise(const std::vector<Datum>& args,
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 2d1b89ad048..5abf97eef3d 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -592,7 +592,8 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
 /// \param[in] divisor the divisor
 /// \param[in] options arithmetic options (enable/disable overflow checking), optional
 /// \param[in] ctx the function execution context, optional
-/// \return the elementwise quotient and remainder
+/// \return the elementwise quotient and remainder as an array of
+/// struct<quotient: T, remainder: T>
 ARROW_EXPORT
 Result<Datum> Divmod(const Datum& dividend, const Datum& divisor,
                      ArithmeticOptions options = ArithmeticOptions(),

From 4c7262f097ec1d39c2eda5346e6ae21740f04eb5 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 6 Sep 2022 01:17:04 -0400
Subject: [PATCH 10/10] minor revert, minor change

---
 cpp/src/arrow/compute/api_scalar.h                 | 3 ++-
 cpp/src/arrow/compute/kernels/codegen_internal.h   | 2 +-
 cpp/src/arrow/compute/kernels/scalar_arithmetic.cc | 2 ++
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 5abf97eef3d..5b4f6f83168 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -571,7 +571,8 @@ Result<Datum> Multiply(const Datum& left, const Datum& right,
                        ExecContext* ctx = NULLPTR);
 
 /// \brief Divide two values. Array values must be the same length. If either
-/// argument is null the result will be null. If divisor is zero, an error will be raised.
+/// argument is null the result will be null. For integer types, if there is
+/// a zero divisor, an error will be raised.
 ///
 /// \param[in] left the dividend
 /// \param[in] right the divisor
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 3c860557cae..9515302666a 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -641,7 +641,7 @@ struct ScalarUnary {
   }
 };
 
-// An alternative to ScalarUnary that Applies a scalar operation with state on
+// An alternative to ScalarUnary that applies a scalar operation with state on
 // only the not-null values of a single array
 template <typename OutType, typename Arg0Type, typename Op>
 struct ScalarUnaryNotNullStateful {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index abe147da1d8..aab7f08c3ed 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1006,6 +1006,8 @@ struct Trunc {
 struct Divmod {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_value<T, FixedSizeListScalar> Call(KernelContext* ctx, Arg0 dividend, Arg1 divisor, Status* st) {
+    static_assert(std::is_same<T, Arg0>::value, "");
+
     T quotient = std::floor(dividend / divisor);
     T remainder = dividend - quotient * divisor;