From a50942e951d396c73be26e3fa690559e3ba51118 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 25 May 2021 02:22:50 -0400
Subject: [PATCH 01/23] add sign function and tests

---
 cpp/src/arrow/compute/api_scalar.cc           |   1 +
 cpp/src/arrow/compute/api_scalar.h            |  10 ++
 .../compute/kernels/scalar_arithmetic.cc      |  76 +++++++++++
 .../compute/kernels/scalar_arithmetic_test.cc | 118 ++++++++++++++++--
 4 files changed, 193 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index be6498a74c6..88832252e19 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -330,6 +330,7 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
 
 SCALAR_ARITHMETIC_UNARY(AbsoluteValue, "abs", "abs_checked")
 SCALAR_ARITHMETIC_UNARY(Negate, "negate", "negate_checked")
+SCALAR_EAGER_UNARY(Sign, "sign")
 SCALAR_ARITHMETIC_UNARY(Sin, "sin", "sin_checked")
 SCALAR_ARITHMETIC_UNARY(Cos, "cos", "cos_checked")
 SCALAR_ARITHMETIC_UNARY(Asin, "asin", "asin_checked")
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index f0aebc8e032..fa6b8c08d77 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -513,6 +513,16 @@ Result<Datum> MinElementWise(
     ElementWiseAggregateOptions options = ElementWiseAggregateOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
+/// \brief Get the sign of a value. Array values can be of arbitrary length. If argument
+/// is null the result will be null.
+///
+/// \param[in] arg the value to extract sign from
+/// \param[in] ctx the function execution context, optional
+/// \return the elementwise sign function
+ARROW_EXPORT
+Result<Datum> Sign(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),
+                   ExecContext* ctx = NULLPTR);
+
 /// \brief Compare a numeric array with a scalar.
 ///
 /// \param[in] left datum to compare, must be an Array
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index db73294e1fa..edcab9353ea 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -462,6 +462,29 @@ struct PowerChecked {
   }
 };
 
+struct Sign {
+  template <typename T, typename Arg,
+            enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
+  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+    return std::signbit(arg) ? -1 : 1;
+  }
+
+  template <typename T, typename Arg,
+            enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
+  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+    return arg ? 1 : 0;
+  }
+
+  template <typename T, typename Arg,
+            enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
+                        bool> = true>
+  static int8_t Call(KernelContext*, Arg arg, Status*) {
+    if (arg > 0) return 1;
+    if (arg < 0) return -1;
+    return 0;
+  }
+};
+
 // Bitwise operations
 
 struct BitWiseNot {
@@ -1033,6 +1056,37 @@ void AddDecimalBinaryKernels(const std::string& name,
   DCHECK_OK((*func)->AddKernel({in_type256, in_type256}, out_type, exec256));
 }
 
+// Generate a kernel given an arithmetic functor
+template <template <typename... Args> class KernelGenerator, typename Op>
+ArrayKernelExec ArithmeticExecFromOpFixedOutType(detail::GetTypeId get_id) {
+  switch (get_id.id) {
+    case Type::INT8:
+      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
+    case Type::UINT8:
+      return KernelGenerator<Int8Type, UInt8Type, Op>::Exec;
+    case Type::INT16:
+      return KernelGenerator<Int8Type, Int16Type, Op>::Exec;
+    case Type::UINT16:
+      return KernelGenerator<Int8Type, UInt16Type, Op>::Exec;
+    case Type::INT32:
+      return KernelGenerator<Int8Type, Int32Type, Op>::Exec;
+    case Type::UINT32:
+      return KernelGenerator<Int8Type, UInt32Type, Op>::Exec;
+    case Type::INT64:
+    case Type::TIMESTAMP:
+      return KernelGenerator<Int8Type, Int64Type, Op>::Exec;
+    case Type::UINT64:
+      return KernelGenerator<Int8Type, UInt64Type, Op>::Exec;
+    case Type::FLOAT:
+      return KernelGenerator<Int8Type, FloatType, Op>::Exec;
+    case Type::DOUBLE:
+      return KernelGenerator<Int8Type, DoubleType, Op>::Exec;
+    default:
+      DCHECK(false);
+      return ExecFail;
+  }
+}
+
 struct ArithmeticFunction : ScalarFunction {
   using ScalarFunction::ScalarFunction;
 
@@ -1142,6 +1196,19 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
   return func;
 }
 
+// Like MakeUnaryArithmeticFunction, but with a fixed output type.
+template <typename Op, typename OutType>
+std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFixedOutType(
+    std::string name, const FunctionDoc* doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
+  for (const auto& ty : NumericTypes()) {
+    auto exec = ArithmeticExecFromOpFixedOutType<ScalarUnary, Op>(ty);
+    // NOTE[EPM] How to use OutType to get intX()?
+    DCHECK_OK(func->AddKernel({ty}, int8(), exec));
+  }
+  return func;
+}
+
 // Like MakeUnaryArithmeticFunction, but for arithmetic ops that need to run
 // only on non-null output.
 template <typename Op>
@@ -1318,6 +1385,11 @@ const FunctionDoc pow_checked_doc{
      "or integer overflow is encountered."),
     {"base", "exponent"}};
 
+const FunctionDoc sign_doc{"Get the sign value of the argument element-wise",
+                           ("Floating-point variants always return (-1,1).\n"
+                            "Integral variants can result in any of (-1,0,1).\n"),
+                           {"x"}};
+
 const FunctionDoc bit_wise_not_doc{
     "Bit-wise negate the arguments element-wise", ("Null values return null."), {"x"}};
 
@@ -1579,6 +1651,10 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
       MakeArithmeticFunctionNotNull<PowerChecked>("power_checked", &pow_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
+  // ----------------------------------------------------------------------
+  auto sign = MakeUnaryArithmeticFunctionFixedOutType<Sign, int8_t>("sign", &sign_doc);
+  DCHECK_OK(registry->AddFunction(std::move(sign)));
+
   // ----------------------------------------------------------------------
   // Bitwise functions
   {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index e37fb93fac2..97c666849e2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -66,7 +66,7 @@ class TestUnaryArithmetic : public TestBase {
     return *arrow::MakeScalar(type_singleton(), value);
   }
 
-  // (Scalar)
+  // (Scalar, Scalar)
   void AssertUnaryOp(UnaryFunction func, CType argument, CType expected) {
     auto arg = MakeScalar(argument);
     auto exp = MakeScalar(expected);
@@ -74,34 +74,42 @@ class TestUnaryArithmetic : public TestBase {
     AssertScalarsApproxEqual(*exp, *actual.scalar(), /*verbose=*/true);
   }
 
-  // (Scalar)
+  // (Scalar, Scalar)
   void AssertUnaryOp(UnaryFunction func, const std::shared_ptr<Scalar>& arg,
                      const std::shared_ptr<Scalar>& expected) {
     ASSERT_OK_AND_ASSIGN(auto actual, func(arg, options_, nullptr));
     AssertScalarsApproxEqual(*expected, *actual.scalar(), /*verbose=*/true);
   }
 
-  // (Array)
-  void AssertUnaryOp(UnaryFunction func, const std::string& argument,
-                     const std::string& expected) {
-    auto arg = ArrayFromJSON(type_singleton(), argument);
+  // (JSON, JSON)
+  void AssertUnaryOp(UnaryFunction func, const std::string& arg_json,
+                     const std::string& expected_json) {
+    auto arg = ArrayFromJSON(type_singleton(), arg_json);
+    auto expected = ArrayFromJSON(type_singleton(), expected_json);
     AssertUnaryOp(func, arg, expected);
   }
 
-  // (Array)
+  // (Array, JSON)
   void AssertUnaryOp(UnaryFunction func, const std::shared_ptr<Array>& arg,
                      const std::string& expected_json) {
     const auto expected = ArrayFromJSON(type_singleton(), expected_json);
-    return AssertUnaryOp(func, arg, expected);
+    AssertUnaryOp(func, arg, expected);
   }
 
-  // (Array)
+  // (JSON, Array)
+  void AssertUnaryOp(UnaryFunction func, const std::string& arg_json,
+                     const std::shared_ptr<Array>& expected) {
+    auto arg = ArrayFromJSON(type_singleton(), arg_json);
+    AssertUnaryOp(func, arg, expected);
+  }
+
+  // (Array, Array)
   void AssertUnaryOp(UnaryFunction func, const std::shared_ptr<Array>& arg,
                      const std::shared_ptr<Array>& expected) {
     ASSERT_OK_AND_ASSIGN(Datum actual, func(arg, options_, nullptr));
     ValidateAndAssertApproxEqual(actual.make_array(), expected);
 
-    // Also check (Scalar) operations
+    // Also check (Scalar, Scalar) operations
     const int64_t length = expected->length();
     for (int64_t i = 0; i < length; ++i) {
       const auto expected_scalar = *expected->GetScalar(i);
@@ -1024,7 +1032,8 @@ TEST(TestBinaryArithmetic, AddWithImplicitCastsUint64EdgeCase) {
 }
 
 TEST(TestUnaryArithmetic, DispatchBest) {
-  for (std::string name : {"negate", "abs", "abs_checked"}) {
+  // All arithmetic
+  for (std::string name : {"negate", "abs", "abs_checked", "sign"}) {
     for (const auto& ty : {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
                            uint64(), float32(), float64()}) {
       CheckDispatchBest(name, {ty}, {ty});
@@ -1032,6 +1041,7 @@ TEST(TestUnaryArithmetic, DispatchBest) {
     }
   }
 
+  // Signed arithmetic
   for (std::string name : {"negate_checked"}) {
     for (const auto& ty : {int8(), int16(), int32(), int64(), float32(), float64()}) {
       CheckDispatchBest(name, {ty}, {ty});
@@ -1039,7 +1049,8 @@ TEST(TestUnaryArithmetic, DispatchBest) {
     }
   }
 
-  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked"}) {
+  // Null input
+  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign"}) {
     CheckDispatchFails(name, {null()});
   }
 
@@ -1973,5 +1984,88 @@ TYPED_TEST(TestUnaryArithmeticSigned, Log) {
   this->AssertUnaryOpRaises(Log1p, "[-2]", "logarithm of negative number");
 }
 
+TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
+  using CType = typename TestFixture::CType;
+
+  auto min = std::numeric_limits<CType>::min();
+  auto max = std::numeric_limits<CType>::max();
+
+  // Empty array
+  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+  // Scalar/arrays with nulls
+  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
+  // Scalar/arrays with zeros
+  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+  // Ordinary scalar/arrays (positive inputs)
+  this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+  // Ordinary scalar/arrays (negative inputs)
+  this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
+  // Min/max
+  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                      ArrayFromJSON(int8(), "[-1, 1]"));
+
+  auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
+  arg = TweakValidityBit(arg, 1, false);
+  arg = TweakValidityBit(arg, 2, false);
+  this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
+}
+
+TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
+  using CType = typename TestFixture::CType;
+
+  auto min = std::numeric_limits<CType>::min();
+  auto max = std::numeric_limits<CType>::max();
+
+  // Empty arrays
+  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+  // Array with nulls
+  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  // Ordinary arrays
+  this->AssertUnaryOp(Sign, "[0, 1, 10, 127]", ArrayFromJSON(int8(), "[0, 1, 1, 1]"));
+  // Min/max
+  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                      ArrayFromJSON(int8(), "[0, 1]"));
+
+  auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(0, min, max, 1));
+  arg = TweakValidityBit(arg, 1, false);
+  arg = TweakValidityBit(arg, 2, false);
+  this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[0, null, null, 1]"));
+}
+
+TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
+  using CType = typename TestFixture::CType;
+
+  auto min = std::numeric_limits<CType>::lowest();
+  auto max = std::numeric_limits<CType>::max();
+
+  // Empty array
+  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+  // Scalar/arrays with nulls
+  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  this->AssertUnaryOp(Sign, "[1.3, null, -10.80]",
+                      ArrayFromJSON(int8(), "[1, null, -1]"));
+  // Scalars/arrays with zeros
+  this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[1, -1]"));
+  // Ordinary scalars/arrays (positive inputs)
+  this->AssertUnaryOp(Sign, "[1.3, 10.80, 12748.001]",
+                      ArrayFromJSON(int8(), "[1, 1, 1]"));
+  // Ordinary scalars/arrays (negative inputs)
+  this->AssertUnaryOp(Sign, "[-1.3, -10.80, -12748.001]",
+                      ArrayFromJSON(int8(), "[-1, -1, -1]"));
+  // Arrays with infinites
+  this->AssertUnaryOp(Sign, "[Inf, -Inf]", ArrayFromJSON(int8(), "[1, -1]"));
+  // Arrays with NaNs
+  // NOTE[EPM] NaNs do no work, why?
+  // this->AssertUnaryOp(Sign, "[NaN, -NaN]", ArrayFromJSON(int8(), "[1, -1]"));
+  // Min/max
+  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                      ArrayFromJSON(int8(), "[-1, 1]"));
+
+  auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
+  arg = TweakValidityBit(arg, 1, false);
+  arg = TweakValidityBit(arg, 2, false);
+  this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
+}
 }  // namespace compute
 }  // namespace arrow

From 41e72dd2e98700ee9f7e194d53201eb6a4c3fc58 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 25 May 2021 02:50:39 -0400
Subject: [PATCH 02/23] update C++/Python compute docs

---
 .../compute/kernels/scalar_arithmetic.cc      | 130 ++++++++++--------
 docs/source/cpp/compute.rst                   |   5 +
 docs/source/python/api/compute.rst            |   5 +-
 3 files changed, 82 insertions(+), 58 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index edcab9353ea..4c78e2c10e3 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1311,11 +1311,12 @@ const FunctionDoc absolute_value_checked_doc{
      "doesn't fail on overflow, use function \"abs\"."),
     {"x"}};
 
-const FunctionDoc add_doc{"Add the arguments element-wise",
-                          ("Results will wrap around on integer overflow.\n"
-                           "Use function \"add_checked\" if you want overflow\n"
-                           "to return an error."),
-                          {"x", "y"}};
+const FunctionDoc add_doc{
+    "Add the arguments element-wise",
+    ("Results will wrap around on integer overflow.\n"
+     "Use function \"add_checked\" if you want overflow\n"
+     "to return an error."),
+    {"x", "y"}};
 
 const FunctionDoc add_checked_doc{
     "Add the arguments element-wise",
@@ -1323,11 +1324,12 @@ const FunctionDoc add_checked_doc{
      "doesn't fail on overflow, use function \"add\"."),
     {"x", "y"}};
 
-const FunctionDoc sub_doc{"Subtract the arguments element-wise",
-                          ("Results will wrap around on integer overflow.\n"
-                           "Use function \"subtract_checked\" if you want overflow\n"
-                           "to return an error."),
-                          {"x", "y"}};
+const FunctionDoc sub_doc{
+    "Subtract the arguments element-wise",
+    ("Results will wrap around on integer overflow.\n"
+     "Use function \"subtract_checked\" if you want overflow\n"
+     "to return an error."),
+    {"x", "y"}};
 
 const FunctionDoc sub_checked_doc{
     "Subtract the arguments element-wise",
@@ -1335,11 +1337,12 @@ const FunctionDoc sub_checked_doc{
      "doesn't fail on overflow, use function \"subtract\"."),
     {"x", "y"}};
 
-const FunctionDoc mul_doc{"Multiply the arguments element-wise",
-                          ("Results will wrap around on integer overflow.\n"
-                           "Use function \"multiply_checked\" if you want overflow\n"
-                           "to return an error."),
-                          {"x", "y"}};
+const FunctionDoc mul_doc{
+    "Multiply the arguments element-wise",
+    ("Results will wrap around on integer overflow.\n"
+     "Use function \"multiply_checked\" if you want overflow\n"
+     "to return an error."),
+    {"x", "y"}};
 
 const FunctionDoc mul_checked_doc{
     "Multiply the arguments element-wise",
@@ -1361,11 +1364,12 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"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"
-                              "to return an error."),
-                             {"x"}};
+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"
+     "to return an error."),
+    {"x"}};
 
 const FunctionDoc negate_checked_doc{
     "Negate the arguments element-wise",
@@ -1385,22 +1389,30 @@ const FunctionDoc pow_checked_doc{
      "or integer overflow is encountered."),
     {"base", "exponent"}};
 
-const FunctionDoc sign_doc{"Get the sign value of the argument element-wise",
-                           ("Floating-point variants always return (-1,1).\n"
-                            "Integral variants can result in any of (-1,0,1).\n"),
-                           {"x"}};
+const FunctionDoc sign_doc{
+    "Get the sign value of the argument element-wise",
+    ("For nonzero inputs, output is any of (-1,1) and 0 for zero input."),
+    {"x"}};
 
 const FunctionDoc bit_wise_not_doc{
-    "Bit-wise negate the arguments element-wise", ("Null values return null."), {"x"}};
+    "Bit-wise negate the arguments element-wise",
+    ("Null values return null."),
+    {"x"}};
 
 const FunctionDoc bit_wise_and_doc{
-    "Bit-wise AND the arguments element-wise", ("Null values return null."), {"x", "y"}};
+    "Bit-wise AND the arguments element-wise",
+    ("Null values return null."),
+    {"x", "y"}};
 
 const FunctionDoc bit_wise_or_doc{
-    "Bit-wise OR the arguments element-wise", ("Null values return null."), {"x", "y"}};
+    "Bit-wise OR the arguments element-wise",
+    ("Null values return null."),
+    {"x", "y"}};
 
 const FunctionDoc bit_wise_xor_doc{
-    "Bit-wise XOR the arguments element-wise", ("Null values return null."), {"x", "y"}};
+    "Bit-wise XOR the arguments element-wise",
+    ("Null values return null."),
+    {"x", "y"}};
 
 const FunctionDoc shift_left_doc{
     "Left shift `x` by `y`",
@@ -1440,11 +1452,12 @@ const FunctionDoc shift_right_checked_doc{
      "See \"shift_right\" for a variant that doesn't fail for an invalid shift amount"),
     {"x", "y"}};
 
-const FunctionDoc sin_doc{"Compute the sine of the elements argument-wise",
-                          ("Integer arguments return double values. "
-                           "This function returns NaN on values outside its domain. "
-                           "To raise an error instead, see \"sin_checked\"."),
-                          {"x"}};
+const FunctionDoc sin_doc{
+    "Compute the sine of the elements argument-wise",
+    ("Integer arguments return double values. "
+     "This function returns NaN on values outside its domain. "
+     "To raise an error instead, see \"sin_checked\"."),
+    {"x"}};
 
 const FunctionDoc sin_checked_doc{
     "Compute the sine of the elements argument-wise",
@@ -1453,11 +1466,12 @@ const FunctionDoc sin_checked_doc{
      "To return NaN instead, see \"sin\"."),
     {"x"}};
 
-const FunctionDoc cos_doc{"Compute the cosine of the elements argument-wise",
-                          ("Integer arguments return double values. "
-                           "This function returns NaN on values outside its domain. "
-                           "To raise an error instead, see \"cos_checked\"."),
-                          {"x"}};
+const FunctionDoc cos_doc{
+    "Compute the cosine of the elements argument-wise",
+    ("Integer arguments return double values. "
+     "This function returns NaN on values outside its domain. "
+     "To raise an error instead, see \"cos_checked\"."),
+    {"x"}};
 
 const FunctionDoc cos_checked_doc{
     "Compute the cosine of the elements argument-wise",
@@ -1466,11 +1480,12 @@ const FunctionDoc cos_checked_doc{
      "To return NaN instead, see \"cos\"."),
     {"x"}};
 
-const FunctionDoc tan_doc{"Compute the tangent of the elements argument-wise",
-                          ("Integer arguments return double values. "
-                           "This function returns NaN on values outside its domain. "
-                           "To raise an error instead, see \"tan_checked\"."),
-                          {"x"}};
+const FunctionDoc tan_doc{
+    "Compute the tangent of the elements argument-wise",
+    ("Integer arguments return double values. "
+     "This function returns NaN on values outside its domain. "
+     "To raise an error instead, see \"tan_checked\"."),
+    {"x"}};
 
 const FunctionDoc tan_checked_doc{
     "Compute the tangent of the elements argument-wise",
@@ -1479,11 +1494,12 @@ const FunctionDoc tan_checked_doc{
      "To return NaN instead, see \"tan\"."),
     {"x"}};
 
-const FunctionDoc asin_doc{"Compute the inverse sine of the elements argument-wise",
-                           ("Integer arguments return double values. "
-                            "This function returns NaN on values outside its domain. "
-                            "To raise an error instead, see \"asin_checked\"."),
-                           {"x"}};
+const FunctionDoc asin_doc{
+    "Compute the inverse sine of the elements argument-wise",
+    ("Integer arguments return double values. "
+     "This function returns NaN on values outside its domain. "
+     "To raise an error instead, see \"asin_checked\"."),
+    {"x"}};
 
 const FunctionDoc asin_checked_doc{
     "Compute the inverse sine of the elements argument-wise",
@@ -1492,11 +1508,12 @@ const FunctionDoc asin_checked_doc{
      "To return NaN instead, see \"asin\"."),
     {"x"}};
 
-const FunctionDoc acos_doc{"Compute the inverse cosine of the elements argument-wise",
-                           ("Integer arguments return double values. "
-                            "This function returns NaN on values outside its domain. "
-                            "To raise an error instead, see \"acos_checked\"."),
-                           {"x"}};
+const FunctionDoc acos_doc{
+    "Compute the inverse cosine of the elements argument-wise",
+    ("Integer arguments return double values. "
+     "This function returns NaN on values outside its domain. "
+     "To raise an error instead, see \"acos_checked\"."),
+    {"x"}};
 
 const FunctionDoc acos_checked_doc{
     "Compute the inverse cosine of the elements argument-wise",
@@ -1505,9 +1522,10 @@ const FunctionDoc acos_checked_doc{
      "To return NaN instead, see \"acos\"."),
     {"x"}};
 
-const FunctionDoc atan_doc{"Compute the principal value of the inverse tangent",
-                           ("Integer arguments return double values."),
-                           {"x"}};
+const FunctionDoc atan_doc{
+    "Compute the principal value of the inverse tangent",
+    ("Integer arguments return double values."),
+    {"x"}};
 
 const FunctionDoc atan2_doc{
     "Compute the inverse tangent using argument signs to determine the quadrant",
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 6ce808aba67..a3400b733e0 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -289,6 +289,8 @@ an ``Invalid`` :class:`Status` when overflow is detected.
 +------------------+--------+----------------+----------------+-------+
 | power_checked    | Binary | Numeric        | Numeric        |       |
 +------------------+--------+----------------+----------------+-------+
+| sign             | Unary  | Numeric        | Int8           | \(2)  |
++------------------+--------+----------------+----------------+-------+
 | subtract         | Binary | Numeric        | Numeric        | \(1)  |
 +------------------+--------+----------------+----------------+-------+
 | subtract_checked | Binary | Numeric        | Numeric        | \(1)  |
@@ -315,6 +317,9 @@ an ``Invalid`` :class:`Status` when overflow is detected.
   enough scale kept. Error is returned if the result precision is beyond the
   decimal value range.
 
+* \(2) Output is an integral representing the signedness of the input.
+  For nonzero inputs, output is any of (-1,1) and 0 for zero input.
+
 Bit-wise functions
 ~~~~~~~~~~~~~~~~~~
 
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index 09c67598193..58d35e47f8b 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -54,14 +54,15 @@ throws an ``ArrowInvalid`` exception when overflow is detected.
    divide_checked
    multiply
    multiply_checked
-   subtract
-   subtract_checked
    power
    power_checked
    shift_left
    shift_left_checked
    shift_right
    shift_right_checked
+   sign
+   subtract
+   subtract_checked
 
 Bit-wise operations do not offer (or need) a checked variant.
 

From de7951258ca413195973095926442a329dafe19f Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 25 May 2021 05:38:36 -0400
Subject: [PATCH 03/23] add GD for arithmetic kernels with fixed output type

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 4c78e2c10e3..dcaea903022 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -20,8 +20,10 @@
 #include <limits>
 #include <utility>
 
+#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
 #include "arrow/util/int_util_internal.h"
@@ -1057,36 +1059,36 @@ void AddDecimalBinaryKernels(const std::string& name,
 }
 
 // Generate a kernel given an arithmetic functor
-template <template <typename... Args> class KernelGenerator, typename Op>
-ArrayKernelExec ArithmeticExecFromOpFixedOutType(detail::GetTypeId get_id) {
+template <template <typename... Args> class KernelGenerator, typename Type0,
+          typename... Args>
+ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
-      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
+      return KernelGenerator<Type0, Int8Type, Args...>::Exec;
     case Type::UINT8:
-      return KernelGenerator<Int8Type, UInt8Type, Op>::Exec;
+      return KernelGenerator<Type0, UInt8Type, Args...>::Exec;
     case Type::INT16:
-      return KernelGenerator<Int8Type, Int16Type, Op>::Exec;
+      return KernelGenerator<Type0, Int16Type, Args...>::Exec;
     case Type::UINT16:
-      return KernelGenerator<Int8Type, UInt16Type, Op>::Exec;
+      return KernelGenerator<Type0, UInt16Type, Args...>::Exec;
     case Type::INT32:
-      return KernelGenerator<Int8Type, Int32Type, Op>::Exec;
+      return KernelGenerator<Type0, Int32Type, Args...>::Exec;
     case Type::UINT32:
-      return KernelGenerator<Int8Type, UInt32Type, Op>::Exec;
+      return KernelGenerator<Type0, UInt32Type, Args...>::Exec;
     case Type::INT64:
     case Type::TIMESTAMP:
-      return KernelGenerator<Int8Type, Int64Type, Op>::Exec;
+      return KernelGenerator<Type0, Int64Type, Args...>::Exec;
     case Type::UINT64:
-      return KernelGenerator<Int8Type, UInt64Type, Op>::Exec;
+      return KernelGenerator<Type0, UInt64Type, Args...>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<Int8Type, FloatType, Op>::Exec;
+      return KernelGenerator<Type0, FloatType, Args...>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<Int8Type, DoubleType, Op>::Exec;
+      return KernelGenerator<Type0, DoubleType, Args...>::Exec;
     default:
       DCHECK(false);
       return ExecFail;
   }
 }
-
 struct ArithmeticFunction : ScalarFunction {
   using ScalarFunction::ScalarFunction;
 
@@ -1200,11 +1202,11 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
 template <typename Op, typename OutType>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFixedOutType(
     std::string name, const FunctionDoc* doc) {
+  auto out_ty = TypeTraits<OutType>::type_singleton();
   auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
   for (const auto& ty : NumericTypes()) {
-    auto exec = ArithmeticExecFromOpFixedOutType<ScalarUnary, Op>(ty);
-    // NOTE[EPM] How to use OutType to get intX()?
-    DCHECK_OK(func->AddKernel({ty}, int8(), exec));
+    auto exec = GenerateArithmeticFixedOutType<ScalarUnary, OutType, Op>(ty);
+    DCHECK_OK(func->AddKernel({ty}, out_ty, exec));
   }
   return func;
 }
@@ -1670,7 +1672,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
   // ----------------------------------------------------------------------
-  auto sign = MakeUnaryArithmeticFunctionFixedOutType<Sign, int8_t>("sign", &sign_doc);
+  auto sign = MakeUnaryArithmeticFunctionFixedOutType<Sign, Int8Type>("sign", &sign_doc);
   DCHECK_OK(registry->AddFunction(std::move(sign)));
 
   // ----------------------------------------------------------------------

From 1052f045e8e7d4f7676bfb28261ed78849af89c2 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 27 May 2021 05:08:28 -0400
Subject: [PATCH 04/23] improve variants of sign function and tests

---
 cpp/src/arrow/compute/api_scalar.h            |  2 +-
 .../compute/kernels/scalar_arithmetic.cc      | 27 +++++-
 .../compute/kernels/scalar_arithmetic_test.cc | 85 ++++++++++---------
 3 files changed, 70 insertions(+), 44 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index fa6b8c08d77..5f03b1f33ad 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -41,7 +41,6 @@ class ARROW_EXPORT ArithmeticOptions : public FunctionOptions {
  public:
   explicit ArithmeticOptions(bool check_overflow = false);
   constexpr static char const kTypeName[] = "ArithmeticOptions";
-  bool check_overflow;
 };
 
 class ARROW_EXPORT ElementWiseAggregateOptions : public FunctionOptions {
@@ -517,6 +516,7 @@ Result<Datum> MinElementWise(
 /// is null the result will be null.
 ///
 /// \param[in] arg the value to extract sign from
+/// \param[in] options arithmetic options (signed zero handling), optional
 /// \param[in] ctx the function execution context, optional
 /// \return the elementwise sign function
 ARROW_EXPORT
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index dcaea903022..192cfe59ea1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -465,6 +465,27 @@ struct PowerChecked {
 };
 
 struct Sign {
+  template <typename T, typename Arg,
+            enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
+  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+    return (arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1);
+  }
+
+  template <typename T, typename Arg,
+            enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
+  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+    return arg ? 1 : 0;
+  }
+
+  template <typename T, typename Arg,
+            enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
+                        bool> = true>
+  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+    return (arg > 0) ? 1 : ((arg < 0) ? -1 : 0);
+  }
+};
+
+struct SignWithSignedZero : Sign {
   template <typename T, typename Arg,
             enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
   static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
@@ -480,10 +501,8 @@ struct Sign {
   template <typename T, typename Arg,
             enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
                         bool> = true>
-  static int8_t Call(KernelContext*, Arg arg, Status*) {
-    if (arg > 0) return 1;
-    if (arg < 0) return -1;
-    return 0;
+  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+    return (arg > 0) ? 1 : ((arg < 0) ? -1 : 0);
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 97c666849e2..d91bb28c9f1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -56,8 +56,6 @@ class TestUnaryArithmetic : public TestBase {
   using UnaryFunction =
       std::function<Result<Datum>(const Datum&, ArithmeticOptions, ExecContext*)>;
 
-  void SetUp() override { options_.check_overflow = false; }
-
   std::shared_ptr<Scalar> MakeNullScalar() {
     return arrow::MakeNullScalar(type_singleton());
   }
@@ -66,6 +64,8 @@ class TestUnaryArithmetic : public TestBase {
     return *arrow::MakeScalar(type_singleton(), value);
   }
 
+  void SetUp() override { SetOverflowCheck(false); }
+
   // (Scalar, Scalar)
   void AssertUnaryOp(UnaryFunction func, CType argument, CType expected) {
     auto arg = MakeScalar(argument);
@@ -106,7 +106,7 @@ class TestUnaryArithmetic : public TestBase {
   // (Array, Array)
   void AssertUnaryOp(UnaryFunction func, const std::shared_ptr<Array>& arg,
                      const std::shared_ptr<Array>& expected) {
-    ASSERT_OK_AND_ASSIGN(Datum actual, func(arg, options_, nullptr));
+    ASSERT_OK_AND_ASSIGN(auto actual, func(arg, options_, nullptr));
     ValidateAndAssertApproxEqual(actual.make_array(), expected);
 
     // Also check (Scalar, Scalar) operations
@@ -152,6 +152,8 @@ class TestUnaryArithmetic : public TestBase {
 
   void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
 
+  void SetSignedZero(bool value = true) { options_.allow_signed_zero = value; }
+
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
   }
@@ -1986,56 +1988,59 @@ TYPED_TEST(TestUnaryArithmeticSigned, Log) {
 
 TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
   using CType = typename TestFixture::CType;
-
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  // Empty array
-  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Scalar/arrays with nulls
-  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
-  // Scalar/arrays with zeros
-  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-  // Ordinary scalar/arrays (positive inputs)
-  this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-  // Ordinary scalar/arrays (negative inputs)
-  this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
-  // Min/max
-  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                      ArrayFromJSON(int8(), "[-1, 1]"));
+  for (auto allow_signed_zero : {false, true}) {
+    this->SetSignedZero(allow_signed_zero);
+    // Empty array
+    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+    // Scalar/arrays with nulls
+    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+    this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
+    // Scalar/arrays with zeros
+    this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+    // Ordinary scalar/arrays (positive inputs)
+    this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+    // Ordinary scalar/arrays (negative inputs)
+    this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
+    // Min/max
+    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                        ArrayFromJSON(int8(), "[-1, 1]"));
 
-  auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
-  arg = TweakValidityBit(arg, 1, false);
-  arg = TweakValidityBit(arg, 2, false);
-  this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
+    auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
+    arg = TweakValidityBit(arg, 1, false);
+    arg = TweakValidityBit(arg, 2, false);
+    this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
+  }
 }
 
 TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
   using CType = typename TestFixture::CType;
-
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  // Empty arrays
-  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Array with nulls
-  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  // Ordinary arrays
-  this->AssertUnaryOp(Sign, "[0, 1, 10, 127]", ArrayFromJSON(int8(), "[0, 1, 1, 1]"));
-  // Min/max
-  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                      ArrayFromJSON(int8(), "[0, 1]"));
+  for (auto allow_signed_zero : {false, true}) {
+    this->SetSignedZero(allow_signed_zero);
+    // Empty arrays
+    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+    // Array with nulls
+    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+    // Ordinary arrays
+    this->AssertUnaryOp(Sign, "[0, 1, 10, 127]", ArrayFromJSON(int8(), "[0, 1, 1, 1]"));
+    // Min/max
+    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                        ArrayFromJSON(int8(), "[0, 1]"));
 
-  auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(0, min, max, 1));
-  arg = TweakValidityBit(arg, 1, false);
-  arg = TweakValidityBit(arg, 2, false);
-  this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[0, null, null, 1]"));
+    auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(0, min, max, 1));
+    arg = TweakValidityBit(arg, 1, false);
+    arg = TweakValidityBit(arg, 2, false);
+    this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[0, null, null, 1]"));
+  }
 }
 
 TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   using CType = typename TestFixture::CType;
-
   auto min = std::numeric_limits<CType>::lowest();
   auto max = std::numeric_limits<CType>::max();
 
@@ -2046,7 +2051,10 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   this->AssertUnaryOp(Sign, "[1.3, null, -10.80]",
                       ArrayFromJSON(int8(), "[1, null, -1]"));
   // Scalars/arrays with zeros
+  this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[0, 0]"));
+  this->SetSignedZero(true);
   this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[1, -1]"));
+  this->SetSignedZero(false);
   // Ordinary scalars/arrays (positive inputs)
   this->AssertUnaryOp(Sign, "[1.3, 10.80, 12748.001]",
                       ArrayFromJSON(int8(), "[1, 1, 1]"));
@@ -2056,8 +2064,7 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   // Arrays with infinites
   this->AssertUnaryOp(Sign, "[Inf, -Inf]", ArrayFromJSON(int8(), "[1, -1]"));
   // Arrays with NaNs
-  // NOTE[EPM] NaNs do no work, why?
-  // this->AssertUnaryOp(Sign, "[NaN, -NaN]", ArrayFromJSON(int8(), "[1, -1]"));
+  this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
   // Min/max
   this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
                       ArrayFromJSON(int8(), "[-1, 1]"));

From 584a4ee56badfc9bd7b39913c02ac176aba7e37b Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 27 May 2021 06:36:50 -0400
Subject: [PATCH 05/23] disabled min/max FP tests to check error in
 AMD64-WinGW32

---
 .../arrow/compute/kernels/scalar_arithmetic_test.cc  | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index d91bb28c9f1..47727248fec 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -2066,13 +2066,13 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   // Arrays with NaNs
   this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
   // Min/max
-  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                      ArrayFromJSON(int8(), "[-1, 1]"));
+  // this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+  //                     ArrayFromJSON(int8(), "[-1, 1]"));
 
-  auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
-  arg = TweakValidityBit(arg, 1, false);
-  arg = TweakValidityBit(arg, 2, false);
-  this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
+  // auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
+  // arg = TweakValidityBit(arg, 1, false);
+  // arg = TweakValidityBit(arg, 2, false);
+  // this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
 }
 }  // namespace compute
 }  // namespace arrow

From df87f08bb4a0be5f9406307f7cc8e12ba7143733 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 27 May 2021 15:51:18 -0400
Subject: [PATCH 06/23] enable max() test again

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic.cc      | 1 +
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 192cfe59ea1..ec2f832d9d7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1108,6 +1108,7 @@ ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
       return ExecFail;
   }
 }
+
 struct ArithmeticFunction : ScalarFunction {
   using ScalarFunction::ScalarFunction;
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 47727248fec..1eacd6c7f07 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -2066,8 +2066,8 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   // Arrays with NaNs
   this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
   // Min/max
-  // this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-  //                     ArrayFromJSON(int8(), "[-1, 1]"));
+  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                      ArrayFromJSON(int8(), "[-1, 1]"));
 
   // auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
   // arg = TweakValidityBit(arg, 1, false);

From 0fadccc0785c8b3aa1197cc05be4adeb10f03cea Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 11 Jun 2021 04:14:37 -0400
Subject: [PATCH 07/23] add SignOptions and update kernel def

---
 cpp/src/arrow/compute/api_scalar.h            |  4 +--
 .../compute/kernels/scalar_arithmetic.cc      | 32 +++++++++----------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 5f03b1f33ad..c3a6689977e 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -516,11 +516,11 @@ Result<Datum> MinElementWise(
 /// is null the result will be null.
 ///
 /// \param[in] arg the value to extract sign from
-/// \param[in] options arithmetic options (signed zero handling), optional
+/// \param[in] options options for handling signed zero, optional
 /// \param[in] ctx the function execution context, optional
 /// \return the elementwise sign function
 ARROW_EXPORT
-Result<Datum> Sign(const Datum& arg, ArithmeticOptions options = ArithmeticOptions(),
+Result<Datum> Sign(const Datum& arg, SignOptions options = SignOptions(),
                    ExecContext* ctx = NULLPTR);
 
 /// \brief Compare a numeric array with a scalar.
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index ec2f832d9d7..cabdfd28a77 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -474,18 +474,18 @@ struct Sign {
   template <typename T, typename Arg,
             enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
   static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
-    return arg ? 1 : 0;
+    return (arg == 0) ? 0 : 1;
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
                         bool> = true>
   static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
-    return (arg > 0) ? 1 : ((arg < 0) ? -1 : 0);
+    return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
   }
 };
 
-struct SignWithSignedZero : Sign {
+struct SignWithSignedZero {
   template <typename T, typename Arg,
             enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
   static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
@@ -495,14 +495,14 @@ struct SignWithSignedZero : Sign {
   template <typename T, typename Arg,
             enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
   static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
-    return arg ? 1 : 0;
+    return (arg == 0) ? 0 : 1;
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
                         bool> = true>
   static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
-    return (arg > 0) ? 1 : ((arg < 0) ? -1 : 0);
+    return (arg >= 0) ? 1 : -1;
   }
 };
 
@@ -1078,31 +1078,31 @@ void AddDecimalBinaryKernels(const std::string& name,
 }
 
 // Generate a kernel given an arithmetic functor
-template <template <typename... Args> class KernelGenerator, typename Type0,
+template <template <typename... Args> class KernelGenerator, typename OutType,
           typename... Args>
 ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
-      return KernelGenerator<Type0, Int8Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int8Type, Args...>::Exec;
     case Type::UINT8:
-      return KernelGenerator<Type0, UInt8Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt8Type, Args...>::Exec;
     case Type::INT16:
-      return KernelGenerator<Type0, Int16Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int16Type, Args...>::Exec;
     case Type::UINT16:
-      return KernelGenerator<Type0, UInt16Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt16Type, Args...>::Exec;
     case Type::INT32:
-      return KernelGenerator<Type0, Int32Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int32Type, Args...>::Exec;
     case Type::UINT32:
-      return KernelGenerator<Type0, UInt32Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt32Type, Args...>::Exec;
     case Type::INT64:
     case Type::TIMESTAMP:
-      return KernelGenerator<Type0, Int64Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int64Type, Args...>::Exec;
     case Type::UINT64:
-      return KernelGenerator<Type0, UInt64Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt64Type, Args...>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<Type0, FloatType, Args...>::Exec;
+      return KernelGenerator<OutType, FloatType, Args...>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<Type0, DoubleType, Args...>::Exec;
+      return KernelGenerator<OutType, DoubleType, Args...>::Exec;
     default:
       DCHECK(false);
       return ExecFail;

From f7229ea1143e2e6c5436c3aa1ca954978afcea34 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 11 Jun 2021 04:15:09 -0400
Subject: [PATCH 08/23] update documentation

---
 docs/source/cpp/compute.rst        | 2 +-
 docs/source/python/api/compute.rst | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index a3400b733e0..1b221e0efcb 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -258,7 +258,7 @@ Input(s) will be cast to the :ref:`common numeric type <common-numeric-type>`
 (and dictionary decoded, if applicable) before the operation is applied.
 
 The default variant of these functions does not detect overflow (the result
-then typically wraps around).  Each function is also available in an
+then typically wraps around).  Most functions are also available in an
 overflow-checking variant, suffixed ``_checked``, which returns
 an ``Invalid`` :class:`Status` when overflow is detected.
 
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index 58d35e47f8b..d243f24fcbf 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -39,7 +39,7 @@ Aggregations
 Arithmetic Functions
 --------------------
 
-By default these functions do not detect overflow. Each function is also
+By default these functions do not detect overflow. Most functions are also
 available in an overflow-checking variant, suffixed ``_checked``, which
 throws an ``ArrowInvalid`` exception when overflow is detected.
 

From 50c2c1f712268bd1997403c391321154b1685a01 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 11 Jun 2021 04:16:48 -0400
Subject: [PATCH 09/23] debugging tests (unstable

---
 .../compute/kernels/scalar_arithmetic_test.cc | 91 ++++++++-----------
 1 file changed, 40 insertions(+), 51 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 1eacd6c7f07..6dbdc20c96a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -152,8 +152,6 @@ class TestUnaryArithmetic : public TestBase {
 
   void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
 
-  void SetSignedZero(bool value = true) { options_.allow_signed_zero = value; }
-
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
   }
@@ -1035,7 +1033,7 @@ TEST(TestBinaryArithmetic, AddWithImplicitCastsUint64EdgeCase) {
 
 TEST(TestUnaryArithmetic, DispatchBest) {
   // All arithmetic
-  for (std::string name : {"negate", "abs", "abs_checked", "sign"}) {
+  for (std::string name : {"negate", "abs", "abs_checked"}) {
     for (const auto& ty : {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
                            uint64(), float32(), float64()}) {
       CheckDispatchBest(name, {ty}, {ty});
@@ -1051,8 +1049,23 @@ TEST(TestUnaryArithmetic, DispatchBest) {
     }
   }
 
+  // Functions with fixed output type
+  struct FuncAndOutType {
+    std::string name;
+    std::shared_ptr<DataType> out_type;
+  };
+
+  FuncAndOutType funcs[] = {{"sign", int8()}};
+  for (const auto& func : funcs) {
+    for (const auto& ty : {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
+                           uint64(), float32(), float64()}) {
+      CheckDispatchBest(func.name, {ty}, {func.out_type});
+      CheckDispatchBest(func.name, {dictionary(int8(), ty)}, {func.out_type});
+    }
+  }
+
   // Null input
-  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign"}) {
+  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign", "sign_with_signed_zero"}) {
     CheckDispatchFails(name, {null()});
   }
 
@@ -1991,28 +2004,20 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto allow_signed_zero : {false, true}) {
-    this->SetSignedZero(allow_signed_zero);
-    // Empty array
-    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-    // Scalar/arrays with nulls
-    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-    this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
-    // Scalar/arrays with zeros
-    this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-    // Ordinary scalar/arrays (positive inputs)
-    this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-    // Ordinary scalar/arrays (negative inputs)
-    this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
-    // Min/max
-    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                        ArrayFromJSON(int8(), "[-1, 1]"));
-
-    auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
-    arg = TweakValidityBit(arg, 1, false);
-    arg = TweakValidityBit(arg, 2, false);
-    this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
-  }
+  // Empty array
+  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+  // Scalar/arrays with nulls
+  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
+  // Scalar/arrays with zeros
+  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+  // Ordinary scalar/arrays (positive inputs)
+  this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+  // Ordinary scalar/arrays (negative inputs)
+  this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
+  // Min/max
+  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                      ArrayFromJSON(int8(), "[-1, 1]"));
 }
 
 TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
@@ -2020,23 +2025,15 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto allow_signed_zero : {false, true}) {
-    this->SetSignedZero(allow_signed_zero);
-    // Empty arrays
-    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-    // Array with nulls
-    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-    // Ordinary arrays
-    this->AssertUnaryOp(Sign, "[0, 1, 10, 127]", ArrayFromJSON(int8(), "[0, 1, 1, 1]"));
-    // Min/max
-    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                        ArrayFromJSON(int8(), "[0, 1]"));
-
-    auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(0, min, max, 1));
-    arg = TweakValidityBit(arg, 1, false);
-    arg = TweakValidityBit(arg, 2, false);
-    this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[0, null, null, 1]"));
-  }
+  // Empty arrays
+  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+  // Array with nulls
+  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  // Ordinary arrays
+  this->AssertUnaryOp(Sign, "[0, 1, 10, 127]", ArrayFromJSON(int8(), "[0, 1, 1, 1]"));
+  // Min/max
+  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                      ArrayFromJSON(int8(), "[0, 1]"));
 }
 
 TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
@@ -2052,9 +2049,6 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
                       ArrayFromJSON(int8(), "[1, null, -1]"));
   // Scalars/arrays with zeros
   this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[0, 0]"));
-  this->SetSignedZero(true);
-  this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[1, -1]"));
-  this->SetSignedZero(false);
   // Ordinary scalars/arrays (positive inputs)
   this->AssertUnaryOp(Sign, "[1.3, 10.80, 12748.001]",
                       ArrayFromJSON(int8(), "[1, 1, 1]"));
@@ -2068,11 +2062,6 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   // Min/max
   this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
                       ArrayFromJSON(int8(), "[-1, 1]"));
-
-  // auto arg = ArrayFromJSON(this->type_singleton(), MakeArray(-1, min, max, 1));
-  // arg = TweakValidityBit(arg, 1, false);
-  // arg = TweakValidityBit(arg, 2, false);
-  // this->AssertUnaryOp(Sign, arg, ArrayFromJSON(int8(), "[-1, null, null, 1]"));
 }
 }  // namespace compute
 }  // namespace arrow

From 770d6efdc46183b49ff6933a8ffec30a98747c62 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sat, 12 Jun 2021 04:09:55 -0400
Subject: [PATCH 10/23] fix kernel and tests

---
 .../compute/kernels/scalar_arithmetic.cc      | 19 ++--
 .../compute/kernels/scalar_arithmetic_test.cc | 87 ++++++++++++++-----
 2 files changed, 74 insertions(+), 32 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index cabdfd28a77..daf4563a334 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -467,20 +467,20 @@ struct PowerChecked {
 struct Sign {
   template <typename T, typename Arg,
             enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
-  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1);
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
-  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg == 0) ? 0 : 1;
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
                         bool> = true>
-  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
   }
 };
@@ -488,20 +488,20 @@ struct Sign {
 struct SignWithSignedZero {
   template <typename T, typename Arg,
             enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
-  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return std::signbit(arg) ? -1 : 1;
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
-  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
-    return (arg == 0) ? 0 : 1;
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
+    return 1;
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
                         bool> = true>
-  static constexpr int8_t Call(KernelContext*, Arg arg, Status*) {
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg >= 0) ? 1 : -1;
   }
 };
@@ -1078,7 +1078,7 @@ void AddDecimalBinaryKernels(const std::string& name,
 }
 
 // Generate a kernel given an arithmetic functor
-template <template <typename... Args> class KernelGenerator, typename OutType,
+template <template <typename...> class KernelGenerator, typename OutType,
           typename... Args>
 ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
@@ -1218,7 +1218,8 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
   return func;
 }
 
-// Like MakeUnaryArithmeticFunction, but with a fixed output type.
+// Like MakeUnaryArithmeticFunction, but for unary arithmetic ops with a fixed
+// output type.
 template <typename Op, typename OutType>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFixedOutType(
     std::string name, const FunctionDoc* doc) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 6dbdc20c96a..6026c3ba432 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -43,8 +43,8 @@
 namespace arrow {
 namespace compute {
 
-template <typename T>
-class TestUnaryArithmetic : public TestBase {
+template <typename T, typename Options>
+class TestBaseUnaryArithmetic : public TestBase {
  protected:
   using ArrowType = T;
   using CType = typename ArrowType::c_type;
@@ -53,8 +53,7 @@ class TestUnaryArithmetic : public TestBase {
     return TypeTraits<ArrowType>::type_singleton();
   }
 
-  using UnaryFunction =
-      std::function<Result<Datum>(const Datum&, ArithmeticOptions, ExecContext*)>;
+  using UnaryFunction = std::function<Result<Datum>(const Datum&, Options, ExecContext*)>;
 
   std::shared_ptr<Scalar> MakeNullScalar() {
     return arrow::MakeNullScalar(type_singleton());
@@ -64,7 +63,7 @@ class TestUnaryArithmetic : public TestBase {
     return *arrow::MakeScalar(type_singleton(), value);
   }
 
-  void SetUp() override { SetOverflowCheck(false); }
+  void SetUp() override {}
 
   // (Scalar, Scalar)
   void AssertUnaryOp(UnaryFunction func, CType argument, CType expected) {
@@ -150,18 +149,29 @@ class TestUnaryArithmetic : public TestBase {
     AssertArraysApproxEqual(*expected, *actual, /*verbose=*/true, equal_options_);
   }
 
-  void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
-
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
   }
 
-  ArithmeticOptions options_ = ArithmeticOptions();
+  Options options_ = Options();
   EqualOptions equal_options_ = EqualOptions::Defaults();
 };
 
+template <typename T, typename Options>
+class TestUnaryArithmetic : public TestBaseUnaryArithmetic<T, Options> {};
+
 template <typename T>
-class TestUnaryArithmeticIntegral : public TestUnaryArithmetic<T> {};
+class TestUnaryArithmetic<T, ArithmeticOptions>
+    : public TestBaseUnaryArithmetic<T, ArithmeticOptions> {
+  using Base = TestBaseUnaryArithmetic<T, ArithmeticOptions>;
+  using Base::options_;
+
+ protected:
+  void SetOverflowCheck(bool value) { options_.check_overflow = value; }
+};
+
+template <typename T>
+class TestUnaryArithmeticIntegral : public TestUnaryArithmetic<T, ArithmeticOptions> {};
 
 template <typename T>
 class TestUnaryArithmeticSigned : public TestUnaryArithmeticIntegral<T> {};
@@ -170,7 +180,23 @@ template <typename T>
 class TestUnaryArithmeticUnsigned : public TestUnaryArithmeticIntegral<T> {};
 
 template <typename T>
-class TestUnaryArithmeticFloating : public TestUnaryArithmetic<T> {};
+class TestUnaryArithmeticFloating : public TestUnaryArithmetic<T, ArithmeticOptions> {};
+
+template <typename T>
+class TestUnaryArithmetic<T, SignOptions>
+    : public TestBaseUnaryArithmetic<T, SignOptions> {};
+
+template <typename T>
+class TestUnaryArithmeticIntegral_Sign : public TestUnaryArithmetic<T, SignOptions> {};
+
+template <typename T>
+class TestUnaryArithmeticSigned_Sign : public TestUnaryArithmeticIntegral_Sign<T> {};
+
+template <typename T>
+class TestUnaryArithmeticUnsigned_Sign : public TestUnaryArithmeticIntegral_Sign<T> {};
+
+template <typename T>
+class TestUnaryArithmeticFloating_Sign : public TestUnaryArithmetic<T, SignOptions> {};
 
 template <typename T>
 class TestBinaryArithmetic : public TestBase {
@@ -403,6 +429,11 @@ TYPED_TEST_SUITE(TestUnaryArithmeticSigned, SignedIntegerTypes);
 TYPED_TEST_SUITE(TestUnaryArithmeticUnsigned, UnsignedIntegerTypes);
 TYPED_TEST_SUITE(TestUnaryArithmeticFloating, FloatingTypes);
 
+TYPED_TEST_SUITE(TestUnaryArithmeticIntegral_Sign, IntegralTypes);
+TYPED_TEST_SUITE(TestUnaryArithmeticSigned_Sign, SignedIntegerTypes);
+TYPED_TEST_SUITE(TestUnaryArithmeticUnsigned_Sign, UnsignedIntegerTypes);
+TYPED_TEST_SUITE(TestUnaryArithmeticFloating_Sign, FloatingTypes);
+
 TYPED_TEST_SUITE(TestBinaryArithmeticIntegral, IntegralTypes);
 TYPED_TEST_SUITE(TestBinaryArithmeticSigned, SignedIntegerTypes);
 TYPED_TEST_SUITE(TestBinaryArithmeticUnsigned, UnsignedIntegerTypes);
@@ -1661,6 +1692,7 @@ TEST(TestBinaryArithmeticDecimal, Divide) {
   }
 }
 
+<<<<<<< 7c29ba1efa914c2971bb8563d45b238ff88edcfb
 TYPED_TEST(TestBinaryArithmeticIntegral, ShiftLeft) {
   for (auto check_overflow : {false, true}) {
     this->SetOverflowCheck(check_overflow);
@@ -2006,14 +2038,17 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
 
   // Empty array
   this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Scalar/arrays with nulls
+  // Null
   this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
   this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
-  // Scalar/arrays with zeros
+  // Zero
+  this->options_.with_signed_zero = true;
+  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[1]"));
+  this->options_.with_signed_zero = false;
   this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-  // Ordinary scalar/arrays (positive inputs)
+  // Positive inputs
   this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-  // Ordinary scalar/arrays (negative inputs)
+  // Negative inputs
   this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
   // Min/max
   this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
@@ -2027,10 +2062,16 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
 
   // Empty arrays
   this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Array with nulls
+  // Null
   this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  // Ordinary arrays
-  this->AssertUnaryOp(Sign, "[0, 1, 10, 127]", ArrayFromJSON(int8(), "[0, 1, 1, 1]"));
+  this->AssertUnaryOp(Sign, "[1, null, 10]", ArrayFromJSON(int8(), "[1, null, 1]"));
+  // Zero
+  this->options_.with_signed_zero = true;
+  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[1]"));
+  this->options_.with_signed_zero = false;
+  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+  // Positive inputs
+  this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
   // Min/max
   this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
                       ArrayFromJSON(int8(), "[0, 1]"));
@@ -2043,21 +2084,21 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
 
   // Empty array
   this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Scalar/arrays with nulls
+  // Null
   this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
   this->AssertUnaryOp(Sign, "[1.3, null, -10.80]",
                       ArrayFromJSON(int8(), "[1, null, -1]"));
-  // Scalars/arrays with zeros
+  // Zero
   this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[0, 0]"));
-  // Ordinary scalars/arrays (positive inputs)
+  // Positive inputs
   this->AssertUnaryOp(Sign, "[1.3, 10.80, 12748.001]",
                       ArrayFromJSON(int8(), "[1, 1, 1]"));
-  // Ordinary scalars/arrays (negative inputs)
+  // Negative inputs
   this->AssertUnaryOp(Sign, "[-1.3, -10.80, -12748.001]",
                       ArrayFromJSON(int8(), "[-1, -1, -1]"));
-  // Arrays with infinites
+  // Infinite
   this->AssertUnaryOp(Sign, "[Inf, -Inf]", ArrayFromJSON(int8(), "[1, -1]"));
-  // Arrays with NaNs
+  // NaN
   this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
   // Min/max
   this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),

From c1366cfef57998e247b32dd8fcf651da35d1feb7 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sat, 12 Jun 2021 04:33:24 -0400
Subject: [PATCH 11/23] fix lint errors

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 6026c3ba432..8886d5a58b3 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -1096,7 +1096,8 @@ TEST(TestUnaryArithmetic, DispatchBest) {
   }
 
   // Null input
-  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign", "sign_with_signed_zero"}) {
+  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign",
+                           "sign_with_signed_zero"}) {
     CheckDispatchFails(name, {null()});
   }
 

From 6e7bcabb6bdaa1254da80a0f17bad55ace1b9dab Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 16 Jun 2021 02:05:39 -0400
Subject: [PATCH 12/23] update based on reviews

---
 .../compute/kernels/scalar_arithmetic.cc      |  4 +-
 .../compute/kernels/scalar_arithmetic_test.cc | 84 ++++++++-----------
 2 files changed, 38 insertions(+), 50 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index daf4563a334..b51154701a9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -495,14 +495,14 @@ struct SignWithSignedZero {
   template <typename T, typename Arg,
             enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
   static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return 1;
+    return (arg == 0) ? 0 : 1;
   }
 
   template <typename T, typename Arg,
             enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
                         bool> = true>
   static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return (arg >= 0) ? 1 : -1;
+    return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 8886d5a58b3..ff66fa559cf 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -1064,7 +1064,8 @@ TEST(TestBinaryArithmetic, AddWithImplicitCastsUint64EdgeCase) {
 
 TEST(TestUnaryArithmetic, DispatchBest) {
   // All arithmetic
-  for (std::string name : {"negate", "abs", "abs_checked"}) {
+  for (std::string name :
+       {"negate", "abs", "abs_checked", "sign", "sign_with_signed_zero"}) {
     for (const auto& ty : {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
                            uint64(), float32(), float64()}) {
       CheckDispatchBest(name, {ty}, {ty});
@@ -1080,21 +1081,6 @@ TEST(TestUnaryArithmetic, DispatchBest) {
     }
   }
 
-  // Functions with fixed output type
-  struct FuncAndOutType {
-    std::string name;
-    std::shared_ptr<DataType> out_type;
-  };
-
-  FuncAndOutType funcs[] = {{"sign", int8()}};
-  for (const auto& func : funcs) {
-    for (const auto& ty : {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
-                           uint64(), float32(), float64()}) {
-      CheckDispatchBest(func.name, {ty}, {func.out_type});
-      CheckDispatchBest(func.name, {dictionary(int8(), ty)}, {func.out_type});
-    }
-  }
-
   // Null input
   for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign",
                            "sign_with_signed_zero"}) {
@@ -2037,23 +2023,24 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  // Empty array
-  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Null
-  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
-  // Zero
-  this->options_.with_signed_zero = true;
-  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[1]"));
-  this->options_.with_signed_zero = false;
-  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-  // Positive inputs
-  this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-  // Negative inputs
-  this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
-  // Min/max
-  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                      ArrayFromJSON(int8(), "[-1, 1]"));
+  for (auto with_signed_zero : {false, true}) {
+    this->options_.with_signed_zero = with_signed_zero;
+
+    // Empty array
+    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+    // Null
+    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+    this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
+    // Zero
+    this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+    // Positive inputs
+    this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+    // Negative inputs
+    this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
+    // Min/max
+    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                        ArrayFromJSON(int8(), "[-1, 1]"));
+  }
 }
 
 TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
@@ -2061,21 +2048,22 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  // Empty arrays
-  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Null
-  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  this->AssertUnaryOp(Sign, "[1, null, 10]", ArrayFromJSON(int8(), "[1, null, 1]"));
-  // Zero
-  this->options_.with_signed_zero = true;
-  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[1]"));
-  this->options_.with_signed_zero = false;
-  this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-  // Positive inputs
-  this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-  // Min/max
-  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                      ArrayFromJSON(int8(), "[0, 1]"));
+  for (auto with_signed_zero : {false, true}) {
+    this->options_.with_signed_zero = with_signed_zero;
+
+    // Empty arrays
+    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
+    // Null
+    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+    this->AssertUnaryOp(Sign, "[1, null, 10]", ArrayFromJSON(int8(), "[1, null, 1]"));
+    // Zero
+    this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+    // Positive inputs
+    this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+    // Min/max
+    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
+                        ArrayFromJSON(int8(), "[0, 1]"));
+  }
 }
 
 TYPED_TEST(TestUnaryArithmeticFloating, Sign) {

From 19243a0fa77c9fa2413d3468f6a57cfce56a0457 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 16 Jun 2021 04:13:50 -0400
Subject: [PATCH 13/23] remove JSON format for min/max due to AMD64 Win MinGW32
 error

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index ff66fa559cf..e497b4e3b25 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -2038,8 +2038,7 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
     // Negative inputs
     this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
     // Min/max
-    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                        ArrayFromJSON(int8(), "[-1, 1]"));
+    this->AssertUnaryOp(Sign, MakeArray(min, max), ArrayFromJSON(int8(), "[-1, 1]"));
   }
 }
 
@@ -2061,8 +2060,7 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
     // Positive inputs
     this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
     // Min/max
-    this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                        ArrayFromJSON(int8(), "[0, 1]"));
+    this->AssertUnaryOp(Sign, MakeArray(min, max), ArrayFromJSON(int8(), "[0, 1]"));
   }
 }
 
@@ -2090,8 +2088,7 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   // NaN
   this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
   // Min/max
-  this->AssertUnaryOp(Sign, ArrayFromJSON(this->type_singleton(), MakeArray(min, max)),
-                      ArrayFromJSON(int8(), "[-1, 1]"));
+  this->AssertUnaryOp(Sign, MakeArray(min, max), ArrayFromJSON(int8(), "[-1, 1]"));
 }
 }  // namespace compute
 }  // namespace arrow

From 089a693e7003be63811e70fa81cb804f65bfb067 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 16 Jun 2021 12:33:41 -0400
Subject: [PATCH 14/23] change FP test for min/max

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index e497b4e3b25..0182de6be13 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -2088,7 +2088,8 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   // NaN
   this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
   // Min/max
-  this->AssertUnaryOp(Sign, MakeArray(min, max), ArrayFromJSON(int8(), "[-1, 1]"));
+  this->AssertUnaryOp(Sign, MakeScalar(min), *arrow::MakeScalar(int8(), -1));
+  this->AssertUnaryOp(Sign, MakeScalar(max), *arrow::MakeScalar(int8(), 1));
 }
 }  // namespace compute
 }  // namespace arrow

From d15839103d7337e07cb3faf817ad7332634dc763 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 17 Jun 2021 01:11:20 -0400
Subject: [PATCH 15/23] change GD template to use Op instead of ...Args

---
 .../compute/kernels/scalar_arithmetic.cc      | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index b51154701a9..2ef7c0daecf 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1079,30 +1079,30 @@ void AddDecimalBinaryKernels(const std::string& name,
 
 // Generate a kernel given an arithmetic functor
 template <template <typename...> class KernelGenerator, typename OutType,
-          typename... Args>
+          typename Op>
 ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
-      return KernelGenerator<OutType, Int8Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int8Type, Op>::Exec;
     case Type::UINT8:
-      return KernelGenerator<OutType, UInt8Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt8Type, Op>::Exec;
     case Type::INT16:
-      return KernelGenerator<OutType, Int16Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int16Type, Op>::Exec;
     case Type::UINT16:
-      return KernelGenerator<OutType, UInt16Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt16Type, Op>::Exec;
     case Type::INT32:
-      return KernelGenerator<OutType, Int32Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int32Type, Op>::Exec;
     case Type::UINT32:
-      return KernelGenerator<OutType, UInt32Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt32Type, Op>::Exec;
     case Type::INT64:
     case Type::TIMESTAMP:
-      return KernelGenerator<OutType, Int64Type, Args...>::Exec;
+      return KernelGenerator<OutType, Int64Type, Op>::Exec;
     case Type::UINT64:
-      return KernelGenerator<OutType, UInt64Type, Args...>::Exec;
+      return KernelGenerator<OutType, UInt64Type, Op>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<OutType, FloatType, Args...>::Exec;
+      return KernelGenerator<OutType, FloatType, Op>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<OutType, DoubleType, Args...>::Exec;
+      return KernelGenerator<OutType, DoubleType, Op>::Exec;
     default:
       DCHECK(false);
       return ExecFail;

From 0025fe0129b8d4524837ffc3c96a4f6d6de9341f Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 17 Jun 2021 01:14:10 -0400
Subject: [PATCH 16/23] clang format

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 2ef7c0daecf..f8e4243cf01 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1078,8 +1078,7 @@ void AddDecimalBinaryKernels(const std::string& name,
 }
 
 // Generate a kernel given an arithmetic functor
-template <template <typename...> class KernelGenerator, typename OutType,
-          typename Op>
+template <template <typename...> class KernelGenerator, typename OutType, typename Op>
 ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:

From 053f468cd6e5f1267f76ca3c8a6cdecf90e6ca1b Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 22 Jun 2021 03:07:32 -0400
Subject: [PATCH 17/23] rename generator dispatcher and kernel exec generator

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic.cc | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index f8e4243cf01..d9e7c84f6bd 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1079,7 +1079,7 @@ void AddDecimalBinaryKernels(const std::string& name,
 
 // Generate a kernel given an arithmetic functor
 template <template <typename...> class KernelGenerator, typename OutType, typename Op>
-ArrayKernelExec GenerateArithmeticFixedOutType(detail::GetTypeId get_id) {
+ArrayKernelExec GenerateArithmeticWithFixedOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
       return KernelGenerator<OutType, Int8Type, Op>::Exec;
@@ -1220,12 +1220,12 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
 // Like MakeUnaryArithmeticFunction, but for unary arithmetic ops with a fixed
 // output type.
 template <typename Op, typename OutType>
-std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFixedOutType(
+std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionWithFixedOutType(
     std::string name, const FunctionDoc* doc) {
   auto out_ty = TypeTraits<OutType>::type_singleton();
   auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
   for (const auto& ty : NumericTypes()) {
-    auto exec = GenerateArithmeticFixedOutType<ScalarUnary, OutType, Op>(ty);
+    auto exec = GenerateArithmeticWithFixedOutType<ScalarUnary, OutType, Op>(ty);
     DCHECK_OK(func->AddKernel({ty}, out_ty, exec));
   }
   return func;
@@ -1692,7 +1692,8 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
   // ----------------------------------------------------------------------
-  auto sign = MakeUnaryArithmeticFunctionFixedOutType<Sign, Int8Type>("sign", &sign_doc);
+  auto sign =
+      MakeUnaryArithmeticFunctionWithFixedOutType<Sign, Int8Type>("sign", &sign_doc);
   DCHECK_OK(registry->AddFunction(std::move(sign)));
 
   // ----------------------------------------------------------------------

From 1c92d277feae9df38e0f270b7fa116bc7c8dad8a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 14 Jul 2021 09:12:43 -0400
Subject: [PATCH 18/23] remove sign_with_signed_zero variant

---
 cpp/src/arrow/compute/api_scalar.h            |   5 +-
 .../compute/kernels/scalar_arithmetic.cc      |  23 +--
 .../compute/kernels/scalar_arithmetic_test.cc | 147 +++++++-----------
 3 files changed, 55 insertions(+), 120 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index c3a6689977e..2be289a4720 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -41,6 +41,7 @@ class ARROW_EXPORT ArithmeticOptions : public FunctionOptions {
  public:
   explicit ArithmeticOptions(bool check_overflow = false);
   constexpr static char const kTypeName[] = "ArithmeticOptions";
+  bool check_overflow;
 };
 
 class ARROW_EXPORT ElementWiseAggregateOptions : public FunctionOptions {
@@ -516,12 +517,10 @@ Result<Datum> MinElementWise(
 /// is null the result will be null.
 ///
 /// \param[in] arg the value to extract sign from
-/// \param[in] options options for handling signed zero, optional
 /// \param[in] ctx the function execution context, optional
 /// \return the elementwise sign function
 ARROW_EXPORT
-Result<Datum> Sign(const Datum& arg, SignOptions options = SignOptions(),
-                   ExecContext* ctx = NULLPTR);
+Result<Datum> Sign(const Datum& arg, ExecContext* ctx = NULLPTR);
 
 /// \brief Compare a numeric array with a scalar.
 ///
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index d9e7c84f6bd..0fb9d5e2f50 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -474,28 +474,7 @@ struct Sign {
   template <typename T, typename Arg,
             enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
   static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return (arg == 0) ? 0 : 1;
-  }
-
-  template <typename T, typename Arg,
-            enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
-                        bool> = true>
-  static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
-  }
-};
-
-struct SignWithSignedZero {
-  template <typename T, typename Arg,
-            enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
-  static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return std::signbit(arg) ? -1 : 1;
-  }
-
-  template <typename T, typename Arg,
-            enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
-  static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return (arg == 0) ? 0 : 1;
+    return arg > 0;
   }
 
   template <typename T, typename Arg,
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 0182de6be13..bbafdeadf96 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -43,8 +43,8 @@
 namespace arrow {
 namespace compute {
 
-template <typename T, typename Options>
-class TestBaseUnaryArithmetic : public TestBase {
+template <typename T>
+class TestUnaryArithmetic : public TestBase {
  protected:
   using ArrowType = T;
   using CType = typename ArrowType::c_type;
@@ -53,7 +53,10 @@ class TestBaseUnaryArithmetic : public TestBase {
     return TypeTraits<ArrowType>::type_singleton();
   }
 
-  using UnaryFunction = std::function<Result<Datum>(const Datum&, Options, ExecContext*)>;
+  using UnaryFunction =
+      std::function<Result<Datum>(const Datum&, ArithmeticOptions, ExecContext*)>;
+
+  void SetUp() override { options_.check_overflow = false; }
 
   std::shared_ptr<Scalar> MakeNullScalar() {
     return arrow::MakeNullScalar(type_singleton());
@@ -63,8 +66,6 @@ class TestBaseUnaryArithmetic : public TestBase {
     return *arrow::MakeScalar(type_singleton(), value);
   }
 
-  void SetUp() override {}
-
   // (Scalar, Scalar)
   void AssertUnaryOp(UnaryFunction func, CType argument, CType expected) {
     auto arg = MakeScalar(argument);
@@ -149,29 +150,18 @@ class TestBaseUnaryArithmetic : public TestBase {
     AssertArraysApproxEqual(*expected, *actual, /*verbose=*/true, equal_options_);
   }
 
+  void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
+
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
   }
 
-  Options options_ = Options();
+  ArithmeticOptions options_ = ArithmeticOptions();
   EqualOptions equal_options_ = EqualOptions::Defaults();
 };
 
-template <typename T, typename Options>
-class TestUnaryArithmetic : public TestBaseUnaryArithmetic<T, Options> {};
-
-template <typename T>
-class TestUnaryArithmetic<T, ArithmeticOptions>
-    : public TestBaseUnaryArithmetic<T, ArithmeticOptions> {
-  using Base = TestBaseUnaryArithmetic<T, ArithmeticOptions>;
-  using Base::options_;
-
- protected:
-  void SetOverflowCheck(bool value) { options_.check_overflow = value; }
-};
-
 template <typename T>
-class TestUnaryArithmeticIntegral : public TestUnaryArithmetic<T, ArithmeticOptions> {};
+class TestUnaryArithmeticIntegral : public TestUnaryArithmetic<T> {};
 
 template <typename T>
 class TestUnaryArithmeticSigned : public TestUnaryArithmeticIntegral<T> {};
@@ -180,23 +170,7 @@ template <typename T>
 class TestUnaryArithmeticUnsigned : public TestUnaryArithmeticIntegral<T> {};
 
 template <typename T>
-class TestUnaryArithmeticFloating : public TestUnaryArithmetic<T, ArithmeticOptions> {};
-
-template <typename T>
-class TestUnaryArithmetic<T, SignOptions>
-    : public TestBaseUnaryArithmetic<T, SignOptions> {};
-
-template <typename T>
-class TestUnaryArithmeticIntegral_Sign : public TestUnaryArithmetic<T, SignOptions> {};
-
-template <typename T>
-class TestUnaryArithmeticSigned_Sign : public TestUnaryArithmeticIntegral_Sign<T> {};
-
-template <typename T>
-class TestUnaryArithmeticUnsigned_Sign : public TestUnaryArithmeticIntegral_Sign<T> {};
-
-template <typename T>
-class TestUnaryArithmeticFloating_Sign : public TestUnaryArithmetic<T, SignOptions> {};
+class TestUnaryArithmeticFloating : public TestUnaryArithmetic<T> {};
 
 template <typename T>
 class TestBinaryArithmetic : public TestBase {
@@ -429,11 +403,6 @@ TYPED_TEST_SUITE(TestUnaryArithmeticSigned, SignedIntegerTypes);
 TYPED_TEST_SUITE(TestUnaryArithmeticUnsigned, UnsignedIntegerTypes);
 TYPED_TEST_SUITE(TestUnaryArithmeticFloating, FloatingTypes);
 
-TYPED_TEST_SUITE(TestUnaryArithmeticIntegral_Sign, IntegralTypes);
-TYPED_TEST_SUITE(TestUnaryArithmeticSigned_Sign, SignedIntegerTypes);
-TYPED_TEST_SUITE(TestUnaryArithmeticUnsigned_Sign, UnsignedIntegerTypes);
-TYPED_TEST_SUITE(TestUnaryArithmeticFloating_Sign, FloatingTypes);
-
 TYPED_TEST_SUITE(TestBinaryArithmeticIntegral, IntegralTypes);
 TYPED_TEST_SUITE(TestBinaryArithmeticSigned, SignedIntegerTypes);
 TYPED_TEST_SUITE(TestBinaryArithmeticUnsigned, UnsignedIntegerTypes);
@@ -1064,8 +1033,7 @@ TEST(TestBinaryArithmetic, AddWithImplicitCastsUint64EdgeCase) {
 
 TEST(TestUnaryArithmetic, DispatchBest) {
   // All arithmetic
-  for (std::string name :
-       {"negate", "abs", "abs_checked", "sign", "sign_with_signed_zero"}) {
+  for (std::string name : {"negate", "abs", "abs_checked", "sign"}) {
     for (const auto& ty : {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
                            uint64(), float32(), float64()}) {
       CheckDispatchBest(name, {ty}, {ty});
@@ -1082,8 +1050,7 @@ TEST(TestUnaryArithmetic, DispatchBest) {
   }
 
   // Null input
-  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign",
-                           "sign_with_signed_zero"}) {
+  for (std::string name : {"negate", "negate_checked", "abs", "abs_checked", "sign"}) {
     CheckDispatchFails(name, {null()});
   }
 
@@ -1679,7 +1646,6 @@ TEST(TestBinaryArithmeticDecimal, Divide) {
   }
 }
 
-<<<<<<< 7c29ba1efa914c2971bb8563d45b238ff88edcfb
 TYPED_TEST(TestBinaryArithmeticIntegral, ShiftLeft) {
   for (auto check_overflow : {false, true}) {
     this->SetOverflowCheck(check_overflow);
@@ -2023,23 +1989,19 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto with_signed_zero : {false, true}) {
-    this->options_.with_signed_zero = with_signed_zero;
+  // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
+  // second parameter
+  auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
+    return Sign(arg, ctx);
+  };
 
-    // Empty array
-    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-    // Null
-    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-    this->AssertUnaryOp(Sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
-    // Zero
-    this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-    // Positive inputs
-    this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-    // Negative inputs
-    this->AssertUnaryOp(Sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
-    // Min/max
-    this->AssertUnaryOp(Sign, MakeArray(min, max), ArrayFromJSON(int8(), "[-1, 1]"));
-  }
+  this->AssertUnaryOp(sign, "[]", ArrayFromJSON(int8(), "[]"));
+  this->AssertUnaryOp(sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  this->AssertUnaryOp(sign, "[1, null, -10]", ArrayFromJSON(int8(), "[1, null, -1]"));
+  this->AssertUnaryOp(sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+  this->AssertUnaryOp(sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+  this->AssertUnaryOp(sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
+  this->AssertUnaryOp(sign, MakeArray(min, max), ArrayFromJSON(int8(), "[-1, 1]"));
 }
 
 TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
@@ -2047,21 +2009,18 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto with_signed_zero : {false, true}) {
-    this->options_.with_signed_zero = with_signed_zero;
+  // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
+  // second parameter
+  auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
+    return Sign(arg, ctx);
+  };
 
-    // Empty arrays
-    this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-    // Null
-    this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-    this->AssertUnaryOp(Sign, "[1, null, 10]", ArrayFromJSON(int8(), "[1, null, 1]"));
-    // Zero
-    this->AssertUnaryOp(Sign, "[0]", ArrayFromJSON(int8(), "[0]"));
-    // Positive inputs
-    this->AssertUnaryOp(Sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-    // Min/max
-    this->AssertUnaryOp(Sign, MakeArray(min, max), ArrayFromJSON(int8(), "[0, 1]"));
-  }
+  this->AssertUnaryOp(sign, "[]", ArrayFromJSON(int8(), "[]"));
+  this->AssertUnaryOp(sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  this->AssertUnaryOp(sign, "[1, null, 10]", ArrayFromJSON(int8(), "[1, null, 1]"));
+  this->AssertUnaryOp(sign, "[0]", ArrayFromJSON(int8(), "[0]"));
+  this->AssertUnaryOp(sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
+  this->AssertUnaryOp(sign, MakeArray(min, max), ArrayFromJSON(int8(), "[0, 1]"));
 }
 
 TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
@@ -2069,27 +2028,25 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   auto min = std::numeric_limits<CType>::lowest();
   auto max = std::numeric_limits<CType>::max();
 
-  // Empty array
-  this->AssertUnaryOp(Sign, "[]", ArrayFromJSON(int8(), "[]"));
-  // Null
-  this->AssertUnaryOp(Sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  this->AssertUnaryOp(Sign, "[1.3, null, -10.80]",
+  // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
+  // second parameter
+  auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
+    return Sign(arg, ctx);
+  };
+
+  this->AssertUnaryOp(sign, "[]", ArrayFromJSON(int8(), "[]"));
+  this->AssertUnaryOp(sign, "[null]", ArrayFromJSON(int8(), "[null]"));
+  this->AssertUnaryOp(sign, "[1.3, null, -10.80]",
                       ArrayFromJSON(int8(), "[1, null, -1]"));
-  // Zero
-  this->AssertUnaryOp(Sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[0, 0]"));
-  // Positive inputs
-  this->AssertUnaryOp(Sign, "[1.3, 10.80, 12748.001]",
+  this->AssertUnaryOp(sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[0, 0]"));
+  this->AssertUnaryOp(sign, "[1.3, 10.80, 12748.001]",
                       ArrayFromJSON(int8(), "[1, 1, 1]"));
-  // Negative inputs
-  this->AssertUnaryOp(Sign, "[-1.3, -10.80, -12748.001]",
+  this->AssertUnaryOp(sign, "[-1.3, -10.80, -12748.001]",
                       ArrayFromJSON(int8(), "[-1, -1, -1]"));
-  // Infinite
-  this->AssertUnaryOp(Sign, "[Inf, -Inf]", ArrayFromJSON(int8(), "[1, -1]"));
-  // NaN
-  this->AssertUnaryOp(Sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
-  // Min/max
-  this->AssertUnaryOp(Sign, MakeScalar(min), *arrow::MakeScalar(int8(), -1));
-  this->AssertUnaryOp(Sign, MakeScalar(max), *arrow::MakeScalar(int8(), 1));
+  this->AssertUnaryOp(sign, "[Inf, -Inf]", ArrayFromJSON(int8(), "[1, -1]"));
+  this->AssertUnaryOp(sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
+  this->AssertUnaryOp(sign, MakeScalar(min), *arrow::MakeScalar(int8(), -1));
+  this->AssertUnaryOp(sign, MakeScalar(max), *arrow::MakeScalar(int8(), 1));
 }
 }  // namespace compute
 }  // namespace arrow

From 2f971e0f62da4beb903a09d3c5268c8b84a4f936 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 14 Jul 2021 13:36:23 -0400
Subject: [PATCH 19/23] fix lint error

---
 .../compute/kernels/scalar_arithmetic.cc      | 122 ++++++++----------
 1 file changed, 52 insertions(+), 70 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 0fb9d5e2f50..267c2cdf4e5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1312,12 +1312,11 @@ const FunctionDoc absolute_value_checked_doc{
      "doesn't fail on overflow, use function \"abs\"."),
     {"x"}};
 
-const FunctionDoc add_doc{
-    "Add the arguments element-wise",
-    ("Results will wrap around on integer overflow.\n"
-     "Use function \"add_checked\" if you want overflow\n"
-     "to return an error."),
-    {"x", "y"}};
+const FunctionDoc add_doc{"Add the arguments element-wise",
+                          ("Results will wrap around on integer overflow.\n"
+                           "Use function \"add_checked\" if you want overflow\n"
+                           "to return an error."),
+                          {"x", "y"}};
 
 const FunctionDoc add_checked_doc{
     "Add the arguments element-wise",
@@ -1325,12 +1324,11 @@ const FunctionDoc add_checked_doc{
      "doesn't fail on overflow, use function \"add\"."),
     {"x", "y"}};
 
-const FunctionDoc sub_doc{
-    "Subtract the arguments element-wise",
-    ("Results will wrap around on integer overflow.\n"
-     "Use function \"subtract_checked\" if you want overflow\n"
-     "to return an error."),
-    {"x", "y"}};
+const FunctionDoc sub_doc{"Subtract the arguments element-wise",
+                          ("Results will wrap around on integer overflow.\n"
+                           "Use function \"subtract_checked\" if you want overflow\n"
+                           "to return an error."),
+                          {"x", "y"}};
 
 const FunctionDoc sub_checked_doc{
     "Subtract the arguments element-wise",
@@ -1338,12 +1336,11 @@ const FunctionDoc sub_checked_doc{
      "doesn't fail on overflow, use function \"subtract\"."),
     {"x", "y"}};
 
-const FunctionDoc mul_doc{
-    "Multiply the arguments element-wise",
-    ("Results will wrap around on integer overflow.\n"
-     "Use function \"multiply_checked\" if you want overflow\n"
-     "to return an error."),
-    {"x", "y"}};
+const FunctionDoc mul_doc{"Multiply the arguments element-wise",
+                          ("Results will wrap around on integer overflow.\n"
+                           "Use function \"multiply_checked\" if you want overflow\n"
+                           "to return an error."),
+                          {"x", "y"}};
 
 const FunctionDoc mul_checked_doc{
     "Multiply the arguments element-wise",
@@ -1365,12 +1362,11 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"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"
-     "to return an error."),
-    {"x"}};
+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"
+                              "to return an error."),
+                             {"x"}};
 
 const FunctionDoc negate_checked_doc{
     "Negate the arguments element-wise",
@@ -1396,24 +1392,16 @@ const FunctionDoc sign_doc{
     {"x"}};
 
 const FunctionDoc bit_wise_not_doc{
-    "Bit-wise negate the arguments element-wise",
-    ("Null values return null."),
-    {"x"}};
+    "Bit-wise negate the arguments element-wise", ("Null values return null."), {"x"}};
 
 const FunctionDoc bit_wise_and_doc{
-    "Bit-wise AND the arguments element-wise",
-    ("Null values return null."),
-    {"x", "y"}};
+    "Bit-wise AND the arguments element-wise", ("Null values return null."), {"x", "y"}};
 
 const FunctionDoc bit_wise_or_doc{
-    "Bit-wise OR the arguments element-wise",
-    ("Null values return null."),
-    {"x", "y"}};
+    "Bit-wise OR the arguments element-wise", ("Null values return null."), {"x", "y"}};
 
 const FunctionDoc bit_wise_xor_doc{
-    "Bit-wise XOR the arguments element-wise",
-    ("Null values return null."),
-    {"x", "y"}};
+    "Bit-wise XOR the arguments element-wise", ("Null values return null."), {"x", "y"}};
 
 const FunctionDoc shift_left_doc{
     "Left shift `x` by `y`",
@@ -1453,12 +1441,11 @@ const FunctionDoc shift_right_checked_doc{
      "See \"shift_right\" for a variant that doesn't fail for an invalid shift amount"),
     {"x", "y"}};
 
-const FunctionDoc sin_doc{
-    "Compute the sine of the elements argument-wise",
-    ("Integer arguments return double values. "
-     "This function returns NaN on values outside its domain. "
-     "To raise an error instead, see \"sin_checked\"."),
-    {"x"}};
+const FunctionDoc sin_doc{"Compute the sine of the elements argument-wise",
+                          ("Integer arguments return double values. "
+                           "This function returns NaN on values outside its domain. "
+                           "To raise an error instead, see \"sin_checked\"."),
+                          {"x"}};
 
 const FunctionDoc sin_checked_doc{
     "Compute the sine of the elements argument-wise",
@@ -1467,12 +1454,11 @@ const FunctionDoc sin_checked_doc{
      "To return NaN instead, see \"sin\"."),
     {"x"}};
 
-const FunctionDoc cos_doc{
-    "Compute the cosine of the elements argument-wise",
-    ("Integer arguments return double values. "
-     "This function returns NaN on values outside its domain. "
-     "To raise an error instead, see \"cos_checked\"."),
-    {"x"}};
+const FunctionDoc cos_doc{"Compute the cosine of the elements argument-wise",
+                          ("Integer arguments return double values. "
+                           "This function returns NaN on values outside its domain. "
+                           "To raise an error instead, see \"cos_checked\"."),
+                          {"x"}};
 
 const FunctionDoc cos_checked_doc{
     "Compute the cosine of the elements argument-wise",
@@ -1481,12 +1467,11 @@ const FunctionDoc cos_checked_doc{
      "To return NaN instead, see \"cos\"."),
     {"x"}};
 
-const FunctionDoc tan_doc{
-    "Compute the tangent of the elements argument-wise",
-    ("Integer arguments return double values. "
-     "This function returns NaN on values outside its domain. "
-     "To raise an error instead, see \"tan_checked\"."),
-    {"x"}};
+const FunctionDoc tan_doc{"Compute the tangent of the elements argument-wise",
+                          ("Integer arguments return double values. "
+                           "This function returns NaN on values outside its domain. "
+                           "To raise an error instead, see \"tan_checked\"."),
+                          {"x"}};
 
 const FunctionDoc tan_checked_doc{
     "Compute the tangent of the elements argument-wise",
@@ -1495,12 +1480,11 @@ const FunctionDoc tan_checked_doc{
      "To return NaN instead, see \"tan\"."),
     {"x"}};
 
-const FunctionDoc asin_doc{
-    "Compute the inverse sine of the elements argument-wise",
-    ("Integer arguments return double values. "
-     "This function returns NaN on values outside its domain. "
-     "To raise an error instead, see \"asin_checked\"."),
-    {"x"}};
+const FunctionDoc asin_doc{"Compute the inverse sine of the elements argument-wise",
+                           ("Integer arguments return double values. "
+                            "This function returns NaN on values outside its domain. "
+                            "To raise an error instead, see \"asin_checked\"."),
+                           {"x"}};
 
 const FunctionDoc asin_checked_doc{
     "Compute the inverse sine of the elements argument-wise",
@@ -1509,12 +1493,11 @@ const FunctionDoc asin_checked_doc{
      "To return NaN instead, see \"asin\"."),
     {"x"}};
 
-const FunctionDoc acos_doc{
-    "Compute the inverse cosine of the elements argument-wise",
-    ("Integer arguments return double values. "
-     "This function returns NaN on values outside its domain. "
-     "To raise an error instead, see \"acos_checked\"."),
-    {"x"}};
+const FunctionDoc acos_doc{"Compute the inverse cosine of the elements argument-wise",
+                           ("Integer arguments return double values. "
+                            "This function returns NaN on values outside its domain. "
+                            "To raise an error instead, see \"acos_checked\"."),
+                           {"x"}};
 
 const FunctionDoc acos_checked_doc{
     "Compute the inverse cosine of the elements argument-wise",
@@ -1523,10 +1506,9 @@ const FunctionDoc acos_checked_doc{
      "To return NaN instead, see \"acos\"."),
     {"x"}};
 
-const FunctionDoc atan_doc{
-    "Compute the principal value of the inverse tangent",
-    ("Integer arguments return double values."),
-    {"x"}};
+const FunctionDoc atan_doc{"Compute the principal value of the inverse tangent",
+                           ("Integer arguments return double values."),
+                           {"x"}};
 
 const FunctionDoc atan2_doc{
     "Compute the inverse tangent using argument signs to determine the quadrant",

From 9d6a1be5cbfcf4008f16a7180d96b1c49ba73726 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 14 Jul 2021 23:56:54 -0400
Subject: [PATCH 20/23] add support for NaN

---
 .../compute/kernels/scalar_arithmetic.cc      | 37 +++++++++----------
 .../compute/kernels/scalar_arithmetic_test.cc | 24 ++++++------
 2 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 267c2cdf4e5..97d0b2ae4d2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -465,22 +465,18 @@ struct PowerChecked {
 };
 
 struct Sign {
-  template <typename T, typename Arg,
-            enable_if_t<std::is_floating_point<Arg>::value, bool> = true>
-  static constexpr T Call(KernelContext*, Arg arg, Status*) {
-    return (arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1);
+  template <typename T, typename Arg>
+  static constexpr enable_if_floating_point<T> Call(KernelContext*, Arg arg, Status*) {
+    return std::isnan(arg) ? arg : ((arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1));
   }
 
-  template <typename T, typename Arg,
-            enable_if_t<std::is_unsigned<Arg>::value, bool> = true>
-  static constexpr T Call(KernelContext*, Arg arg, Status*) {
+  template <typename T, typename Arg>
+  static constexpr enable_if_unsigned_integer<T> Call(KernelContext*, Arg arg, Status*) {
     return arg > 0;
   }
 
-  template <typename T, typename Arg,
-            enable_if_t<std::is_integral<Arg>::value && std::is_signed<Arg>::value,
-                        bool> = true>
-  static constexpr T Call(KernelContext*, Arg arg, Status*) {
+  template <typename T, typename Arg>
+  static constexpr enable_if_signed_integer<T> Call(KernelContext*, Arg arg, Status*) {
     return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
   }
 };
@@ -1058,7 +1054,7 @@ void AddDecimalBinaryKernels(const std::string& name,
 
 // Generate a kernel given an arithmetic functor
 template <template <typename...> class KernelGenerator, typename OutType, typename Op>
-ArrayKernelExec GenerateArithmeticWithFixedOutType(detail::GetTypeId get_id) {
+ArrayKernelExec GenerateArithmeticWithFixedIntOutType(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
       return KernelGenerator<OutType, Int8Type, Op>::Exec;
@@ -1078,9 +1074,9 @@ ArrayKernelExec GenerateArithmeticWithFixedOutType(detail::GetTypeId get_id) {
     case Type::UINT64:
       return KernelGenerator<OutType, UInt64Type, Op>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<OutType, FloatType, Op>::Exec;
+      return KernelGenerator<FloatType, FloatType, Op>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<OutType, DoubleType, Op>::Exec;
+      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
     default:
       DCHECK(false);
       return ExecFail;
@@ -1197,14 +1193,15 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
 }
 
 // Like MakeUnaryArithmeticFunction, but for unary arithmetic ops with a fixed
-// output type.
-template <typename Op, typename OutType>
-std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionWithFixedOutType(
+// output type for integral inputs.
+template <typename Op, typename IntOutType>
+std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionWithFixedIntOutType(
     std::string name, const FunctionDoc* doc) {
-  auto out_ty = TypeTraits<OutType>::type_singleton();
+  auto int_out_ty = TypeTraits<IntOutType>::type_singleton();
   auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
   for (const auto& ty : NumericTypes()) {
-    auto exec = GenerateArithmeticWithFixedOutType<ScalarUnary, OutType, Op>(ty);
+    auto out_ty = arrow::is_floating(ty->id()) ? ty : int_out_ty;
+    auto exec = GenerateArithmeticWithFixedIntOutType<ScalarUnary, IntOutType, Op>(ty);
     DCHECK_OK(func->AddKernel({ty}, out_ty, exec));
   }
   return func;
@@ -1654,7 +1651,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
 
   // ----------------------------------------------------------------------
   auto sign =
-      MakeUnaryArithmeticFunctionWithFixedOutType<Sign, Int8Type>("sign", &sign_doc);
+      MakeUnaryArithmeticFunctionWithFixedIntOutType<Sign, Int8Type>("sign", &sign_doc);
   DCHECK_OK(registry->AddFunction(std::move(sign)));
 
   // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index bbafdeadf96..cfa6d40004a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -2028,25 +2028,23 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   auto min = std::numeric_limits<CType>::lowest();
   auto max = std::numeric_limits<CType>::max();
 
+  this->SetNansEqual(true);
+
   // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
   // second parameter
   auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
     return Sign(arg, ctx);
   };
 
-  this->AssertUnaryOp(sign, "[]", ArrayFromJSON(int8(), "[]"));
-  this->AssertUnaryOp(sign, "[null]", ArrayFromJSON(int8(), "[null]"));
-  this->AssertUnaryOp(sign, "[1.3, null, -10.80]",
-                      ArrayFromJSON(int8(), "[1, null, -1]"));
-  this->AssertUnaryOp(sign, "[0.0, -0.0]", ArrayFromJSON(int8(), "[0, 0]"));
-  this->AssertUnaryOp(sign, "[1.3, 10.80, 12748.001]",
-                      ArrayFromJSON(int8(), "[1, 1, 1]"));
-  this->AssertUnaryOp(sign, "[-1.3, -10.80, -12748.001]",
-                      ArrayFromJSON(int8(), "[-1, -1, -1]"));
-  this->AssertUnaryOp(sign, "[Inf, -Inf]", ArrayFromJSON(int8(), "[1, -1]"));
-  this->AssertUnaryOp(sign, "[NaN]", ArrayFromJSON(int8(), "[1]"));
-  this->AssertUnaryOp(sign, MakeScalar(min), *arrow::MakeScalar(int8(), -1));
-  this->AssertUnaryOp(sign, MakeScalar(max), *arrow::MakeScalar(int8(), 1));
+  this->AssertUnaryOp(sign, "[]", "[]");
+  this->AssertUnaryOp(sign, "[null]", "[null]");
+  this->AssertUnaryOp(sign, "[1.3, null, -10.80]", "[1, null, -1]");
+  this->AssertUnaryOp(sign, "[0.0, -0.0]", "[0, 0]");
+  this->AssertUnaryOp(sign, "[1.3, 10.80, 12748.001]", "[1, 1, 1]");
+  this->AssertUnaryOp(sign, "[-1.3, -10.80, -12748.001]", "[-1, -1, -1]");
+  this->AssertUnaryOp(sign, "[Inf, -Inf]", "[1, -1]");
+  this->AssertUnaryOp(sign, "[NaN]", "[NaN]");
+  this->AssertUnaryOp(sign, MakeArray(min, max), "[-1, 1]");
 }
 }  // namespace compute
 }  // namespace arrow

From 292a0609b16757c71b895a43891e40e60bf80d1a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 15 Jul 2021 02:42:04 -0400
Subject: [PATCH 21/23] update docs

---
 .../compute/kernels/scalar_arithmetic.cc      |  6 +-
 docs/source/cpp/compute.rst                   | 71 ++++++++++---------
 2 files changed, 40 insertions(+), 37 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 97d0b2ae4d2..28904bdbfa0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1384,8 +1384,10 @@ const FunctionDoc pow_checked_doc{
     {"base", "exponent"}};
 
 const FunctionDoc sign_doc{
-    "Get the sign value of the argument element-wise",
-    ("For nonzero inputs, output is any of (-1,1) and 0 for zero input."),
+    "Get the signedness of the arguments element-wise",
+    ("Output is any of (-1,1) for nonzero inputs and 0 for zero input.\n"
+     "NaN values return NaN.  Integral values return signedness as Int8 and\n"
+     "floating-point values return it with the same type as the input values."),
     {"x"}};
 
 const FunctionDoc bit_wise_not_doc{
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 1b221e0efcb..dc88d9645c3 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -262,39 +262,39 @@ then typically wraps around).  Most functions are also available in an
 overflow-checking variant, suffixed ``_checked``, which returns
 an ``Invalid`` :class:`Status` when overflow is detected.
 
-+------------------+--------+----------------+----------------+-------+
-| Function name    | Arity  | Input types    | Output type    | Notes |
-+==================+========+================+================+=======+
-| abs              | Unary  | Numeric        | Numeric        |       |
-+------------------+--------+----------------+----------------+-------+
-| abs_checked      | Unary  | Numeric        | Numeric        |       |
-+------------------+--------+----------------+----------------+-------+
-| add              | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| add_checked      | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| divide           | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| divide_checked   | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| multiply         | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| multiply_checked | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| negate           | Unary  | Numeric        | Numeric        |       |
-+------------------+--------+----------------+----------------+-------+
-| negate_checked   | Unary  | Signed Numeric | Signed Numeric |       |
-+------------------+--------+----------------+----------------+-------+
-| power            | Binary | Numeric        | Numeric        |       |
-+------------------+--------+----------------+----------------+-------+
-| power_checked    | Binary | Numeric        | Numeric        |       |
-+------------------+--------+----------------+----------------+-------+
-| sign             | Unary  | Numeric        | Int8           | \(2)  |
-+------------------+--------+----------------+----------------+-------+
-| subtract         | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
-| subtract_checked | Binary | Numeric        | Numeric        | \(1)  |
-+------------------+--------+----------------+----------------+-------+
++------------------+--------+----------------+----------------------+-------+
+| Function name    | Arity  | Input types    | Output type          | Notes |
++==================+========+================+======================+=======+
+| abs              | Unary  | Numeric        | Numeric              |       |
++------------------+--------+----------------+----------------------+-------+
+| abs_checked      | Unary  | Numeric        | Numeric              |       |
++------------------+--------+----------------+----------------------+-------+
+| add              | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| add_checked      | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| divide           | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| divide_checked   | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| multiply         | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| multiply_checked | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| negate           | Unary  | Numeric        | Numeric              |       |
++------------------+--------+----------------+----------------------+-------+
+| negate_checked   | Unary  | Signed Numeric | Signed Numeric       |       |
++------------------+--------+----------------+----------------------+-------+
+| power            | Binary | Numeric        | Numeric              |       |
++------------------+--------+----------------+----------------------+-------+
+| power_checked    | Binary | Numeric        | Numeric              |       |
++------------------+--------+----------------+----------------------+-------+
+| sign             | Unary  | Numeric        | Int8/Float32/Float64 | \(2)  |
++------------------+--------+----------------+----------------------+-------+
+| subtract         | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
+| subtract_checked | Binary | Numeric        | Numeric              | \(1)  |
++------------------+--------+----------------+----------------------+-------+
 
 * \(1) Precision and scale of computed DECIMAL results
 
@@ -317,8 +317,9 @@ an ``Invalid`` :class:`Status` when overflow is detected.
   enough scale kept. Error is returned if the result precision is beyond the
   decimal value range.
 
-* \(2) Output is an integral representing the signedness of the input.
-  For nonzero inputs, output is any of (-1,1) and 0 for zero input.
+* \(2) Output is any of (-1,1) for nonzero inputs and 0 for zero input.
+  NaN values return NaN.  Integral values return signedness as Int8 and
+  floating-point values return it with the same type as the input values.
 
 Bit-wise functions
 ~~~~~~~~~~~~~~~~~~

From f0990341d8b0e8b40d1003ffaf87cd9c8592fb32 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 15 Jul 2021 11:14:21 -0400
Subject: [PATCH 22/23] change MakeArray to MakeScalar to bypass RapidJSON
 'Number too big' error

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index cfa6d40004a..cea07926af8 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -2001,7 +2001,8 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
   this->AssertUnaryOp(sign, "[0]", ArrayFromJSON(int8(), "[0]"));
   this->AssertUnaryOp(sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
   this->AssertUnaryOp(sign, "[-1, -10, -127]", ArrayFromJSON(int8(), "[-1, -1, -1]"));
-  this->AssertUnaryOp(sign, MakeArray(min, max), ArrayFromJSON(int8(), "[-1, 1]"));
+  this->AssertUnaryOp(sign, this->MakeScalar(min), *arrow::MakeScalar(int8(), -1));
+  this->AssertUnaryOp(sign, this->MakeScalar(max), *arrow::MakeScalar(int8(), 1));
 }
 
 TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
@@ -2020,7 +2021,8 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
   this->AssertUnaryOp(sign, "[1, null, 10]", ArrayFromJSON(int8(), "[1, null, 1]"));
   this->AssertUnaryOp(sign, "[0]", ArrayFromJSON(int8(), "[0]"));
   this->AssertUnaryOp(sign, "[1, 10, 127]", ArrayFromJSON(int8(), "[1, 1, 1]"));
-  this->AssertUnaryOp(sign, MakeArray(min, max), ArrayFromJSON(int8(), "[0, 1]"));
+  this->AssertUnaryOp(sign, this->MakeScalar(min), *arrow::MakeScalar(int8(), 0));
+  this->AssertUnaryOp(sign, this->MakeScalar(max), *arrow::MakeScalar(int8(), 1));
 }
 
 TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
@@ -2044,7 +2046,8 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
   this->AssertUnaryOp(sign, "[-1.3, -10.80, -12748.001]", "[-1, -1, -1]");
   this->AssertUnaryOp(sign, "[Inf, -Inf]", "[1, -1]");
   this->AssertUnaryOp(sign, "[NaN]", "[NaN]");
-  this->AssertUnaryOp(sign, MakeArray(min, max), "[-1, 1]");
+  this->AssertUnaryOp(sign, this->MakeScalar(min), this->MakeScalar(-1));
+  this->AssertUnaryOp(sign, this->MakeScalar(max), this->MakeScalar(1));
 }
 }  // namespace compute
 }  // namespace arrow

From ea19dc6ccad5529d2ecf42bccd3438d482578bd2 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 15 Jul 2021 12:28:04 -0400
Subject: [PATCH 23/23] change XXX comment tag to N.B.

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index cea07926af8..a495b00a171 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -1989,7 +1989,7 @@ TYPED_TEST(TestUnaryArithmeticSigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
+  // N.B. TestUnaryArithmetic expects a function with ArithmeticOptions as its
   // second parameter
   auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
     return Sign(arg, ctx);
@@ -2010,7 +2010,7 @@ TYPED_TEST(TestUnaryArithmeticUnsigned, Sign) {
   auto min = std::numeric_limits<CType>::min();
   auto max = std::numeric_limits<CType>::max();
 
-  // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
+  // N.B. TestUnaryArithmetic expects a function with ArithmeticOptions as its
   // second parameter
   auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
     return Sign(arg, ctx);
@@ -2032,7 +2032,7 @@ TYPED_TEST(TestUnaryArithmeticFloating, Sign) {
 
   this->SetNansEqual(true);
 
-  // XXX TestUnaryArithmetic expects a function with ArithmeticOptions as its
+  // N.B. TestUnaryArithmetic expects a function with ArithmeticOptions as its
   // second parameter
   auto sign = [](const Datum& arg, ArithmeticOptions, ExecContext* ctx) {
     return Sign(arg, ctx);