From d27218e1cdb53ac49dadb946c6feda7a32371004 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 29 Mar 2021 22:01:11 +0200
Subject: [PATCH 01/21] Adding exponentiation kernel.

---
 cpp/src/arrow/compute/api_scalar.cc           |  1 +
 cpp/src/arrow/compute/api_scalar.h            | 14 ++++
 .../compute/kernels/scalar_arithmetic.cc      | 61 +++++++++++++++
 .../compute/kernels/scalar_arithmetic_test.cc | 78 ++++++++++++++++++-
 4 files changed, 153 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index f4696fbe02a..0ede1bf6502 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -52,6 +52,7 @@ SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
 SCALAR_ARITHMETIC_BINARY(Subtract, "subtract", "subtract_checked")
 SCALAR_ARITHMETIC_BINARY(Multiply, "multiply", "multiply_checked")
 SCALAR_ARITHMETIC_BINARY(Divide, "divide", "divide_checked")
+SCALAR_ARITHMETIC_BINARY(Exponentiate, "exponentiate", "exponentiate_checked")
 
 // ----------------------------------------------------------------------
 // Set-related operations
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index f59426d8f1b..66b59573e57 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -204,6 +204,20 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
                      ArithmeticOptions options = ArithmeticOptions(),
                      ExecContext* ctx = NULLPTR);
 
+/// \brief Compute the value of base value to the power of the exponent value.
+/// Array values must be the same length. If either argument is null the result will be
+/// null. For integer types, if there is a zero base value, an error will be raised.
+///
+/// \param[in] left the base
+/// \param[in] right the exponent
+/// \param[in] options arithmetic options (enable/disable overflow checking), optional
+/// \param[in] ctx the function execution context, optional
+/// \return the elementwise quotient
+ARROW_EXPORT
+Result<Datum> Exponentiate(const Datum& left, const Datum& right,
+                           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 7abaa1c1a59..2e8b605451e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -18,11 +18,13 @@
 #include "arrow/compute/kernels/common.h"
 #include "arrow/util/int_util_internal.h"
 #include "arrow/util/macros.h"
+#include "math.h"
 
 namespace arrow {
 
 using internal::AddWithOverflow;
 using internal::DivideWithOverflow;
+// using internal::ExponentiateWithOverflow;
 using internal::MultiplyWithOverflow;
 using internal::SubtractWithOverflow;
 
@@ -233,6 +235,41 @@ struct DivideChecked {
   }
 };
 
+struct Exponentiate {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    if (left == 0 && (-INFINITY < right && right < 0)) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    return pow(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    return pow(left, right);
+  }
+};
+
+struct ExponentiateChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    if (left == 0 && (-INFINITY < right && right < 0)) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    return pow(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    if (left == 0 && (-INFINITY < right && right < 0)) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    return pow(left, right);
+  }
+};
+
 // Generate a kernel given an arithmetic functor
 template <template <typename... Args> class KernelGenerator, typename Op>
 ArrayKernelExec NumericEqualTypesBinary(detail::GetTypeId get_id) {
@@ -359,6 +396,20 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"dividend", "divisor"}};
 
+const FunctionDoc exp_doc{
+    "Exponentiate the arguments element-wise",
+    ("Integer division by zero returns an error. However, integer overflow\n"
+     "wraps around, and floating-point division by zero returns an infinite.\n"
+     "Use function \"divide_checked\" if you want to get an error\n"
+     "in all the aforementioned cases."),
+    {"base", "power"}};
+
+const FunctionDoc exp_checked_doc{
+    "Exponentiate the arguments element-wise",
+    ("An error is returned when trying to divide by zero, or when\n"
+     "integer overflow is encountered."),
+    {"base", "power"}};
+
 }  // namespace
 
 void RegisterScalarArithmetic(FunctionRegistry* registry) {
@@ -407,6 +458,16 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   auto divide_checked =
       MakeArithmeticFunctionNotNull<DivideChecked>("divide_checked", &div_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
+
+  // ----------------------------------------------------------------------
+  auto exponentiate =
+      MakeArithmeticFunctionNotNull<Exponentiate>("exponentiate", &exp_doc);
+  DCHECK_OK(registry->AddFunction(std::move(exponentiate)));
+
+  // ----------------------------------------------------------------------
+  auto exponentiate_checked = MakeArithmeticFunctionNotNull<ExponentiateChecked>(
+      "exponentiate_checked", &exp_checked_doc);
+  DCHECK_OK(registry->AddFunction(std::move(exponentiate_checked)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 4d4f14e1154..9a2c2effcc9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -590,6 +590,82 @@ TYPED_TEST(TestBinaryArithmeticSigned, DivideOverflowRaises) {
   this->AssertBinop(Divide, MakeArray(min), MakeArray(-1), "[0]");
 }
 
+TYPED_TEST(TestBinaryArithmeticFloating, Exponentiate) {
+  for (auto check_overflow : {false, true}) {
+    this->SetOverflowCheck(check_overflow);
+
+    // Empty arrays
+    this->AssertBinop(Exponentiate, "[]", "[]", "[]");
+    // Ordinary arrays
+    this->AssertBinop(Exponentiate, "[3.4, 16, 0.64, 1.2, 0]", "[1, 0.5, 2, 4, 0]",
+                      "[3.4, 4, 0.4096, 2.0736, 1]");
+    // Array with nulls
+    this->AssertBinop(Exponentiate, "[null, 1, 3.3, null, 2]", "[1, 4, 2, 5, 0.1]",
+                      "[null, 1, 10.89, null, 1.07177346]");
+    // Scalar exponentiated by array
+    this->AssertBinop(Exponentiate, 10.0F, "[null, 1, 2.5, null, 2, 5]",
+                      "[null, 10, 316.227766017, null, 100, 100000]");
+    // Array exponentiated by scalar
+    this->AssertBinop(Exponentiate, "[null, 1, 2.5, null, 2, 5]", 10.0F,
+                      "[null, 1, 9536.74316406, null, 1024, 9765625]");
+    // Array with infinity
+    this->AssertBinop(Exponentiate, "[3.4, Inf, -Inf, 1.1]", "[1, 2, 3, Inf]",
+                      "[3.4, Inf, -Inf, Inf]");
+    // Array with NaN
+    this->SetNansEqual(true);
+    this->AssertBinop(Exponentiate, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
+    // Scalar exponentiated by scalar
+    this->AssertBinop(Exponentiate, 21.0F, 3.0F, 9261.0F);
+  }
+}
+
+TYPED_TEST(TestBinaryArithmeticIntegral, Exponentiate) {
+  for (auto check_overflow : {false, true}) {
+    this->SetOverflowCheck(check_overflow);
+
+    // Empty arrays
+    this->AssertBinop(Exponentiate, "[]", "[]", "[]");
+    // Ordinary arrays
+    this->AssertBinop(Exponentiate, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
+    // Array with nulls
+    this->AssertBinop(Exponentiate, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
+                      "[null, 64, 9, null, 20]");
+    // Scalar exponentiated by array
+    this->AssertBinop(Exponentiate, 3, "[null, 3, 4, null, 2]",
+                      "[null, 27, 81, null, 9]");
+    // Array exponentiated by scalar
+    this->AssertBinop(Exponentiate, "[null, 10, 3, null, 2]", 2,
+                      "[null, 100, 9, null, 4]");
+    // Scalar exponentiated by scalar
+    this->AssertBinop(Exponentiate, 6, 3, 216);
+  }
+}
+
+TYPED_TEST(TestBinaryArithmeticSigned, Exponentiate) {
+  // Ordinary arrays
+  this->AssertBinop(Exponentiate, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
+  // Array with nulls
+  this->AssertBinop(Exponentiate, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
+                    "[null, 100, 0, null, -20]");
+  // Scalar divides by array
+  this->AssertBinop(Exponentiate, 11, "[null, -1, -3, null, 2]",
+                    "[null, 0, 0, null, 121]");
+  // Array divides by scalar
+  this->AssertBinop(Exponentiate, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
+  // Scalar divides by scalar
+  this->AssertBinop(Exponentiate, 16, .5, 1);
+}
+
+TYPED_TEST(TestBinaryArithmeticFloating, BaseZeroToNegativePower) {
+  this->SetOverflowCheck(true);
+  this->AssertBinopRaises(Exponentiate, MakeArray(0), MakeArray(-1), "divide by zero");
+
+  this->SetOverflowCheck(false);
+  this->SetNansEqual(true);
+  this->AssertBinop(Exponentiate, "[-0.0, 0.0, 0.0]", "[-1.0, -2.0, -1.0]",
+                    "[-Inf, Inf, Inf]");
+}
+
 TYPED_TEST(TestBinaryArithmeticFloating, Sub) {
   this->AssertBinop(Subtract, "[]", "[]", "[]");
 
@@ -638,7 +714,7 @@ TYPED_TEST(TestBinaryArithmeticFloating, Mul) {
 }
 
 TEST(TestBinaryArithmetic, DispatchBest) {
-  for (std::string name : {"add", "subtract", "multiply", "divide"}) {
+  for (std::string name : {"add", "subtract", "multiply", "divide", "exponentiate"}) {
     for (std::string suffix : {"", "_checked"}) {
       name += suffix;
 

From 15a5bd4d03bd6da8098484ef914cb475e4fc15ae Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 31 Mar 2021 04:03:55 +0200
Subject: [PATCH 02/21] Renaming factorize to power, changing power for
 integers.

---
 cpp/src/arrow/compute/api_scalar.cc           |   2 +-
 cpp/src/arrow/compute/api_scalar.h            |  16 +-
 .../compute/kernels/scalar_arithmetic.cc      | 298 +++++++++++++++++-
 .../compute/kernels/scalar_arithmetic_test.cc | 105 +++---
 4 files changed, 355 insertions(+), 66 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 0ede1bf6502..d169fd2ebde 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -52,7 +52,7 @@ SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
 SCALAR_ARITHMETIC_BINARY(Subtract, "subtract", "subtract_checked")
 SCALAR_ARITHMETIC_BINARY(Multiply, "multiply", "multiply_checked")
 SCALAR_ARITHMETIC_BINARY(Divide, "divide", "divide_checked")
-SCALAR_ARITHMETIC_BINARY(Exponentiate, "exponentiate", "exponentiate_checked")
+SCALAR_ARITHMETIC_BINARY(Power, "power", "power_checked")
 
 // ----------------------------------------------------------------------
 // Set-related operations
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 66b59573e57..ddda637d6d6 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -38,8 +38,9 @@ namespace compute {
 /// @{
 
 struct ArithmeticOptions : public FunctionOptions {
-  ArithmeticOptions() : check_overflow(false) {}
+  ArithmeticOptions() : check_overflow(false), remove_nulls(false) {}
   bool check_overflow;
+  bool remove_nulls;
 };
 
 struct ARROW_EXPORT MatchSubstringOptions : public FunctionOptions {
@@ -206,17 +207,18 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
 
 /// \brief Compute the value of base value to the power of the exponent value.
 /// Array values must be the same length. If either argument is null the result will be
-/// null. For integer types, if there is a zero base value, an error will be raised.
+/// null. For integer types, if there is a zero base value with negative value, a divide
+/// by zero error will be raised.
 ///
 /// \param[in] left the base
 /// \param[in] right the exponent
-/// \param[in] options arithmetic options (enable/disable overflow checking), optional
+/// \param[in] options arithmetic options (enable/disable overflow checking and null removal), optional
 /// \param[in] ctx the function execution context, optional
-/// \return the elementwise quotient
+/// \return the elementwise base value raised to the power of exponent
 ARROW_EXPORT
-Result<Datum> Exponentiate(const Datum& left, const Datum& right,
-                           ArithmeticOptions options = ArithmeticOptions(),
-                           ExecContext* ctx = NULLPTR);
+Result<Datum> Power(const Datum& left, const Datum& right,
+                    ArithmeticOptions options = ArithmeticOptions(),
+                    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 2e8b605451e..953ef9d2a5f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -15,16 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cmath>
+
 #include "arrow/compute/kernels/common.h"
 #include "arrow/util/int_util_internal.h"
 #include "arrow/util/macros.h"
-#include "math.h"
 
 namespace arrow {
 
 using internal::AddWithOverflow;
 using internal::DivideWithOverflow;
-// using internal::ExponentiateWithOverflow;
 using internal::MultiplyWithOverflow;
 using internal::SubtractWithOverflow;
 
@@ -235,13 +235,64 @@ struct DivideChecked {
   }
 };
 
-struct Exponentiate {
+struct Power {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (left == 0 && (-INFINITY < right && right < 0)) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right < 0) {
+        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+        ctx->SetStatus(Status::Invalid("divide by zero"));
+        return result;
+      } else if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && abs(left) > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      return result;
+    } else if (right == -INFINITY && abs(left) > 1) {
+      return 0;
     }
-    return pow(left, right);
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    } else {
+      for (Arg1 i = 0; i < -right; i++) {
+        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && left > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      ctx->SetStatus(Status::Invalid("overflow"));
+      return result;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
   }
 
   template <typename T, typename Arg0, typename Arg1>
@@ -250,15 +301,205 @@ struct Exponentiate {
   }
 };
 
-struct ExponentiateChecked {
+struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right < 0) {
+        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+        ctx->SetStatus(Status::Invalid("divide by zero"));
+        return result;
+      } else if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && abs(left) > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      return result;
+    } else if (right == -INFINITY && abs(left) > 1) {
+      return 0;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    } else {
+      for (Arg1 i = 0; i < -right; i++) {
+        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && left > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      ctx->SetStatus(Status::Invalid("overflow"));
+      return result;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     if (left == 0 && (-INFINITY < right && right < 0)) {
       ctx->SetStatus(Status::Invalid("divide by zero"));
     }
     return pow(left, right);
   }
+};
+
+struct PowerRemoveNulls {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right < 0) {
+        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+        ctx->SetStatus(Status::Invalid("divide by zero"));
+        return result;
+      } else if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && abs(left) > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      return result;
+    } else if (right == -INFINITY && abs(left) > 1) {
+      return 0;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    } else {
+      for (Arg1 i = 0; i < -right; i++) {
+        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && left > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      ctx->SetStatus(Status::Invalid("overflow"));
+      return result;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    return pow(left, right);
+  }
+};
+
+struct PowerCheckedRemoveNulls {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right < 0) {
+        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+        ctx->SetStatus(Status::Invalid("divide by zero"));
+        return result;
+      } else if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && abs(left) > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      return result;
+    } else if (right == -INFINITY && abs(left) > 1) {
+      return 0;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    } else {
+      for (Arg1 i = 0; i < -right; i++) {
+        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    Arg0 result = 1;
+    if (left == 0) {
+      if (right == 0) {
+        return 1;
+      }
+      return 0;
+    } else if (right == INFINITY && left > 1) {
+      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
+      ctx->SetStatus(Status::Invalid("overflow"));
+      return result;
+    }
+
+    if (right > 0) {
+      for (Arg1 i = 0; i < right; i++) {
+        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+          ctx->SetStatus(Status::Invalid("overflow"));
+        }
+      }
+    }
+    return result;
+  }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
@@ -396,7 +637,7 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"dividend", "divisor"}};
 
-const FunctionDoc exp_doc{
+const FunctionDoc pow_doc{
     "Exponentiate the arguments element-wise",
     ("Integer division by zero returns an error. However, integer overflow\n"
      "wraps around, and floating-point division by zero returns an infinite.\n"
@@ -404,7 +645,21 @@ const FunctionDoc exp_doc{
      "in all the aforementioned cases."),
     {"base", "power"}};
 
-const FunctionDoc exp_checked_doc{
+const FunctionDoc pow_checked_doc{
+    "Exponentiate the arguments element-wise",
+    ("An error is returned when trying to divide by zero, or when\n"
+     "integer overflow is encountered."),
+    {"base", "power"}};
+
+const FunctionDoc pow_remove_nulls_doc{
+    "Exponentiate the arguments element-wise",
+    ("Integer division by zero returns an error. However, integer overflow\n"
+     "wraps around, and floating-point division by zero returns an infinite.\n"
+     "Use function \"divide_checked\" if you want to get an error\n"
+     "in all the aforementioned cases."),
+    {"base", "power"}};
+
+const FunctionDoc pow_checked_remove_nulls_doc{
     "Exponentiate the arguments element-wise",
     ("An error is returned when trying to divide by zero, or when\n"
      "integer overflow is encountered."),
@@ -460,14 +715,23 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto exponentiate =
-      MakeArithmeticFunctionNotNull<Exponentiate>("exponentiate", &exp_doc);
-  DCHECK_OK(registry->AddFunction(std::move(exponentiate)));
+  auto power =
+      MakeArithmeticFunctionNotNull<Power>("power", &pow_doc);
+  DCHECK_OK(registry->AddFunction(std::move(power)));
+
+  // ----------------------------------------------------------------------
+  auto power_checked = MakeArithmeticFunctionNotNull<PowerChecked>("power_checked", &pow_checked_doc);
+  DCHECK_OK(registry->AddFunction(std::move(power_checked)));
+
+  // ----------------------------------------------------------------------
+  auto power_remove_nulls =
+      MakeArithmeticFunctionNotNull<PowerRemoveNulls>("power_remove_nulls", &pow_remove_nulls_doc);
+  DCHECK_OK(registry->AddFunction(std::move(power_remove_nulls)));
 
   // ----------------------------------------------------------------------
-  auto exponentiate_checked = MakeArithmeticFunctionNotNull<ExponentiateChecked>(
-      "exponentiate_checked", &exp_checked_doc);
-  DCHECK_OK(registry->AddFunction(std::move(exponentiate_checked)));
+  auto power_checked_remove_nulls = MakeArithmeticFunctionNotNull<PowerCheckedRemoveNulls>(
+      "power_checked_remove_nulls", &pow_checked_remove_nulls_doc);
+  DCHECK_OK(registry->AddFunction(std::move(power_checked_remove_nulls)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 9a2c2effcc9..7e5edd3e33e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -171,6 +171,8 @@ class TestBinaryArithmetic : public TestBase {
 
   void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
 
+  void SetRemoveNulls(bool value = false) { options_.remove_nulls = value; }
+
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
   }
@@ -590,82 +592,103 @@ TYPED_TEST(TestBinaryArithmeticSigned, DivideOverflowRaises) {
   this->AssertBinop(Divide, MakeArray(min), MakeArray(-1), "[0]");
 }
 
-TYPED_TEST(TestBinaryArithmeticFloating, Exponentiate) {
+TYPED_TEST(TestBinaryArithmeticFloating, Power) {
   for (auto check_overflow : {false, true}) {
-    this->SetOverflowCheck(check_overflow);
-
-    // Empty arrays
-    this->AssertBinop(Exponentiate, "[]", "[]", "[]");
-    // Ordinary arrays
-    this->AssertBinop(Exponentiate, "[3.4, 16, 0.64, 1.2, 0]", "[1, 0.5, 2, 4, 0]",
-                      "[3.4, 4, 0.4096, 2.0736, 1]");
-    // Array with nulls
-    this->AssertBinop(Exponentiate, "[null, 1, 3.3, null, 2]", "[1, 4, 2, 5, 0.1]",
-                      "[null, 1, 10.89, null, 1.07177346]");
-    // Scalar exponentiated by array
-    this->AssertBinop(Exponentiate, 10.0F, "[null, 1, 2.5, null, 2, 5]",
-                      "[null, 10, 316.227766017, null, 100, 100000]");
-    // Array exponentiated by scalar
-    this->AssertBinop(Exponentiate, "[null, 1, 2.5, null, 2, 5]", 10.0F,
-                      "[null, 1, 9536.74316406, null, 1024, 9765625]");
-    // Array with infinity
-    this->AssertBinop(Exponentiate, "[3.4, Inf, -Inf, 1.1]", "[1, 2, 3, Inf]",
-                      "[3.4, Inf, -Inf, Inf]");
-    // Array with NaN
-    this->SetNansEqual(true);
-    this->AssertBinop(Exponentiate, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
-    // Scalar exponentiated by scalar
-    this->AssertBinop(Exponentiate, 21.0F, 3.0F, 9261.0F);
+    for (auto remove_nulls : {false, true}) {
+      this->SetOverflowCheck(check_overflow);
+      this->SetRemoveNulls(remove_nulls);
+
+      // Empty arrays
+      this->AssertBinop(Power, "[]", "[]", "[]");
+      // Ordinary arrays
+      this->AssertBinop(Power, "[3.4, 16, 0.64, 1.2, 0]", "[1, 0.5, 2, 4, 0]",
+                        "[3.4, 4, 0.4096, 2.0736, 1]");
+      // Array with nulls
+      this->AssertBinop(Power, "[null, 1, 3.3, null, 2]", "[1, 4, 2, 5, 0.1]",
+                        "[null, 1, 10.89, null, 1.07177346]");
+      // Scalar exponentiated by array
+      this->AssertBinop(Power, 10.0F, "[null, 1, 2.5, null, 2, 5]",
+                        "[null, 10, 316.227766017, null, 100, 100000]");
+      // Array exponentiated by scalar
+      this->AssertBinop(Power, "[null, 1, 2.5, null, 2, 5]", 10.0F,
+                        "[null, 1, 9536.74316406, null, 1024, 9765625]");
+      // Array with infinity
+      this->AssertBinop(Power, "[3.4, Inf, -Inf, 1.1]", "[1, 2, 3, Inf]",
+                        "[3.4, Inf, -Inf, Inf]");
+      // Array with NaN
+      this->SetNansEqual(true);
+      this->AssertBinop(Power, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
+      // Scalar exponentiated by scalar
+      this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
+    }
   }
 }
 
-TYPED_TEST(TestBinaryArithmeticIntegral, Exponentiate) {
+TYPED_TEST(TestBinaryArithmeticIntegral, Power) {
   for (auto check_overflow : {false, true}) {
     this->SetOverflowCheck(check_overflow);
 
     // Empty arrays
-    this->AssertBinop(Exponentiate, "[]", "[]", "[]");
+    this->AssertBinop(Power, "[]", "[]", "[]");
     // Ordinary arrays
-    this->AssertBinop(Exponentiate, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
+    this->AssertBinop(Power, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
     // Array with nulls
-    this->AssertBinop(Exponentiate, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
+    this->AssertBinop(Power, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
                       "[null, 64, 9, null, 20]");
     // Scalar exponentiated by array
-    this->AssertBinop(Exponentiate, 3, "[null, 3, 4, null, 2]",
+    this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]",
                       "[null, 27, 81, null, 9]");
     // Array exponentiated by scalar
-    this->AssertBinop(Exponentiate, "[null, 10, 3, null, 2]", 2,
+    this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2,
                       "[null, 100, 9, null, 4]");
     // Scalar exponentiated by scalar
-    this->AssertBinop(Exponentiate, 6, 3, 216);
+    this->AssertBinop(Power, 4, 3, 64);
   }
 }
 
-TYPED_TEST(TestBinaryArithmeticSigned, Exponentiate) {
+TYPED_TEST(TestBinaryArithmeticSigned, Power) {
   // Ordinary arrays
-  this->AssertBinop(Exponentiate, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
+  this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
   // Array with nulls
-  this->AssertBinop(Exponentiate, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
+  this->AssertBinop(Power, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
                     "[null, 100, 0, null, -20]");
   // Scalar divides by array
-  this->AssertBinop(Exponentiate, 11, "[null, -1, -3, null, 2]",
+  this->AssertBinop(Power, 11, "[null, -1, -3, null, 2]",
                     "[null, 0, 0, null, 121]");
   // Array divides by scalar
-  this->AssertBinop(Exponentiate, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
+  this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
   // Scalar divides by scalar
-  this->AssertBinop(Exponentiate, 16, .5, 1);
+  this->AssertBinop(Power, 16, .5, 1);
+
+  // Correctnes
+  this->AssertBinop(Power, "[0, 0, 0]", "[100, 0, 0]", "[0, 1, 1]");
 }
 
 TYPED_TEST(TestBinaryArithmeticFloating, BaseZeroToNegativePower) {
   this->SetOverflowCheck(true);
-  this->AssertBinopRaises(Exponentiate, MakeArray(0), MakeArray(-1), "divide by zero");
+  this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1), "divide by zero");
 
   this->SetOverflowCheck(false);
   this->SetNansEqual(true);
-  this->AssertBinop(Exponentiate, "[-0.0, 0.0, 0.0]", "[-1.0, -2.0, -1.0]",
+  this->AssertBinop(Power, "[-0.0, 0.0, 0.0]", "[-1.0, -2.0, -1.0]",
                     "[-Inf, Inf, Inf]");
 }
 
+TYPED_TEST(TestBinaryArithmeticSigned, PowerOverflowRaises) {
+  using CType = typename TestFixture::CType;
+  auto min = std::numeric_limits<CType>::lowest();
+  auto max = std::numeric_limits<CType>::max();
+
+  this->SetOverflowCheck(true);
+  this->AssertBinopRaises(Power, MakeArray(max), MakeArray(2), "overflow");
+//  this->AssertBinopRaises(Power, MakeArray(-min), MakeArray(-3), "overflow");
+
+  this->SetOverflowCheck(false);
+  this->AssertBinopRaises(Power, MakeArray(max), MakeArray(2), "overflow");
+//  this->AssertBinopRaises(Power, MakeArray(-min), MakeArray(-3), "overflow");
+  this->AssertBinop(Divide, MakeArray(min), MakeArray(-1), "[0]");
+}
+
 TYPED_TEST(TestBinaryArithmeticFloating, Sub) {
   this->AssertBinop(Subtract, "[]", "[]", "[]");
 
@@ -714,7 +737,7 @@ TYPED_TEST(TestBinaryArithmeticFloating, Mul) {
 }
 
 TEST(TestBinaryArithmetic, DispatchBest) {
-  for (std::string name : {"add", "subtract", "multiply", "divide", "exponentiate"}) {
+  for (std::string name : {"add", "subtract", "multiply", "divide", "power"}) {
     for (std::string suffix : {"", "_checked"}) {
       name += suffix;
 

From bc7a787460f770f521d467608fb1e8e3b256f78f Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 1 Apr 2021 04:02:39 +0200
Subject: [PATCH 03/21] Some fixes.

---
 cpp/src/arrow/compute/api_scalar.cc           |  11 +-
 .../compute/kernels/scalar_arithmetic.cc      | 198 ++++++------------
 .../compute/kernels/scalar_arithmetic_test.cc | 125 ++++++-----
 3 files changed, 138 insertions(+), 196 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index d169fd2ebde..eb9671e6edb 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -41,11 +41,12 @@ namespace compute {
 // ----------------------------------------------------------------------
 // Arithmetic
 
-#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)           \
-  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options, \
-                     ExecContext* ctx) {                                               \
-    auto func_name = (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME; \
-    return CallFunction(func_name, {left, right}, ctx);                                \
+#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)                  \
+  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options,        \
+                     ExecContext* ctx) {                                                      \
+    std::string func_name = (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME; \
+    func_name = (options.remove_nulls) ? func_name + "_remove_nulls" : func_name + "";        \
+    return CallFunction(func_name, {left, right}, ctx);                                       \
   }
 
 SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 953ef9d2a5f..82ce69d79bf 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -238,34 +238,20 @@ struct DivideChecked {
 struct Power {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right < 0) {
-        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-        ctx->SetStatus(Status::Invalid("divide by zero"));
-        return result;
-      } else if (right == 0) {
-        return 1;
-      }
-      return 0;
-    } else if (right == INFINITY && abs(left) > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      return result;
-    } else if (right == -INFINITY && abs(left) > 1) {
+    if (left == 0 && right < 0) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    if (left == 0 && right != 0) {
       return 0;
     }
-
+    Arg0 result = 1;
     if (right > 0) {
       for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+        result *= left;
       }
     } else {
       for (Arg1 i = 0; i < -right; i++) {
-        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+        result /= left;
       }
     }
     return result;
@@ -273,30 +259,24 @@ struct Power {
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right == 0) {
-        return 1;
-      }
+    if (left == 0 && right != 0) {
       return 0;
-    } else if (right == INFINITY && left > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      ctx->SetStatus(Status::Invalid("overflow"));
-      return result;
     }
-
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
-      }
+    Arg0 result = 1;
+    for (Arg1 i = 0; i < right; i++) {
+      result *= left;
     }
     return result;
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    if (isnan(left) || isnan(right)) {
+      return NAN;
+    }
+    if (left == 0 && right < 0) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
     return pow(left, right);
   }
 };
@@ -305,23 +285,13 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right < 0) {
-        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-        ctx->SetStatus(Status::Invalid("divide by zero"));
-        return result;
-      } else if (right == 0) {
-        return 1;
-      }
-      return 0;
-    } else if (right == INFINITY && abs(left) > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      return result;
-    } else if (right == -INFINITY && abs(left) > 1) {
+    if (left == 0 && right < 0) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    if (left == 0 && right != 0) {
       return 0;
     }
-
+    Arg0 result = 1;
     if (right > 0) {
       for (Arg1 i = 0; i < right; i++) {
         if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
@@ -341,23 +311,13 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right == 0) {
-        return 1;
-      }
+    if (left == 0 && right != 0) {
       return 0;
-    } else if (right == INFINITY && left > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      ctx->SetStatus(Status::Invalid("overflow"));
-      return result;
     }
-
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+    Arg0 result = 1;
+    for (Arg1 i = 0; i < right; i++) {
+      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+        ctx->SetStatus(Status::Invalid("overflow"));
       }
     }
     return result;
@@ -366,7 +326,10 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && (-INFINITY < right && right < 0)) {
+    if (isnan(left) || isnan(right)) {
+      return NAN;
+    }
+    if (left == 0 && right < 0) {
       ctx->SetStatus(Status::Invalid("divide by zero"));
     }
     return pow(left, right);
@@ -376,34 +339,20 @@ struct PowerChecked {
 struct PowerRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right < 0) {
-        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-        ctx->SetStatus(Status::Invalid("divide by zero"));
-        return result;
-      } else if (right == 0) {
-        return 1;
-      }
-      return 0;
-    } else if (right == INFINITY && abs(left) > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      return result;
-    } else if (right == -INFINITY && abs(left) > 1) {
+    if (left == 0 && right < 0) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    if (left == 0 && right != 0) {
       return 0;
     }
-
+    Arg0 result = 1;
     if (right > 0) {
       for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+        result *= left;
       }
     } else {
       for (Arg1 i = 0; i < -right; i++) {
-        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+        result /= left;
       }
     }
     return result;
@@ -411,30 +360,24 @@ struct PowerRemoveNulls {
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right == 0) {
-        return 1;
-      }
+    if (left == 0 && right != 0) {
       return 0;
-    } else if (right == INFINITY && left > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      ctx->SetStatus(Status::Invalid("overflow"));
-      return result;
     }
-
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
-      }
+    Arg0 result = 1;
+    for (Arg1 i = 0; i < right; i++) {
+      result *= left;
     }
     return result;
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    if (left == 0 && right < 0) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    if (left == 0 && right != 0) {
+      return 0;
+    }
     return pow(left, right);
   }
 };
@@ -443,23 +386,13 @@ struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right < 0) {
-        ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-        ctx->SetStatus(Status::Invalid("divide by zero"));
-        return result;
-      } else if (right == 0) {
-        return 1;
-      }
-      return 0;
-    } else if (right == INFINITY && abs(left) > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      return result;
-    } else if (right == -INFINITY && abs(left) > 1) {
+    if (left == 0 && right < 0) {
+      ctx->SetStatus(Status::Invalid("divide by zero"));
+    }
+    if (left == 0 && right != 0) {
       return 0;
     }
-
+    Arg0 result = 1;
     if (right > 0) {
       for (Arg1 i = 0; i < right; i++) {
         if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
@@ -479,23 +412,13 @@ struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    Arg0 result = 1;
-    if (left == 0) {
-      if (right == 0) {
-        return 1;
-      }
+    if (left == 0 && right != 0) {
       return 0;
-    } else if (right == INFINITY && left > 1) {
-      ARROW_PREDICT_FALSE(MultiplyWithOverflow(2, std::numeric_limits<Arg0>::max(), &result));
-      ctx->SetStatus(Status::Invalid("overflow"));
-      return result;
     }
-
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+    Arg0 result = 1;
+    for (Arg1 i = 0; i < right; i++) {
+      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+        ctx->SetStatus(Status::Invalid("overflow"));
       }
     }
     return result;
@@ -504,9 +427,12 @@ struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && (-INFINITY < right && right < 0)) {
+    if (left == 0 && right < 0) {
       ctx->SetStatus(Status::Invalid("divide by zero"));
     }
+    if (left == 0 && right != 0) {
+      return 0;
+    }
     return pow(left, right);
   }
 };
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 7e5edd3e33e..77ee14fb698 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -67,7 +67,7 @@ class TestBinaryArithmetic : public TestBase {
   using BinaryFunction = std::function<Result<Datum>(const Datum&, const Datum&,
                                                      ArithmeticOptions, ExecContext*)>;
 
-  void SetUp() override { options_.check_overflow = false; }
+  void SetUp() override { options_.check_overflow = false; options_.remove_nulls = false; }
 
   std::shared_ptr<Scalar> MakeNullScalar() {
     return arrow::MakeNullScalar(type_singleton());
@@ -593,6 +593,9 @@ TYPED_TEST(TestBinaryArithmeticSigned, DivideOverflowRaises) {
 }
 
 TYPED_TEST(TestBinaryArithmeticFloating, Power) {
+  using CType = typename TestFixture::CType;
+  auto max = std::numeric_limits<CType>::max();
+
   for (auto check_overflow : {false, true}) {
     for (auto remove_nulls : {false, true}) {
       this->SetOverflowCheck(check_overflow);
@@ -613,80 +616,92 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
       this->AssertBinop(Power, "[null, 1, 2.5, null, 2, 5]", 10.0F,
                         "[null, 1, 9536.74316406, null, 1024, 9765625]");
       // Array with infinity
-      this->AssertBinop(Power, "[3.4, Inf, -Inf, 1.1]", "[1, 2, 3, Inf]",
-                        "[3.4, Inf, -Inf, Inf]");
+      this->AssertBinop(Power, "[3.4, Inf, -Inf, 1.1, 100000]", "[1, 2, 3, Inf, 100000]",
+                        "[3.4, Inf, -Inf, Inf, Inf]");
       // Array with NaN
       this->SetNansEqual(true);
       this->AssertBinop(Power, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
       // Scalar exponentiated by scalar
       this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
+      // Divide by zero raises
+      this->AssertBinopRaises(Power, MakeArray(0.0), MakeArray(-1.0), "divide by zero");
     }
+    // Edge cases - propagating NaNs
+    this->SetRemoveNulls(false);
+    this->AssertBinop(Power, "[1, NaN, 0, -Inf, Inf, 1.1, 1, 0, 1, 0]",
+                      "[NaN, 0, NaN, 1, 2, -Inf, Inf, 0, 0, 42]",
+                      "[NaN, NaN, NaN, -Inf, Inf, 0, 1, 1, 1, 0]");
+    // Edge cases - removing NaNs
+    this->SetRemoveNulls(true);
+    this->AssertBinop(Power, "[1, NaN, 0, -Inf, Inf, 1.1, 1, 0, 1, 0]",
+                      "[NaN, 0, NaN, 1, 2, -Inf, Inf, 0, 0, 42]",
+                      "[1, 1, 0, -Inf, Inf, 0, 1, 1, 1, 0]");
   }
 }
 
 TYPED_TEST(TestBinaryArithmeticIntegral, Power) {
+  using CType = typename TestFixture::CType;
+  auto max = std::numeric_limits<CType>::max();
+
   for (auto check_overflow : {false, true}) {
-    this->SetOverflowCheck(check_overflow);
+    for (auto remove_nulls : {false, true}) {
+      this->SetOverflowCheck(check_overflow);
+      this->SetRemoveNulls(remove_nulls);
 
-    // Empty arrays
-    this->AssertBinop(Power, "[]", "[]", "[]");
-    // Ordinary arrays
-    this->AssertBinop(Power, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
-    // Array with nulls
-    this->AssertBinop(Power, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
-                      "[null, 64, 9, null, 20]");
-    // Scalar exponentiated by array
-    this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]",
-                      "[null, 27, 81, null, 9]");
-    // Array exponentiated by scalar
-    this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2,
-                      "[null, 100, 9, null, 4]");
-    // Scalar exponentiated by scalar
-    this->AssertBinop(Power, 4, 3, 64);
+      // Empty arrays
+      this->AssertBinop(Power, "[]", "[]", "[]");
+      // Ordinary arrays
+      this->AssertBinop(Power, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
+      // Array with nulls
+      this->AssertBinop(Power, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
+                        "[null, 64, 9, null, 20]");
+      // Scalar exponentiated by array
+      this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]",
+                        "[null, 27, 81, null, 9]");
+      // Array exponentiated by scalar
+      this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2,
+                        "[null, 100, 9, null, 4]");
+      // Scalar exponentiated by scalar
+      this->AssertBinop(Power, 4, 3, 64);
+      // Edge cases
+      this->AssertBinop(Power, "[0, 1, 0]", "[0, 0, 42]", "[1, 1, 0]");
+      // Overflow raises
+      this->SetOverflowCheck(true);
+      this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
+    }
   }
 }
 
 TYPED_TEST(TestBinaryArithmeticSigned, Power) {
-  // Ordinary arrays
-  this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
-  // Array with nulls
-  this->AssertBinop(Power, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
-                    "[null, 100, 0, null, -20]");
-  // Scalar divides by array
-  this->AssertBinop(Power, 11, "[null, -1, -3, null, 2]",
-                    "[null, 0, 0, null, 121]");
-  // Array divides by scalar
-  this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
-  // Scalar divides by scalar
-  this->AssertBinop(Power, 16, .5, 1);
-
-  // Correctnes
-  this->AssertBinop(Power, "[0, 0, 0]", "[100, 0, 0]", "[0, 1, 1]");
-}
-
-TYPED_TEST(TestBinaryArithmeticFloating, BaseZeroToNegativePower) {
-  this->SetOverflowCheck(true);
-  this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1), "divide by zero");
-
-  this->SetOverflowCheck(false);
-  this->SetNansEqual(true);
-  this->AssertBinop(Power, "[-0.0, 0.0, 0.0]", "[-1.0, -2.0, -1.0]",
-                    "[-Inf, Inf, Inf]");
-}
-
-TYPED_TEST(TestBinaryArithmeticSigned, PowerOverflowRaises) {
   using CType = typename TestFixture::CType;
-  auto min = std::numeric_limits<CType>::lowest();
   auto max = std::numeric_limits<CType>::max();
 
-  this->SetOverflowCheck(true);
-  this->AssertBinopRaises(Power, MakeArray(max), MakeArray(2), "overflow");
-//  this->AssertBinopRaises(Power, MakeArray(-min), MakeArray(-3), "overflow");
+  for (auto check_overflow : {false, true}) {
+    for (auto remove_nulls : {false, true}) {
+      this->SetOverflowCheck(check_overflow);
+      this->SetRemoveNulls(remove_nulls);
 
-  this->SetOverflowCheck(false);
-  this->AssertBinopRaises(Power, MakeArray(max), MakeArray(2), "overflow");
-//  this->AssertBinopRaises(Power, MakeArray(-min), MakeArray(-3), "overflow");
-  this->AssertBinop(Divide, MakeArray(min), MakeArray(-1), "[0]");
+      // Ordinary arrays
+      this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
+      // Array with nulls
+      this->AssertBinop(Power, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
+                        "[null, 100, 0, null, -20]");
+      // Scalar divides by array
+      this->AssertBinop(Power, 11, "[null, -1, -3, null, 2]",
+                        "[null, 0, 0, null, 121]");
+      // Array divides by scalar
+      this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
+      // Scalar divides by scalar
+      this->AssertBinop(Power, 16, .5, 1);
+      // Edge cases
+      this->AssertBinop(Power, "[1, 0, -1, 2]", "[0, 42, 0, -1]", "[1, 0, 1, 0]");
+      // Divide by zero raises
+      this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1), "divide by zero");
+      // Overflow raises
+      this->SetOverflowCheck(true);
+      this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
+    }
+  }
 }
 
 TYPED_TEST(TestBinaryArithmeticFloating, Sub) {

From 4e5cbc2ac06a6f639febfcea89168e8a5e3bbcf2 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 1 Apr 2021 14:14:56 +0200
Subject: [PATCH 04/21] More fixes.

---
 cpp/src/arrow/compute/api_scalar.cc           | 13 ++---
 cpp/src/arrow/compute/api_scalar.h            | 14 +++---
 .../compute/kernels/scalar_arithmetic.cc      | 49 +++++++++++--------
 .../compute/kernels/scalar_arithmetic_test.cc | 47 +++++++++++-------
 docs/source/cpp/compute.rst                   |  4 ++
 docs/source/python/api/compute.rst            |  2 +
 6 files changed, 77 insertions(+), 52 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index eb9671e6edb..23cf498329b 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -41,12 +41,13 @@ namespace compute {
 // ----------------------------------------------------------------------
 // Arithmetic
 
-#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)                  \
-  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options,        \
-                     ExecContext* ctx) {                                                      \
-    std::string func_name = (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME; \
-    func_name = (options.remove_nulls) ? func_name + "_remove_nulls" : func_name + "";        \
-    return CallFunction(func_name, {left, right}, ctx);                                       \
+#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)           \
+  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options, \
+                     ExecContext* ctx) {                                               \
+    std::string func_name =                                                            \
+        (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME;              \
+    func_name = (options.remove_nulls) ? func_name + "_remove_nulls" : func_name + ""; \
+    return CallFunction(func_name, {left, right}, ctx);                                \
   }
 
 SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index ddda637d6d6..3fc09feb031 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -205,16 +205,16 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
                      ArithmeticOptions options = ArithmeticOptions(),
                      ExecContext* ctx = NULLPTR);
 
-/// \brief Compute the value of base value to the power of the exponent value.
-/// Array values must be the same length. If either argument is null the result will be
-/// null. For integer types, if there is a zero base value with negative value, a divide
-/// by zero error will be raised.
+/// \brief Raise the values of base array to the power of the exponent array values.
+/// Array values must be the same length. Base value 0 with negative integer exponent
+/// will raise divide by zero error. Nulls can be removed when base is 0 or 1 or when
+/// exponent is 0.
 ///
 /// \param[in] left the base
 /// \param[in] right the exponent
-/// \param[in] options arithmetic options (enable/disable overflow checking and null removal), optional
-/// \param[in] ctx the function execution context, optional
-/// \return the elementwise base value raised to the power of exponent
+/// \param[in] options arithmetic options (enable/disable overflow checking and null
+/// removal), optional \param[in] ctx the function execution context, optional \return the
+/// elementwise base value raised to the power of exponent
 ARROW_EXPORT
 Result<Datum> Power(const Datum& left, const Datum& right,
                     ArithmeticOptions options = ArithmeticOptions(),
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 82ce69d79bf..f4d90621b84 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -271,7 +271,7 @@ struct Power {
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (isnan(left) || isnan(right)) {
+    if (std::isnan(left) || std::isnan(right)) {
       return NAN;
     }
     if (left == 0 && right < 0) {
@@ -326,7 +326,7 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (isnan(left) || isnan(right)) {
+    if (std::isnan(left) || std::isnan(right)) {
       return NAN;
     }
     if (left == 0 && right < 0) {
@@ -564,30 +564,36 @@ const FunctionDoc div_checked_doc{
     {"dividend", "divisor"}};
 
 const FunctionDoc pow_doc{
-    "Exponentiate the arguments element-wise",
-    ("Integer division by zero returns an error. However, integer overflow\n"
-     "wraps around, and floating-point division by zero returns an infinite.\n"
-     "Use function \"divide_checked\" if you want to get an error\n"
+    "Raise arguments to power element-wise",
+    ("Raising zero to negative integer returns an error. However, integer overflow\n"
+     "wraps around, and floating-point raising zero to negative integer returns an"
+     "infinite.\n"
+     "Use function \"power_checked\" if you want to get an error\n"
      "in all the aforementioned cases."),
     {"base", "power"}};
 
 const FunctionDoc pow_checked_doc{
-    "Exponentiate the arguments element-wise",
-    ("An error is returned when trying to divide by zero, or when\n"
+    "Raise arguments to power element-wise",
+    ("An error is returned when trying to raise zero to negative integer, or when\n"
      "integer overflow is encountered."),
     {"base", "power"}};
 
 const FunctionDoc pow_remove_nulls_doc{
-    "Exponentiate the arguments element-wise",
-    ("Integer division by zero returns an error. However, integer overflow\n"
-     "wraps around, and floating-point division by zero returns an infinite.\n"
-     "Use function \"divide_checked\" if you want to get an error\n"
+    "Raise arguments to power element-wise",
+    ("Raising zero to negative integer returns an error. However, integer overflow\n"
+     "wraps around, and floating-point raising zero to negative integer returns an"
+     "infinite.\n"
+     "In certain cases nulls will be removed: power(0, null)=0, power(1, null)=1"
+     "and power(null, 0)=1.\n"
+     "Use function \"power_checked_remove_nulls\" if you want to get an error\n"
      "in all the aforementioned cases."),
     {"base", "power"}};
 
 const FunctionDoc pow_checked_remove_nulls_doc{
-    "Exponentiate the arguments element-wise",
-    ("An error is returned when trying to divide by zero, or when\n"
+    "Raise arguments to power element-wise",
+    ("In certain cases nulls will be removed: power(0, null)=0, power(1, null)=1"
+     "and power(null, 0)=1.\n"
+     "An error is returned when trying to raise zero to negative integer, or when\n"
      "integer overflow is encountered."),
     {"base", "power"}};
 
@@ -641,22 +647,23 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto power =
-      MakeArithmeticFunctionNotNull<Power>("power", &pow_doc);
+  auto power = MakeArithmeticFunctionNotNull<Power>("power", &pow_doc);
   DCHECK_OK(registry->AddFunction(std::move(power)));
 
   // ----------------------------------------------------------------------
-  auto power_checked = MakeArithmeticFunctionNotNull<PowerChecked>("power_checked", &pow_checked_doc);
+  auto power_checked =
+      MakeArithmeticFunctionNotNull<PowerChecked>("power_checked", &pow_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
   // ----------------------------------------------------------------------
-  auto power_remove_nulls =
-      MakeArithmeticFunctionNotNull<PowerRemoveNulls>("power_remove_nulls", &pow_remove_nulls_doc);
+  auto power_remove_nulls = MakeArithmeticFunctionNotNull<PowerRemoveNulls>(
+      "power_remove_nulls", &pow_remove_nulls_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_remove_nulls)));
 
   // ----------------------------------------------------------------------
-  auto power_checked_remove_nulls = MakeArithmeticFunctionNotNull<PowerCheckedRemoveNulls>(
-      "power_checked_remove_nulls", &pow_checked_remove_nulls_doc);
+  auto power_checked_remove_nulls =
+      MakeArithmeticFunctionNotNull<PowerCheckedRemoveNulls>(
+          "power_checked_remove_nulls", &pow_checked_remove_nulls_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_checked_remove_nulls)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 77ee14fb698..fb88ba2951b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -67,7 +67,10 @@ class TestBinaryArithmetic : public TestBase {
   using BinaryFunction = std::function<Result<Datum>(const Datum&, const Datum&,
                                                      ArithmeticOptions, ExecContext*)>;
 
-  void SetUp() override { options_.check_overflow = false; options_.remove_nulls = false; }
+  void SetUp() override {
+    options_.check_overflow = false;
+    options_.remove_nulls = false;
+  }
 
   std::shared_ptr<Scalar> MakeNullScalar() {
     return arrow::MakeNullScalar(type_singleton());
@@ -625,6 +628,8 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
       this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
       // Divide by zero raises
       this->AssertBinopRaises(Power, MakeArray(0.0), MakeArray(-1.0), "divide by zero");
+      // Check overflow behaviour
+      this->AssertBinop(Power, max, 10, INFINITY);
     }
     // Edge cases - propagating NaNs
     this->SetRemoveNulls(false);
@@ -643,8 +648,8 @@ TYPED_TEST(TestBinaryArithmeticIntegral, Power) {
   using CType = typename TestFixture::CType;
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto check_overflow : {false, true}) {
-    for (auto remove_nulls : {false, true}) {
+  for (auto remove_nulls : {false, true}) {
+    for (auto check_overflow : {false, true}) {
       this->SetOverflowCheck(check_overflow);
       this->SetRemoveNulls(remove_nulls);
 
@@ -656,19 +661,20 @@ TYPED_TEST(TestBinaryArithmeticIntegral, Power) {
       this->AssertBinop(Power, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
                         "[null, 64, 9, null, 20]");
       // Scalar exponentiated by array
-      this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]",
-                        "[null, 27, 81, null, 9]");
+      this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]", "[null, 27, 81, null, 9]");
       // Array exponentiated by scalar
-      this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2,
-                        "[null, 100, 9, null, 4]");
+      this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2, "[null, 100, 9, null, 4]");
       // Scalar exponentiated by scalar
       this->AssertBinop(Power, 4, 3, 64);
       // Edge cases
       this->AssertBinop(Power, "[0, 1, 0]", "[0, 0, 42]", "[1, 1, 0]");
-      // Overflow raises
-      this->SetOverflowCheck(true);
-      this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
     }
+    // Overflow raises
+    this->SetOverflowCheck(true);
+    this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
+    // Disable overflow check
+    this->SetOverflowCheck(false);
+    this->AssertBinop(Power, max, 10, 1);
   }
 }
 
@@ -676,8 +682,8 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
   using CType = typename TestFixture::CType;
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto check_overflow : {false, true}) {
-    for (auto remove_nulls : {false, true}) {
+  for (auto remove_nulls : {false, true}) {
+    for (auto check_overflow : {false, true}) {
       this->SetOverflowCheck(check_overflow);
       this->SetRemoveNulls(remove_nulls);
 
@@ -686,13 +692,12 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
       // Array with nulls
       this->AssertBinop(Power, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
                         "[null, 100, 0, null, -20]");
-      // Scalar divides by array
-      this->AssertBinop(Power, 11, "[null, -1, -3, null, 2]",
-                        "[null, 0, 0, null, 121]");
-      // Array divides by scalar
+      // Scalar exponentiated by array
+      this->AssertBinop(Power, 11, "[null, -1, -3, null, 2]", "[null, 0, 0, null, 121]");
+      // Array exponentiated by scalar
       this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
-      // Scalar divides by scalar
-      this->AssertBinop(Power, 16, .5, 1);
+      // Scalar exponentiated by scalar
+      this->AssertBinop(Power, 16, 1, 16);
       // Edge cases
       this->AssertBinop(Power, "[1, 0, -1, 2]", "[0, 42, 0, -1]", "[1, 0, 1, 0]");
       // Divide by zero raises
@@ -701,6 +706,12 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
       this->SetOverflowCheck(true);
       this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
     }
+    // Overflow raises
+    this->SetOverflowCheck(true);
+    this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
+    // Disable overflow check
+    this->SetOverflowCheck(false);
+    this->AssertBinop(Power, max, 10, 1);
   }
 }
 
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 715d5036964..b2ecb3b2ceb 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -272,6 +272,10 @@ an ``Invalid`` :class:`Status` when overflow is detected.
 +--------------------------+------------+--------------------+---------------------+
 | divide_checked           | Binary     | Numeric            | Numeric             |
 +--------------------------+------------+--------------------+---------------------+
+| power                    | Binary     | Numeric            | Numeric             |
++--------------------------+------------+--------------------+---------------------+
+| power_checked            | Binary     | Numeric            | Numeric             |
++--------------------------+------------+--------------------+---------------------+
 | multiply                 | Binary     | Numeric            | Numeric             |
 +--------------------------+------------+--------------------+---------------------+
 | multiply_checked         | Binary     | Numeric            | Numeric             |
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index d6efc6a5fea..da16ccdfa29 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -53,6 +53,8 @@ throws an ``ArrowInvalid`` exception when overflow is detected.
    multiply_checked
    subtract
    subtract_checked
+   power
+   power_checked
 
 Comparisons
 -----------

From c4933e063098fab0bb961b3e7cff290856f2bf10 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 1 Apr 2021 20:37:31 +0200
Subject: [PATCH 05/21] Disabling negative intiger exponents.

---
 .../compute/kernels/scalar_arithmetic.cc      | 70 ++++++-------------
 .../compute/kernels/scalar_arithmetic_test.cc | 11 +--
 2 files changed, 29 insertions(+), 52 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index f4d90621b84..77390330364 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -238,21 +238,16 @@ struct DivideChecked {
 struct Power {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
+    if (right < 0) {
+      ctx->SetStatus(
+          Status::Invalid("integers to negative integer powers are not allowed"));
     }
     if (left == 0 && right != 0) {
       return 0;
     }
     Arg0 result = 1;
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        result *= left;
-      }
-    } else {
-      for (Arg1 i = 0; i < -right; i++) {
-        result /= left;
-      }
+    for (Arg1 i = 0; i < right; i++) {
+      MultiplyWithOverflow(result, left, &result);
     }
     return result;
   }
@@ -264,7 +259,7 @@ struct Power {
     }
     Arg0 result = 1;
     for (Arg1 i = 0; i < right; i++) {
-      result *= left;
+      MultiplyWithOverflow(result, left, &result);
     }
     return result;
   }
@@ -285,24 +280,17 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
+    if (right < 0) {
+      ctx->SetStatus(
+          Status::Invalid("integers to negative integer powers are not allowed"));
     }
     if (left == 0 && right != 0) {
       return 0;
     }
     Arg0 result = 1;
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
-      }
-    } else {
-      for (Arg1 i = 0; i < -right; i++) {
-        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+    for (Arg1 i = 0; i < right; i++) {
+      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+        ctx->SetStatus(Status::Invalid("overflow"));
       }
     }
     return result;
@@ -339,21 +327,16 @@ struct PowerChecked {
 struct PowerRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
+    if (right < 0) {
+      ctx->SetStatus(
+          Status::Invalid("integers to negative integer powers are not allowed"));
     }
     if (left == 0 && right != 0) {
       return 0;
     }
     Arg0 result = 1;
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        result *= left;
-      }
-    } else {
-      for (Arg1 i = 0; i < -right; i++) {
-        result /= left;
-      }
+    for (Arg1 i = 0; i < right; i++) {
+      MultiplyWithOverflow(result, left, &result);
     }
     return result;
   }
@@ -386,24 +369,17 @@ struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
+    if (right < 0) {
+      ctx->SetStatus(
+          Status::Invalid("integers to negative integer powers are not allowed"));
     }
     if (left == 0 && right != 0) {
       return 0;
     }
     Arg0 result = 1;
-    if (right > 0) {
-      for (Arg1 i = 0; i < right; i++) {
-        if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
-      }
-    } else {
-      for (Arg1 i = 0; i < -right; i++) {
-        if (ARROW_PREDICT_FALSE(DivideWithOverflow(result, left, &result))) {
-          ctx->SetStatus(Status::Invalid("overflow"));
-        }
+    for (Arg1 i = 0; i < right; i++) {
+      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+        ctx->SetStatus(Status::Invalid("overflow"));
       }
     }
     return result;
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index fb88ba2951b..898233d9628 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -690,18 +690,19 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
       // Ordinary arrays
       this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
       // Array with nulls
-      this->AssertBinop(Power, "[null, 10, -27, null, -20]", "[1, 2, -3, 5, 1]",
-                        "[null, 100, 0, null, -20]");
+      this->AssertBinop(Power, "[null, 10, 127, null, -20]", "[1, 2, 1, 5, 1]",
+                        "[null, 100, 127, null, -20]");
       // Scalar exponentiated by array
-      this->AssertBinop(Power, 11, "[null, -1, -3, null, 2]", "[null, 0, 0, null, 121]");
+      this->AssertBinop(Power, 11, "[null, 1, null, 2]", "[null, 11, null, 121]");
       // Array exponentiated by scalar
       this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
       // Scalar exponentiated by scalar
       this->AssertBinop(Power, 16, 1, 16);
       // Edge cases
-      this->AssertBinop(Power, "[1, 0, -1, 2]", "[0, 42, 0, -1]", "[1, 0, 1, 0]");
+      this->AssertBinop(Power, "[1, 0, -1, 2]", "[0, 42, 0, 1]", "[1, 0, 1, 2]");
       // Divide by zero raises
-      this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1), "divide by zero");
+      this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1),
+                              "integers to negative integer powers are not allowed");
       // Overflow raises
       this->SetOverflowCheck(true);
       this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");

From 860a1f38489bb5e0462b3d9736c12f829a99b185 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Fri, 2 Apr 2021 19:27:08 +0200
Subject: [PATCH 06/21] Abstracting power functions.

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 77390330364..af8e5191d3f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -235,181 +235,149 @@ struct DivideChecked {
   }
 };
 
-struct Power {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (right < 0) {
-      ctx->SetStatus(
-          Status::Invalid("integers to negative integer powers are not allowed"));
+template <typename T, typename Arg0, typename Arg1>
+inline T integer_power(KernelContext* ctx, Arg0 left, Arg1 right) {
+  if (right < 0) {
+    ctx->SetStatus(
+        Status::Invalid("integers to negative integer powers are not allowed"));
+  }
+  T result = 1;
+  if (left == 0 && right != 0) {
+    return 0;
+  }
+  while (true) {
+    if (right % 2) {
+      result *= left;
     }
-    if (left == 0 && right != 0) {
-      return 0;
+    right /= 2;
+    if (!right) {
+      break;
+    }
+    left *= left;
+  }
+  return result;
+}
+
+template <typename T, typename Arg0, typename Arg1>
+inline T integer_power_checked(KernelContext* ctx, Arg0 left, Arg1 right) {
+  if (right < 0) {
+    ctx->SetStatus(
+        Status::Invalid("integers to negative integer powers are not allowed"));
+  }
+  T result = 1;
+  if (left == 0 && right != 0) {
+    return 0;
+  }
+  while (true) {
+    if (right % 2) {
+      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
+        ctx->SetStatus(Status::Invalid("overflow"));
+      }
     }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      MultiplyWithOverflow(result, left, &result);
+    right /= 2;
+    if (!right) {
+      break;
     }
-    return result;
+    if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(left, left, &left))) {
+      ctx->SetStatus(Status::Invalid("overflow"));
+    }
+  }
+  return result;
+}
+
+template <typename T, typename Arg0, typename Arg1>
+inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
+  if (std::isnan(left) || std::isnan(right)) {
+    return NAN;
   }
+  if (left == 0 && right < 0) {
+    ctx->SetStatus(Status::Invalid("divide by zero"));
+  }
+  return pow(left, right);
+}
+
+template <typename T, typename Arg0, typename Arg1>
+inline T power_remove_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
+  if (left == 0 && right < 0) {
+    ctx->SetStatus(Status::Invalid("divide by zero"));
+  }
+  if (left == 0 && right != 0) {
+    return 0;
+  }
+  return pow(left, right);
+}
 
+struct Power {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      MultiplyWithOverflow(result, left, &result);
-    }
-    return result;
+    return integer_power<T>(ctx, left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    return integer_power<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (std::isnan(left) || std::isnan(right)) {
-      return NAN;
-    }
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
-    }
-    return pow(left, right);
+    return power<T>(ctx, left, right);
   }
 };
 
 struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (right < 0) {
-      ctx->SetStatus(
-          Status::Invalid("integers to negative integer powers are not allowed"));
-    }
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-        ctx->SetStatus(Status::Invalid("overflow"));
-      }
-    }
-    return result;
+    return integer_power_checked<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-        ctx->SetStatus(Status::Invalid("overflow"));
-      }
-    }
-    return result;
+    return integer_power_checked<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (std::isnan(left) || std::isnan(right)) {
-      return NAN;
-    }
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
-    }
-    return pow(left, right);
+    return power<T>(ctx, left, right);
   }
 };
 
 struct PowerRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (right < 0) {
-      ctx->SetStatus(
-          Status::Invalid("integers to negative integer powers are not allowed"));
-    }
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      MultiplyWithOverflow(result, left, &result);
-    }
-    return result;
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    return integer_power<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      result *= left;
-    }
-    return result;
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+    return integer_power<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
-    }
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    return pow(left, right);
+    return power_remove_nulls<T>(ctx, left, right);
   }
 };
 
 struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (right < 0) {
-      ctx->SetStatus(
-          Status::Invalid("integers to negative integer powers are not allowed"));
-    }
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-        ctx->SetStatus(Status::Invalid("overflow"));
-      }
-    }
-    return result;
+    return integer_power_checked<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    Arg0 result = 1;
-    for (Arg1 i = 0; i < right; i++) {
-      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-        ctx->SetStatus(Status::Invalid("overflow"));
-      }
-    }
-    return result;
+    return integer_power_checked<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (left == 0 && right < 0) {
-      ctx->SetStatus(Status::Invalid("divide by zero"));
-    }
-    if (left == 0 && right != 0) {
-      return 0;
-    }
-    return pow(left, right);
+    return power_remove_nulls<T>(ctx, left, right);
   }
 };
 

From 1b65ead716e0d450e24141fbb5a5cc9cf77cb612 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 3 Apr 2021 00:23:01 +0200
Subject: [PATCH 07/21] Integer promotion.

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index af8e5191d3f..04a1e8d3eb0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -310,12 +310,12 @@ inline T power_remove_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
 struct Power {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    return integer_power<T>(ctx, left, right);
+    return integer_power<uint64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    return integer_power<T>(ctx, left, right);
+    return integer_power<int64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
@@ -327,14 +327,14 @@ struct Power {
 struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return integer_power_checked<T>(ctx, left, right);
+    static_assert(std::is_same<Arg0, Arg1>::value, "");
+    return integer_power_checked<uint64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return integer_power_checked<T>(ctx, left, right);
+    static_assert(std::is_same<Arg0, Arg1>::value, "");
+    return integer_power_checked<int64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
@@ -347,12 +347,12 @@ struct PowerChecked {
 struct PowerRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    return integer_power<T>(ctx, left, right);
+    return integer_power<uint64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    return integer_power<T>(ctx, left, right);
+    return integer_power<int64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
@@ -364,14 +364,14 @@ struct PowerRemoveNulls {
 struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return integer_power_checked<T>(ctx, left, right);
+    static_assert(std::is_same<Arg0, Arg1>::value, "");
+    return integer_power_checked<uint64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return integer_power_checked<T>(ctx, left, right);
+    static_assert(std::is_same<Arg0, Arg1>::value, "");
+    return integer_power_checked<int64_t>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>

From ce5c9621cc0fb6a3b58b93c6fe616eaa317905d2 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 3 Apr 2021 01:27:15 +0200
Subject: [PATCH 08/21] Minor change.

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 04a1e8d3eb0..126aff448fb 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -308,18 +308,18 @@ inline T power_remove_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
 }
 
 struct Power {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  template <typename T>
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
     return integer_power<uint64_t>(ctx, left, right);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  template <typename T>
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
     return integer_power<int64_t>(ctx, left, right);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  template <typename T>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
     return power<T>(ctx, left, right);
   }
 };
@@ -345,18 +345,18 @@ struct PowerChecked {
 };
 
 struct PowerRemoveNulls {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  template <typename T>
+  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
     return integer_power<uint64_t>(ctx, left, right);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  template <typename T>
+  static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
     return integer_power<int64_t>(ctx, left, right);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  template <typename T>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
     return power_remove_nulls<T>(ctx, left, right);
   }
 };
@@ -591,7 +591,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto power = MakeArithmeticFunctionNotNull<Power>("power", &pow_doc);
+  auto power = MakeArithmeticFunction<Power>("power", &pow_doc);
   DCHECK_OK(registry->AddFunction(std::move(power)));
 
   // ----------------------------------------------------------------------
@@ -600,7 +600,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
   // ----------------------------------------------------------------------
-  auto power_remove_nulls = MakeArithmeticFunctionNotNull<PowerRemoveNulls>(
+  auto power_remove_nulls = MakeArithmeticFunction<PowerRemoveNulls>(
       "power_remove_nulls", &pow_remove_nulls_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_remove_nulls)));
 

From 575ef4b475edc8b561acc50f72747c2009ee92b2 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 3 Apr 2021 13:33:24 +0200
Subject: [PATCH 09/21] Setting remove_nulls default to true.

---
 cpp/src/arrow/compute/api_scalar.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 3fc09feb031..1e33094d275 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -38,7 +38,7 @@ namespace compute {
 /// @{
 
 struct ArithmeticOptions : public FunctionOptions {
-  ArithmeticOptions() : check_overflow(false), remove_nulls(false) {}
+  ArithmeticOptions() : check_overflow(false), remove_nulls(true) {}
   bool check_overflow;
   bool remove_nulls;
 };

From 5feb6aef1d29fbdd59723cd6f7eb4acea072a209 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 3 Apr 2021 16:23:41 +0200
Subject: [PATCH 10/21] Switching from `remove_nulls` to `propagate_nulls`
 option.

---
 cpp/src/arrow/compute/api_scalar.cc           | 14 +++---
 cpp/src/arrow/compute/api_scalar.h            |  4 +-
 .../compute/kernels/scalar_arithmetic.cc      | 44 +++++++++----------
 .../compute/kernels/scalar_arithmetic_test.cc | 18 ++++----
 4 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 23cf498329b..49e0237e1b0 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -41,13 +41,13 @@ namespace compute {
 // ----------------------------------------------------------------------
 // Arithmetic
 
-#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)           \
-  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options, \
-                     ExecContext* ctx) {                                               \
-    std::string func_name =                                                            \
-        (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME;              \
-    func_name = (options.remove_nulls) ? func_name + "_remove_nulls" : func_name + ""; \
-    return CallFunction(func_name, {left, right}, ctx);                                \
+#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)            \
+  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options,  \
+                     ExecContext* ctx) {                                                \
+    std::string func_name =                                                             \
+        (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME;               \
+    func_name = (options.propagate_nulls) ? func_name + "_propagate_nulls" : func_name; \
+    return CallFunction(func_name, {left, right}, ctx);                                 \
   }
 
 SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 1e33094d275..b87bff2dd5b 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -38,9 +38,9 @@ namespace compute {
 /// @{
 
 struct ArithmeticOptions : public FunctionOptions {
-  ArithmeticOptions() : check_overflow(false), remove_nulls(true) {}
+  ArithmeticOptions() : check_overflow(false), propagate_nulls(false) {}
   bool check_overflow;
-  bool remove_nulls;
+  bool propagate_nulls;
 };
 
 struct ARROW_EXPORT MatchSubstringOptions : public FunctionOptions {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 126aff448fb..bd13727ecf4 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -286,7 +286,7 @@ inline T integer_power_checked(KernelContext* ctx, Arg0 left, Arg1 right) {
 }
 
 template <typename T, typename Arg0, typename Arg1>
-inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
+inline T power_propagate_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
   if (std::isnan(left) || std::isnan(right)) {
     return NAN;
   }
@@ -297,7 +297,7 @@ inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
 }
 
 template <typename T, typename Arg0, typename Arg1>
-inline T power_remove_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
+inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
   if (left == 0 && right < 0) {
     ctx->SetStatus(Status::Invalid("divide by zero"));
   }
@@ -307,7 +307,7 @@ inline T power_remove_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
   return pow(left, right);
 }
 
-struct Power {
+struct PowerPropagateNulls {
   template <typename T>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
     return integer_power<uint64_t>(ctx, left, right);
@@ -320,11 +320,11 @@ struct Power {
 
   template <typename T>
   static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
-    return power<T>(ctx, left, right);
+    return power_propagate_nulls<T>(ctx, left, right);
   }
 };
 
-struct PowerChecked {
+struct PowerCheckedPropagateNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<Arg0, Arg1>::value, "");
@@ -340,11 +340,11 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return power<T>(ctx, left, right);
+    return power_propagate_nulls<T>(ctx, left, right);
   }
 };
 
-struct PowerRemoveNulls {
+struct Power {
   template <typename T>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
     return integer_power<uint64_t>(ctx, left, right);
@@ -357,11 +357,11 @@ struct PowerRemoveNulls {
 
   template <typename T>
   static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
-    return power_remove_nulls<T>(ctx, left, right);
+    return power<T>(ctx, left, right);
   }
 };
 
-struct PowerCheckedRemoveNulls {
+struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<Arg0, Arg1>::value, "");
@@ -377,7 +377,7 @@ struct PowerCheckedRemoveNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return power_remove_nulls<T>(ctx, left, right);
+    return power<T>(ctx, left, right);
   }
 };
 
@@ -507,7 +507,7 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"dividend", "divisor"}};
 
-const FunctionDoc pow_doc{
+const FunctionDoc pow_propagate_nulls_doc{
     "Raise arguments to power element-wise",
     ("Raising zero to negative integer returns an error. However, integer overflow\n"
      "wraps around, and floating-point raising zero to negative integer returns an"
@@ -516,24 +516,24 @@ const FunctionDoc pow_doc{
      "in all the aforementioned cases."),
     {"base", "power"}};
 
-const FunctionDoc pow_checked_doc{
+const FunctionDoc pow_checked_propagate_nulls_doc{
     "Raise arguments to power element-wise",
     ("An error is returned when trying to raise zero to negative integer, or when\n"
      "integer overflow is encountered."),
     {"base", "power"}};
 
-const FunctionDoc pow_remove_nulls_doc{
+const FunctionDoc pow_doc{
     "Raise arguments to power element-wise",
     ("Raising zero to negative integer returns an error. However, integer overflow\n"
      "wraps around, and floating-point raising zero to negative integer returns an"
      "infinite.\n"
      "In certain cases nulls will be removed: power(0, null)=0, power(1, null)=1"
      "and power(null, 0)=1.\n"
-     "Use function \"power_checked_remove_nulls\" if you want to get an error\n"
+     "Use function \"power_checked_propagate_nulls\" if you want to get an error\n"
      "in all the aforementioned cases."),
     {"base", "power"}};
 
-const FunctionDoc pow_checked_remove_nulls_doc{
+const FunctionDoc pow_checked_doc{
     "Raise arguments to power element-wise",
     ("In certain cases nulls will be removed: power(0, null)=0, power(1, null)=1"
      "and power(null, 0)=1.\n"
@@ -600,15 +600,15 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
   // ----------------------------------------------------------------------
-  auto power_remove_nulls = MakeArithmeticFunction<PowerRemoveNulls>(
-      "power_remove_nulls", &pow_remove_nulls_doc);
-  DCHECK_OK(registry->AddFunction(std::move(power_remove_nulls)));
+  auto power_propagate_nulls = MakeArithmeticFunction<PowerPropagateNulls>(
+      "power_propagate_nulls", &pow_propagate_nulls_doc);
+  DCHECK_OK(registry->AddFunction(std::move(power_propagate_nulls)));
 
   // ----------------------------------------------------------------------
-  auto power_checked_remove_nulls =
-      MakeArithmeticFunctionNotNull<PowerCheckedRemoveNulls>(
-          "power_checked_remove_nulls", &pow_checked_remove_nulls_doc);
-  DCHECK_OK(registry->AddFunction(std::move(power_checked_remove_nulls)));
+  auto power_checked_propagate_nulls =
+      MakeArithmeticFunctionNotNull<PowerCheckedPropagateNulls>(
+          "power_checked_propagate_nulls", &pow_checked_propagate_nulls_doc);
+  DCHECK_OK(registry->AddFunction(std::move(power_checked_propagate_nulls)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 898233d9628..62e8c687e2a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -69,7 +69,7 @@ class TestBinaryArithmetic : public TestBase {
 
   void SetUp() override {
     options_.check_overflow = false;
-    options_.remove_nulls = false;
+    options_.propagate_nulls = false;
   }
 
   std::shared_ptr<Scalar> MakeNullScalar() {
@@ -174,7 +174,7 @@ class TestBinaryArithmetic : public TestBase {
 
   void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
 
-  void SetRemoveNulls(bool value = false) { options_.remove_nulls = value; }
+  void SetPropagateNulls(bool value = false) { options_.propagate_nulls = value; }
 
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
@@ -600,9 +600,9 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
   auto max = std::numeric_limits<CType>::max();
 
   for (auto check_overflow : {false, true}) {
-    for (auto remove_nulls : {false, true}) {
+    for (auto propagate_nulls : {false, true}) {
       this->SetOverflowCheck(check_overflow);
-      this->SetRemoveNulls(remove_nulls);
+      this->SetPropagateNulls(propagate_nulls);
 
       // Empty arrays
       this->AssertBinop(Power, "[]", "[]", "[]");
@@ -632,12 +632,12 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
       this->AssertBinop(Power, max, 10, INFINITY);
     }
     // Edge cases - propagating NaNs
-    this->SetRemoveNulls(false);
+    this->SetPropagateNulls(true);
     this->AssertBinop(Power, "[1, NaN, 0, -Inf, Inf, 1.1, 1, 0, 1, 0]",
                       "[NaN, 0, NaN, 1, 2, -Inf, Inf, 0, 0, 42]",
                       "[NaN, NaN, NaN, -Inf, Inf, 0, 1, 1, 1, 0]");
     // Edge cases - removing NaNs
-    this->SetRemoveNulls(true);
+    this->SetPropagateNulls(false);
     this->AssertBinop(Power, "[1, NaN, 0, -Inf, Inf, 1.1, 1, 0, 1, 0]",
                       "[NaN, 0, NaN, 1, 2, -Inf, Inf, 0, 0, 42]",
                       "[1, 1, 0, -Inf, Inf, 0, 1, 1, 1, 0]");
@@ -648,10 +648,10 @@ TYPED_TEST(TestBinaryArithmeticIntegral, Power) {
   using CType = typename TestFixture::CType;
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto remove_nulls : {false, true}) {
+  for (auto propagate_nulls : {false, true}) {
     for (auto check_overflow : {false, true}) {
       this->SetOverflowCheck(check_overflow);
-      this->SetRemoveNulls(remove_nulls);
+      this->SetPropagateNulls(propagate_nulls);
 
       // Empty arrays
       this->AssertBinop(Power, "[]", "[]", "[]");
@@ -685,7 +685,7 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
   for (auto remove_nulls : {false, true}) {
     for (auto check_overflow : {false, true}) {
       this->SetOverflowCheck(check_overflow);
-      this->SetRemoveNulls(remove_nulls);
+      this->SetPropagateNulls(remove_nulls);
 
       // Ordinary arrays
       this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");

From 281eb24227a0dad4a2c556f66b7b4089b84b003a Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 3 Apr 2021 22:27:58 +0200
Subject: [PATCH 11/21] Minor change.

---
 .../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 62e8c687e2a..1934569d5ee 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -633,14 +633,14 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
     }
     // Edge cases - propagating NaNs
     this->SetPropagateNulls(true);
-    this->AssertBinop(Power, "[1, NaN, 0, -Inf, Inf, 1.1, 1, 0, 1, 0]",
-                      "[NaN, 0, NaN, 1, 2, -Inf, Inf, 0, 0, 42]",
-                      "[NaN, NaN, NaN, -Inf, Inf, 0, 1, 1, 1, 0]");
+    this->AssertBinop(Power, "[1, NaN, 0, null, 1.2, -Inf, Inf, 1.1, 1, 0, 1, 0]",
+                      "[NaN, 0, NaN, 1, null, 1, 2, -Inf, Inf, 0, 0, 42]",
+                      "[NaN, NaN, NaN, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
     // Edge cases - removing NaNs
     this->SetPropagateNulls(false);
-    this->AssertBinop(Power, "[1, NaN, 0, -Inf, Inf, 1.1, 1, 0, 1, 0]",
-                      "[NaN, 0, NaN, 1, 2, -Inf, Inf, 0, 0, 42]",
-                      "[1, 1, 0, -Inf, Inf, 0, 1, 1, 1, 0]");
+    this->AssertBinop(Power, "[1, NaN, 0, null, 1.2, -Inf, Inf, 1.1, 1, 0, 1, 0]",
+                      "[NaN, 0, NaN, 1, null, 1, 2, -Inf, Inf, 0, 0, 42]",
+                      "[1, 1, 0, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
   }
 }
 

From 1880cddc10f04c939b02d03735f6e4600da3be9e Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sun, 4 Apr 2021 00:32:13 +0200
Subject: [PATCH 12/21] Casting integers.

---
 .../arrow/compute/kernels/scalar_arithmetic.cc   | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index bd13727ecf4..501669d078c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -310,12 +310,12 @@ inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
 struct PowerPropagateNulls {
   template <typename T>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return integer_power<uint64_t>(ctx, left, right);
+    return static_cast<uint64_t>(integer_power<T>(ctx, left, right));
   }
 
   template <typename T>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return integer_power<int64_t>(ctx, left, right);
+    return static_cast<int64_t>(integer_power<T>(ctx, left, right));
   }
 
   template <typename T>
@@ -328,13 +328,13 @@ struct PowerCheckedPropagateNulls {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return integer_power_checked<uint64_t>(ctx, left, right);
+    return static_cast<uint64_t>(integer_power_checked<uint64_t>(ctx, left, right));
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return integer_power_checked<int64_t>(ctx, left, right);
+    return static_cast<int64_t>(integer_power_checked<T>(ctx, left, right));
   }
 
   template <typename T, typename Arg0, typename Arg1>
@@ -347,12 +347,12 @@ struct PowerCheckedPropagateNulls {
 struct Power {
   template <typename T>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return integer_power<uint64_t>(ctx, left, right);
+    return static_cast<uint64_t>(integer_power<uint64_t>(ctx, left, right));
   }
 
   template <typename T>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return integer_power<int64_t>(ctx, left, right);
+    return static_cast<int64_t>(integer_power<int64_t>(ctx, left, right));
   }
 
   template <typename T>
@@ -365,13 +365,13 @@ struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return integer_power_checked<uint64_t>(ctx, left, right);
+    return static_cast<uint64_t>(integer_power_checked<uint64_t>(ctx, left, right));
   }
 
   template <typename T, typename Arg0, typename Arg1>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
     static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return integer_power_checked<int64_t>(ctx, left, right);
+    return static_cast<int64_t>(integer_power_checked<int64_t>(ctx, left, right));
   }
 
   template <typename T, typename Arg0, typename Arg1>

From d026dd61294dab16f355c635c9c0cb5081c851cb Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 6 Apr 2021 13:18:14 +0200
Subject: [PATCH 13/21] Remove propagate_nulls options.

---
 cpp/src/arrow/compute/api_scalar.cc           |  13 +-
 cpp/src/arrow/compute/api_scalar.h            |   3 +-
 .../compute/kernels/scalar_arithmetic.cc      | 101 ++--------
 .../compute/kernels/scalar_arithmetic_test.cc | 187 ++++++++----------
 4 files changed, 104 insertions(+), 200 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 49e0237e1b0..58d6afc0891 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -41,13 +41,12 @@ namespace compute {
 // ----------------------------------------------------------------------
 // Arithmetic
 
-#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)            \
-  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options,  \
-                     ExecContext* ctx) {                                                \
-    std::string func_name =                                                             \
-        (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME;               \
-    func_name = (options.propagate_nulls) ? func_name + "_propagate_nulls" : func_name; \
-    return CallFunction(func_name, {left, right}, ctx);                                 \
+#define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)           \
+  Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options, \
+                     ExecContext* ctx) {                                               \
+    std::string func_name =                                                            \
+        (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME;              \
+    return CallFunction(func_name, {left, right}, ctx);                                \
   }
 
 SCALAR_ARITHMETIC_BINARY(Add, "add", "add_checked")
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index b87bff2dd5b..09d3bb69b99 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -38,9 +38,8 @@ namespace compute {
 /// @{
 
 struct ArithmeticOptions : public FunctionOptions {
-  ArithmeticOptions() : check_overflow(false), propagate_nulls(false) {}
+  ArithmeticOptions() : check_overflow(false) {}
   bool check_overflow;
-  bool propagate_nulls;
 };
 
 struct ARROW_EXPORT MatchSubstringOptions : public FunctionOptions {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 501669d078c..c33f414c389 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -20,6 +20,7 @@
 #include "arrow/compute/kernels/common.h"
 #include "arrow/util/int_util_internal.h"
 #include "arrow/util/macros.h"
+#include "arrow/util/type_traits.h"
 
 namespace arrow {
 
@@ -235,8 +236,8 @@ struct DivideChecked {
   }
 };
 
-template <typename T, typename Arg0, typename Arg1>
-inline T integer_power(KernelContext* ctx, Arg0 left, Arg1 right) {
+template <typename T>
+inline T integer_power(KernelContext* ctx, T left, T right) {
   if (right < 0) {
     ctx->SetStatus(
         Status::Invalid("integers to negative integer powers are not allowed"));
@@ -285,17 +286,6 @@ inline T integer_power_checked(KernelContext* ctx, Arg0 left, Arg1 right) {
   return result;
 }
 
-template <typename T, typename Arg0, typename Arg1>
-inline T power_propagate_nulls(KernelContext* ctx, Arg0 left, Arg1 right) {
-  if (std::isnan(left) || std::isnan(right)) {
-    return NAN;
-  }
-  if (left == 0 && right < 0) {
-    ctx->SetStatus(Status::Invalid("divide by zero"));
-  }
-  return pow(left, right);
-}
-
 template <typename T, typename Arg0, typename Arg1>
 inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
   if (left == 0 && right < 0) {
@@ -307,52 +297,15 @@ inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
   return pow(left, right);
 }
 
-struct PowerPropagateNulls {
-  template <typename T>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return static_cast<uint64_t>(integer_power<T>(ctx, left, right));
-  }
-
-  template <typename T>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return static_cast<int64_t>(integer_power<T>(ctx, left, right));
-  }
-
-  template <typename T>
-  static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
-    return power_propagate_nulls<T>(ctx, left, right);
-  }
-};
-
-struct PowerCheckedPropagateNulls {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return static_cast<uint64_t>(integer_power_checked<uint64_t>(ctx, left, right));
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return static_cast<int64_t>(integer_power_checked<T>(ctx, left, right));
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return power_propagate_nulls<T>(ctx, left, right);
-  }
-};
-
 struct Power {
   template <typename T>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return static_cast<uint64_t>(integer_power<uint64_t>(ctx, left, right));
+    return integer_power<T>(ctx, left, right);
   }
 
   template <typename T>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return static_cast<int64_t>(integer_power<int64_t>(ctx, left, right));
+    return integer_power<T>(ctx, left, right);
   }
 
   template <typename T>
@@ -362,16 +315,16 @@ struct Power {
 };
 
 struct PowerChecked {
-  template <typename T, typename Arg0, typename Arg1>
+  template <typename T = void, typename Arg0 = void, typename Arg1 = void>
   static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return static_cast<uint64_t>(integer_power_checked<uint64_t>(ctx, left, right));
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return integer_power_checked<T>(ctx, left, right);
   }
 
-  template <typename T, typename Arg0, typename Arg1>
+  template <typename T = void, typename Arg0 = void, typename Arg1 = void>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<Arg0, Arg1>::value, "");
-    return static_cast<int64_t>(integer_power_checked<int64_t>(ctx, left, right));
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return integer_power_checked<T>(ctx, left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
@@ -507,37 +460,18 @@ const FunctionDoc div_checked_doc{
      "integer overflow is encountered."),
     {"dividend", "divisor"}};
 
-const FunctionDoc pow_propagate_nulls_doc{
-    "Raise arguments to power element-wise",
-    ("Raising zero to negative integer returns an error. However, integer overflow\n"
-     "wraps around, and floating-point raising zero to negative integer returns an"
-     "infinite.\n"
-     "Use function \"power_checked\" if you want to get an error\n"
-     "in all the aforementioned cases."),
-    {"base", "power"}};
-
-const FunctionDoc pow_checked_propagate_nulls_doc{
-    "Raise arguments to power element-wise",
-    ("An error is returned when trying to raise zero to negative integer, or when\n"
-     "integer overflow is encountered."),
-    {"base", "power"}};
-
 const FunctionDoc pow_doc{
     "Raise arguments to power element-wise",
     ("Raising zero to negative integer returns an error. However, integer overflow\n"
      "wraps around, and floating-point raising zero to negative integer returns an"
      "infinite.\n"
-     "In certain cases nulls will be removed: power(0, null)=0, power(1, null)=1"
-     "and power(null, 0)=1.\n"
      "Use function \"power_checked_propagate_nulls\" if you want to get an error\n"
      "in all the aforementioned cases."),
     {"base", "power"}};
 
 const FunctionDoc pow_checked_doc{
     "Raise arguments to power element-wise",
-    ("In certain cases nulls will be removed: power(0, null)=0, power(1, null)=1"
-     "and power(null, 0)=1.\n"
-     "An error is returned when trying to raise zero to negative integer, or when\n"
+    ("An error is returned when trying to raise zero to negative integer, or when\n"
      "integer overflow is encountered."),
     {"base", "power"}};
 
@@ -598,17 +532,6 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   auto power_checked =
       MakeArithmeticFunctionNotNull<PowerChecked>("power_checked", &pow_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
-
-  // ----------------------------------------------------------------------
-  auto power_propagate_nulls = MakeArithmeticFunction<PowerPropagateNulls>(
-      "power_propagate_nulls", &pow_propagate_nulls_doc);
-  DCHECK_OK(registry->AddFunction(std::move(power_propagate_nulls)));
-
-  // ----------------------------------------------------------------------
-  auto power_checked_propagate_nulls =
-      MakeArithmeticFunctionNotNull<PowerCheckedPropagateNulls>(
-          "power_checked_propagate_nulls", &pow_checked_propagate_nulls_doc);
-  DCHECK_OK(registry->AddFunction(std::move(power_checked_propagate_nulls)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 1934569d5ee..70e175b5e53 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -67,10 +67,7 @@ class TestBinaryArithmetic : public TestBase {
   using BinaryFunction = std::function<Result<Datum>(const Datum&, const Datum&,
                                                      ArithmeticOptions, ExecContext*)>;
 
-  void SetUp() override {
-    options_.check_overflow = false;
-    options_.propagate_nulls = false;
-  }
+  void SetUp() override { options_.check_overflow = false; }
 
   std::shared_ptr<Scalar> MakeNullScalar() {
     return arrow::MakeNullScalar(type_singleton());
@@ -174,8 +171,6 @@ class TestBinaryArithmetic : public TestBase {
 
   void SetOverflowCheck(bool value = true) { options_.check_overflow = value; }
 
-  void SetPropagateNulls(bool value = false) { options_.propagate_nulls = value; }
-
   void SetNansEqual(bool value = true) {
     this->equal_options_ = equal_options_.nans_equal(value);
   }
@@ -600,120 +595,108 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
   auto max = std::numeric_limits<CType>::max();
 
   for (auto check_overflow : {false, true}) {
-    for (auto propagate_nulls : {false, true}) {
-      this->SetOverflowCheck(check_overflow);
-      this->SetPropagateNulls(propagate_nulls);
-
-      // Empty arrays
-      this->AssertBinop(Power, "[]", "[]", "[]");
-      // Ordinary arrays
-      this->AssertBinop(Power, "[3.4, 16, 0.64, 1.2, 0]", "[1, 0.5, 2, 4, 0]",
-                        "[3.4, 4, 0.4096, 2.0736, 1]");
-      // Array with nulls
-      this->AssertBinop(Power, "[null, 1, 3.3, null, 2]", "[1, 4, 2, 5, 0.1]",
-                        "[null, 1, 10.89, null, 1.07177346]");
-      // Scalar exponentiated by array
-      this->AssertBinop(Power, 10.0F, "[null, 1, 2.5, null, 2, 5]",
-                        "[null, 10, 316.227766017, null, 100, 100000]");
-      // Array exponentiated by scalar
-      this->AssertBinop(Power, "[null, 1, 2.5, null, 2, 5]", 10.0F,
-                        "[null, 1, 9536.74316406, null, 1024, 9765625]");
-      // Array with infinity
-      this->AssertBinop(Power, "[3.4, Inf, -Inf, 1.1, 100000]", "[1, 2, 3, Inf, 100000]",
-                        "[3.4, Inf, -Inf, Inf, Inf]");
-      // Array with NaN
-      this->SetNansEqual(true);
-      this->AssertBinop(Power, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
-      // Scalar exponentiated by scalar
-      this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
-      // Divide by zero raises
-      this->AssertBinopRaises(Power, MakeArray(0.0), MakeArray(-1.0), "divide by zero");
-      // Check overflow behaviour
-      this->AssertBinop(Power, max, 10, INFINITY);
-    }
-    // Edge cases - propagating NaNs
-    this->SetPropagateNulls(true);
-    this->AssertBinop(Power, "[1, NaN, 0, null, 1.2, -Inf, Inf, 1.1, 1, 0, 1, 0]",
-                      "[NaN, 0, NaN, 1, null, 1, 2, -Inf, Inf, 0, 0, 42]",
-                      "[NaN, NaN, NaN, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
-    // Edge cases - removing NaNs
-    this->SetPropagateNulls(false);
-    this->AssertBinop(Power, "[1, NaN, 0, null, 1.2, -Inf, Inf, 1.1, 1, 0, 1, 0]",
-                      "[NaN, 0, NaN, 1, null, 1, 2, -Inf, Inf, 0, 0, 42]",
-                      "[1, 1, 0, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
+    this->SetOverflowCheck(check_overflow);
+
+    // Empty arrays
+    this->AssertBinop(Power, "[]", "[]", "[]");
+    // Ordinary arrays
+    this->AssertBinop(Power, "[3.4, 16, 0.64, 1.2, 0]", "[1, 0.5, 2, 4, 0]",
+                      "[3.4, 4, 0.4096, 2.0736, 1]");
+    // Array with nulls
+    this->AssertBinop(Power, "[null, 1, 3.3, null, 2]", "[1, 4, 2, 5, 0.1]",
+                      "[null, 1, 10.89, null, 1.07177346]");
+    // Scalar exponentiated by array
+    this->AssertBinop(Power, 10.0F, "[null, 1, 2.5, null, 2, 5]",
+                      "[null, 10, 316.227766017, null, 100, 100000]");
+    // Array exponentiated by scalar
+    this->AssertBinop(Power, "[null, 1, 2.5, null, 2, 5]", 10.0F,
+                      "[null, 1, 9536.74316406, null, 1024, 9765625]");
+    // Array with infinity
+    this->AssertBinop(Power, "[3.4, Inf, -Inf, 1.1, 100000]", "[1, 2, 3, Inf, 100000]",
+                      "[3.4, Inf, -Inf, Inf, Inf]");
+    // Array with NaN
+    this->SetNansEqual(true);
+    this->AssertBinop(Power, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
+    // Scalar exponentiated by scalar
+    this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
+    // Divide by zero raises
+    this->AssertBinopRaises(Power, MakeArray(0.0), MakeArray(-1.0), "divide by zero");
+    // Check overflow behaviour
+    this->AssertBinop(Power, max, 10, INFINITY);
   }
+
+  // Edge cases - removing NaNs
+  this->AssertBinop(Power, "[1, NaN, 0, null, 1.2, -Inf, Inf, 1.1, 1, 0, 1, 0]",
+                    "[NaN, 0, NaN, 1, null, 1, 2, -Inf, Inf, 0, 0, 42]",
+                    "[1, 1, 0, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
 }
 
 TYPED_TEST(TestBinaryArithmeticIntegral, Power) {
   using CType = typename TestFixture::CType;
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto propagate_nulls : {false, true}) {
-    for (auto check_overflow : {false, true}) {
-      this->SetOverflowCheck(check_overflow);
-      this->SetPropagateNulls(propagate_nulls);
-
-      // Empty arrays
-      this->AssertBinop(Power, "[]", "[]", "[]");
-      // Ordinary arrays
-      this->AssertBinop(Power, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
-      // Array with nulls
-      this->AssertBinop(Power, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
-                        "[null, 64, 9, null, 20]");
-      // Scalar exponentiated by array
-      this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]", "[null, 27, 81, null, 9]");
-      // Array exponentiated by scalar
-      this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2, "[null, 100, 9, null, 4]");
-      // Scalar exponentiated by scalar
-      this->AssertBinop(Power, 4, 3, 64);
-      // Edge cases
-      this->AssertBinop(Power, "[0, 1, 0]", "[0, 0, 42]", "[1, 1, 0]");
-    }
-    // Overflow raises
-    this->SetOverflowCheck(true);
-    this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
-    // Disable overflow check
-    this->SetOverflowCheck(false);
-    this->AssertBinop(Power, max, 10, 1);
+  for (auto check_overflow : {false, true}) {
+    this->SetOverflowCheck(check_overflow);
+
+    // Empty arrays
+    this->AssertBinop(Power, "[]", "[]", "[]");
+    // Ordinary arrays
+    this->AssertBinop(Power, "[3, 2, 6, 2]", "[1, 1, 2, 0]", "[3, 2, 36, 1]");
+    // Array with nulls
+    this->AssertBinop(Power, "[null, 2, 3, null, 20]", "[1, 6, 2, 5, 1]",
+                      "[null, 64, 9, null, 20]");
+    // Scalar exponentiated by array
+    this->AssertBinop(Power, 3, "[null, 3, 4, null, 2]", "[null, 27, 81, null, 9]");
+    // Array exponentiated by scalar
+    this->AssertBinop(Power, "[null, 10, 3, null, 2]", 2, "[null, 100, 9, null, 4]");
+    // Scalar exponentiated by scalar
+    this->AssertBinop(Power, 4, 3, 64);
+    // Edge cases
+    this->AssertBinop(Power, "[0, 1, 0]", "[0, 0, 42]", "[1, 1, 0]");
   }
+
+  // Overflow raises
+  this->SetOverflowCheck(true);
+  this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
+  // Disable overflow check
+  this->SetOverflowCheck(false);
+  this->AssertBinop(Power, max, 10, 1);
 }
 
 TYPED_TEST(TestBinaryArithmeticSigned, Power) {
   using CType = typename TestFixture::CType;
   auto max = std::numeric_limits<CType>::max();
 
-  for (auto remove_nulls : {false, true}) {
-    for (auto check_overflow : {false, true}) {
-      this->SetOverflowCheck(check_overflow);
-      this->SetPropagateNulls(remove_nulls);
-
-      // Ordinary arrays
-      this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
-      // Array with nulls
-      this->AssertBinop(Power, "[null, 10, 127, null, -20]", "[1, 2, 1, 5, 1]",
-                        "[null, 100, 127, null, -20]");
-      // Scalar exponentiated by array
-      this->AssertBinop(Power, 11, "[null, 1, null, 2]", "[null, 11, null, 121]");
-      // Array exponentiated by scalar
-      this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
-      // Scalar exponentiated by scalar
-      this->AssertBinop(Power, 16, 1, 16);
-      // Edge cases
-      this->AssertBinop(Power, "[1, 0, -1, 2]", "[0, 42, 0, 1]", "[1, 0, 1, 2]");
-      // Divide by zero raises
-      this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1),
-                              "integers to negative integer powers are not allowed");
-      // Overflow raises
-      this->SetOverflowCheck(true);
-      this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
-    }
+  for (auto check_overflow : {false, true}) {
+    this->SetOverflowCheck(check_overflow);
+
+    // Ordinary arrays
+    this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
+    // Array with nulls
+    this->AssertBinop(Power, "[null, 10, 127, null, -20]", "[1, 2, 1, 5, 1]",
+                      "[null, 100, 127, null, -20]");
+    // Scalar exponentiated by array
+    this->AssertBinop(Power, 11, "[null, 1, null, 2]", "[null, 11, null, 121]");
+    // Array exponentiated by scalar
+    this->AssertBinop(Power, "[null, 1, 3, null, 2]", 3, "[null, 1, 27, null, 8]");
+    // Scalar exponentiated by scalar
+    this->AssertBinop(Power, 16, 1, 16);
+    // Edge cases
+    this->AssertBinop(Power, "[1, 0, -1, 2]", "[0, 42, 0, 1]", "[1, 0, 1, 2]");
+    // Divide by zero raises
+    this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1),
+                            "integers to negative integer powers are not allowed");
     // Overflow raises
     this->SetOverflowCheck(true);
     this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
-    // Disable overflow check
-    this->SetOverflowCheck(false);
-    this->AssertBinop(Power, max, 10, 1);
   }
+
+  // Overflow raises
+  this->SetOverflowCheck(true);
+  this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
+  // Disable overflow check
+  this->SetOverflowCheck(false);
+  this->AssertBinop(Power, max, 10, 1);
 }
 
 TYPED_TEST(TestBinaryArithmeticFloating, Sub) {

From 691c64470417aed9ebf9bcd298879def616c5863 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 7 Apr 2021 13:07:27 +0200
Subject: [PATCH 14/21] std::pow and UBSAN fix

---
 cpp/src/arrow/compute/api_scalar.cc                    |  3 +--
 cpp/src/arrow/compute/kernels/scalar_arithmetic.cc     | 10 ++--------
 .../arrow/compute/kernels/scalar_arithmetic_test.cc    |  6 +++---
 3 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 58d6afc0891..d169fd2ebde 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -44,8 +44,7 @@ namespace compute {
 #define SCALAR_ARITHMETIC_BINARY(NAME, REGISTRY_NAME, REGISTRY_CHECKED_NAME)           \
   Result<Datum> NAME(const Datum& left, const Datum& right, ArithmeticOptions options, \
                      ExecContext* ctx) {                                               \
-    std::string func_name =                                                            \
-        (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME;              \
+    auto func_name = (options.check_overflow) ? REGISTRY_CHECKED_NAME : REGISTRY_NAME; \
     return CallFunction(func_name, {left, right}, ctx);                                \
   }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index c33f414c389..b4d8311f6a9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -254,7 +254,7 @@ inline T integer_power(KernelContext* ctx, T left, T right) {
     if (!right) {
       break;
     }
-    left *= left;
+    left = to_unsigned(left) * to_unsigned(left);
   }
   return result;
 }
@@ -288,13 +288,7 @@ inline T integer_power_checked(KernelContext* ctx, Arg0 left, Arg1 right) {
 
 template <typename T, typename Arg0, typename Arg1>
 inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
-  if (left == 0 && right < 0) {
-    ctx->SetStatus(Status::Invalid("divide by zero"));
-  }
-  if (left == 0 && right != 0) {
-    return 0;
-  }
-  return pow(left, right);
+  return std::pow(left, right);
 }
 
 struct Power {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 70e175b5e53..7512e7848d0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -619,8 +619,8 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
     this->AssertBinop(Power, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
     // Scalar exponentiated by scalar
     this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
-    // Divide by zero raises
-    this->AssertBinopRaises(Power, MakeArray(0.0), MakeArray(-1.0), "divide by zero");
+    // Divide by zero
+    this->AssertBinop(Power, "[0.0, 0.0]", "[-1.0, -3.0]", "[Inf, Inf]");
     // Check overflow behaviour
     this->AssertBinop(Power, max, 10, INFINITY);
   }
@@ -628,7 +628,7 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
   // Edge cases - removing NaNs
   this->AssertBinop(Power, "[1, NaN, 0, null, 1.2, -Inf, Inf, 1.1, 1, 0, 1, 0]",
                     "[NaN, 0, NaN, 1, null, 1, 2, -Inf, Inf, 0, 0, 42]",
-                    "[1, 1, 0, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
+                    "[1, 1, NaN, null, null, -Inf, Inf, 0, 1, 1, 1, 0]");
 }
 
 TYPED_TEST(TestBinaryArithmeticIntegral, Power) {

From a5f24696060f07b6cf72752dc11cee7e3ab01304 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 7 Apr 2021 13:19:17 +0200
Subject: [PATCH 15/21] Minor change to tests.

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 7512e7848d0..9481ea66f5d 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -593,6 +593,7 @@ TYPED_TEST(TestBinaryArithmeticSigned, DivideOverflowRaises) {
 TYPED_TEST(TestBinaryArithmeticFloating, Power) {
   using CType = typename TestFixture::CType;
   auto max = std::numeric_limits<CType>::max();
+  this->SetNansEqual(true);
 
   for (auto check_overflow : {false, true}) {
     this->SetOverflowCheck(check_overflow);
@@ -615,7 +616,6 @@ TYPED_TEST(TestBinaryArithmeticFloating, Power) {
     this->AssertBinop(Power, "[3.4, Inf, -Inf, 1.1, 100000]", "[1, 2, 3, Inf, 100000]",
                       "[3.4, Inf, -Inf, Inf, Inf]");
     // Array with NaN
-    this->SetNansEqual(true);
     this->AssertBinop(Power, "[3.4, NaN, 2.0]", "[1, 2, 2.0]", "[3.4, NaN, 4.0]");
     // Scalar exponentiated by scalar
     this->AssertBinop(Power, 21.0F, 3.0F, 9261.0F);
@@ -670,8 +670,10 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
   for (auto check_overflow : {false, true}) {
     this->SetOverflowCheck(check_overflow);
 
+    // Empty arrays
+    this->AssertBinop(Power, "[]", "[]", "[]");
     // Ordinary arrays
-    this->AssertBinop(Power, "[-3, 2, -6]", "[1, 1, 2]", "[-3, 2, 36]");
+    this->AssertBinop(Power, "[-3, 2, -6, 2]", "[1, 1, 2, 0]", "[-3, 2, 36, 1]");
     // Array with nulls
     this->AssertBinop(Power, "[null, 10, 127, null, -20]", "[1, 2, 1, 5, 1]",
                       "[null, 100, 127, null, -20]");
@@ -686,9 +688,6 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
     // Divide by zero raises
     this->AssertBinopRaises(Power, MakeArray(0), MakeArray(-1),
                             "integers to negative integer powers are not allowed");
-    // Overflow raises
-    this->SetOverflowCheck(true);
-    this->AssertBinopRaises(Power, MakeArray(max), MakeArray(10), "overflow");
   }
 
   // Overflow raises

From 3b3d291534216006cb2f8b6176adac035f6b558e Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 7 Apr 2021 14:28:25 +0200
Subject: [PATCH 16/21] MultiplyWithOverflow

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index b4d8311f6a9..95fdb77b7e5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -20,7 +20,6 @@
 #include "arrow/compute/kernels/common.h"
 #include "arrow/util/int_util_internal.h"
 #include "arrow/util/macros.h"
-#include "arrow/util/type_traits.h"
 
 namespace arrow {
 
@@ -248,13 +247,13 @@ inline T integer_power(KernelContext* ctx, T left, T right) {
   }
   while (true) {
     if (right % 2) {
-      result *= left;
+      MultiplyWithOverflow(result, left, &result);
     }
     right /= 2;
     if (!right) {
       break;
     }
-    left = to_unsigned(left) * to_unsigned(left);
+    MultiplyWithOverflow(left, left, &left);
   }
   return result;
 }

From ce1fc7c98df121a316cf31f84b21d4c24233d64a Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 8 Apr 2021 00:57:59 +0200
Subject: [PATCH 17/21] Removing MultiplyWithOverflow.

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 95fdb77b7e5..29d50600413 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -247,13 +247,13 @@ inline T integer_power(KernelContext* ctx, T left, T right) {
   }
   while (true) {
     if (right % 2) {
-      MultiplyWithOverflow(result, left, &result);
+      result *= left;
     }
     right /= 2;
     if (!right) {
       break;
     }
-    MultiplyWithOverflow(left, left, &left);
+    left *= left;
   }
   return result;
 }

From 7a1deb19ac203d38379ef9d595b059606a657096 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 8 Apr 2021 12:10:14 +0200
Subject: [PATCH 18/21] Changing signed multiplication.

---
 .../arrow/compute/kernels/scalar_arithmetic.cc | 18 ++++++++++++++++--
 .../compute/kernels/scalar_arithmetic_test.cc  |  2 +-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 29d50600413..f91abbdb0e2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -247,13 +247,13 @@ inline T integer_power(KernelContext* ctx, T left, T right) {
   }
   while (true) {
     if (right % 2) {
-      result *= left;
+      result = to_unsigned(result) * to_unsigned(left);
     }
     right /= 2;
     if (!right) {
       break;
     }
-    left *= left;
+    left = to_unsigned(left) * to_unsigned(left);
   }
   return result;
 }
@@ -305,6 +305,20 @@ struct Power {
   static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
     return power<T>(ctx, left, right);
   }
+
+  // See comment about 16 bit integer multiplication in Multiply kernel.
+  template <typename T = void>
+  static int16_t Call(KernelContext* ctx, int16_t left, int16_t right) {
+    if (right < 0) {
+      ctx->SetStatus(
+          Status::Invalid("integers to negative integer powers are not allowed"));
+    }
+    return integer_power(ctx, static_cast<uint32_t>(left), static_cast<uint32_t>(right));
+  }
+  template <typename T = void>
+  static uint16_t Call(KernelContext* ctx, uint16_t left, uint16_t right) {
+    return integer_power(ctx, static_cast<uint32_t>(left), static_cast<uint32_t>(right));
+  }
 };
 
 struct PowerChecked {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 9481ea66f5d..cd5f298ae51 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -673,7 +673,7 @@ TYPED_TEST(TestBinaryArithmeticSigned, Power) {
     // Empty arrays
     this->AssertBinop(Power, "[]", "[]", "[]");
     // Ordinary arrays
-    this->AssertBinop(Power, "[-3, 2, -6, 2]", "[1, 1, 2, 0]", "[-3, 2, 36, 1]");
+    this->AssertBinop(Power, "[-3, 2, -6, 2]", "[3, 1, 2, 0]", "[-27, 2, 36, 1]");
     // Array with nulls
     this->AssertBinop(Power, "[null, 10, 127, null, -20]", "[1, 2, 1, 5, 1]",
                       "[null, 100, 127, null, -20]");

From 395099beb647bd3423699e7e31cf41e92df24dd7 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 8 Apr 2021 16:52:22 +0200
Subject: [PATCH 19/21] Adding a safer integer_power fucntion.

---
 .../compute/kernels/scalar_arithmetic.cc      | 25 ++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index f91abbdb0e2..3b4585fd042 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -237,6 +237,29 @@ struct DivideChecked {
 
 template <typename T>
 inline T integer_power(KernelContext* ctx, T left, T right) {
+  if (right < 0) {
+    ctx->SetStatus(
+        Status::Invalid("integers to negative integer powers are not allowed"));
+  }
+  T result = 1;
+  if (left == 0 && right != 0) {
+    return 0;
+  }
+  while (true) {
+    if (right % 2) {
+      result *= left;
+    }
+    right /= 2;
+    if (!right) {
+      break;
+    }
+    left *= left;
+  }
+  return result;
+}
+
+template <typename T>
+inline T signed_integer_power(KernelContext* ctx, T left, T right) {
   if (right < 0) {
     ctx->SetStatus(
         Status::Invalid("integers to negative integer powers are not allowed"));
@@ -298,7 +321,7 @@ struct Power {
 
   template <typename T>
   static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return integer_power<T>(ctx, left, right);
+    return signed_integer_power<T>(ctx, left, right);
   }
 
   template <typename T>

From 822f016f920aa5c9bfe5883dd1e3de2df9915330 Mon Sep 17 00:00:00 2001
From: Yibo Cai <yibo.cai@arm.com>
Date: Tue, 13 Apr 2021 02:00:40 +0000
Subject: [PATCH 20/21] code refine

---
 cpp/src/arrow/compute/api_scalar.h            |  11 +-
 .../compute/kernels/scalar_arithmetic.cc      | 170 ++++++------------
 2 files changed, 56 insertions(+), 125 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 09d3bb69b99..6032f656c4a 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -205,15 +205,14 @@ Result<Datum> Divide(const Datum& left, const Datum& right,
                      ExecContext* ctx = NULLPTR);
 
 /// \brief Raise the values of base array to the power of the exponent array values.
-/// Array values must be the same length. Base value 0 with negative integer exponent
-/// will raise divide by zero error. Nulls can be removed when base is 0 or 1 or when
-/// exponent is 0.
+/// Array values must be the same length. If either base or exponent is null the result
+/// will be null.
 ///
 /// \param[in] left the base
 /// \param[in] right the exponent
-/// \param[in] options arithmetic options (enable/disable overflow checking and null
-/// removal), optional \param[in] ctx the function execution context, optional \return the
-/// elementwise base value raised to the power of exponent
+/// \param[in] options arithmetic options (enable/disable overflow checking), optional
+/// \param[in] ctx the function execution context, optional
+/// \return the elementwise base value raised to the power of exponent
 ARROW_EXPORT
 Result<Datum> Power(const Datum& left, const Datum& right,
                     ArithmeticOptions options = ArithmeticOptions(),
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 3b4585fd042..667a557eb45 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -235,132 +235,67 @@ struct DivideChecked {
   }
 };
 
-template <typename T>
-inline T integer_power(KernelContext* ctx, T left, T right) {
-  if (right < 0) {
-    ctx->SetStatus(
-        Status::Invalid("integers to negative integer powers are not allowed"));
-  }
-  T result = 1;
-  if (left == 0 && right != 0) {
-    return 0;
-  }
-  while (true) {
-    if (right % 2) {
-      result *= left;
-    }
-    right /= 2;
-    if (!right) {
-      break;
-    }
-    left *= left;
-  }
-  return result;
-}
-
-template <typename T>
-inline T signed_integer_power(KernelContext* ctx, T left, T right) {
-  if (right < 0) {
-    ctx->SetStatus(
-        Status::Invalid("integers to negative integer powers are not allowed"));
-  }
-  T result = 1;
-  if (left == 0 && right != 0) {
-    return 0;
-  }
-  while (true) {
-    if (right % 2) {
-      result = to_unsigned(result) * to_unsigned(left);
-    }
-    right /= 2;
-    if (!right) {
-      break;
-    }
-    left = to_unsigned(left) * to_unsigned(left);
-  }
-  return result;
-}
-
-template <typename T, typename Arg0, typename Arg1>
-inline T integer_power_checked(KernelContext* ctx, Arg0 left, Arg1 right) {
-  if (right < 0) {
-    ctx->SetStatus(
-        Status::Invalid("integers to negative integer powers are not allowed"));
-  }
-  T result = 1;
-  if (left == 0 && right != 0) {
-    return 0;
-  }
-  while (true) {
-    if (right % 2) {
-      if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, left, &result))) {
-        ctx->SetStatus(Status::Invalid("overflow"));
-      }
-    }
-    right /= 2;
-    if (!right) {
-      break;
-    }
-    if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(left, left, &left))) {
-      ctx->SetStatus(Status::Invalid("overflow"));
-    }
-  }
-  return result;
-}
-
-template <typename T, typename Arg0, typename Arg1>
-inline T power(KernelContext* ctx, Arg0 left, Arg1 right) {
-  return std::pow(left, right);
-}
-
 struct Power {
-  template <typename T>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return integer_power<T>(ctx, left, right);
-  }
-
-  template <typename T>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, T left, T right) {
-    return signed_integer_power<T>(ctx, left, right);
+  ARROW_NOINLINE
+  static uint64_t IntegerPower(uint64_t base, uint64_t exp) {
+    // right to left O(logn) power
+    uint64_t pow = 1;
+    while (exp) {
+      pow *= (exp & 1) ? base : 1;
+      base *= base;
+      exp >>= 1;
+    }
+    return pow;
   }
 
   template <typename T>
-  static enable_if_floating_point<T> Call(KernelContext* ctx, T left, T right) {
-    return power<T>(ctx, left, right);
-  }
-
-  // See comment about 16 bit integer multiplication in Multiply kernel.
-  template <typename T = void>
-  static int16_t Call(KernelContext* ctx, int16_t left, int16_t right) {
-    if (right < 0) {
+  static enable_if_integer<T> Call(KernelContext* ctx, T base, T exp) {
+    if (exp < 0) {
       ctx->SetStatus(
           Status::Invalid("integers to negative integer powers are not allowed"));
+      return 0;
     }
-    return integer_power(ctx, static_cast<uint32_t>(left), static_cast<uint32_t>(right));
+    return static_cast<T>(IntegerPower(base, exp));
   }
-  template <typename T = void>
-  static uint16_t Call(KernelContext* ctx, uint16_t left, uint16_t right) {
-    return integer_power(ctx, static_cast<uint32_t>(left), static_cast<uint32_t>(right));
+
+  template <typename T>
+  static enable_if_floating_point<T> Call(KernelContext* ctx, T base, T exp) {
+    return std::pow(base, exp);
   }
 };
 
 struct PowerChecked {
-  template <typename T = void, typename Arg0 = void, typename Arg1 = void>
-  static enable_if_unsigned_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return integer_power_checked<T>(ctx, left, right);
-  }
-
-  template <typename T = void, typename Arg0 = void, typename Arg1 = void>
-  static enable_if_signed_integer<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return integer_power_checked<T>(ctx, left, right);
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer<T> Call(KernelContext* ctx, Arg0 base, Arg1 exp) {
+    if (exp < 0) {
+      ctx->SetStatus(
+          Status::Invalid("integers to negative integer powers are not allowed"));
+      return 0;
+    } else if (exp == 0) {
+      return 1;
+    }
+    // left to right O(logn) power with overflow checks
+    bool overflow = false;
+    uint64_t bitmask =
+        1ULL << (63 - BitUtil::CountLeadingZeros(static_cast<uint64_t>(exp)));
+    T pow = 1;
+    while (bitmask) {
+      overflow |= MultiplyWithOverflow(pow, pow, &pow);
+      if (exp & bitmask) {
+        overflow |= MultiplyWithOverflow(pow, base, &pow);
+      }
+      bitmask >>= 1;
+    }
+    if (overflow) {
+      ctx->SetStatus(Status::Invalid("overflow"));
+    }
+    return pow;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 left, Arg1 right) {
+  static enable_if_floating_point<T> Call(KernelContext* ctx, Arg0 base, Arg1 exp) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return power<T>(ctx, left, right);
+    return std::pow(base, exp);
   }
 };
 
@@ -492,18 +427,15 @@ const FunctionDoc div_checked_doc{
 
 const FunctionDoc pow_doc{
     "Raise arguments to power element-wise",
-    ("Raising zero to negative integer returns an error. However, integer overflow\n"
-     "wraps around, and floating-point raising zero to negative integer returns an"
-     "infinite.\n"
-     "Use function \"power_checked_propagate_nulls\" if you want to get an error\n"
-     "in all the aforementioned cases."),
-    {"base", "power"}};
+    ("Integer to negative integer power returns an error. However, integer overflow\n"
+     "wraps around. Floating poing power follows std::pow() behaviour.\n"),
+    {"base", "exponent"}};
 
 const FunctionDoc pow_checked_doc{
     "Raise arguments to power element-wise",
-    ("An error is returned when trying to raise zero to negative integer, or when\n"
-     "integer overflow is encountered."),
-    {"base", "power"}};
+    ("An error is returned when integer to negative integer power is encountered,\n"
+     "or integer overflow is encountered."),
+    {"base", "exponent"}};
 
 }  // namespace
 

From 0ab2ebed26681789b1d9f1753d10fd29365821ca Mon Sep 17 00:00:00 2001
From: Yibo Cai <yibo.cai@arm.com>
Date: Tue, 13 Apr 2021 07:28:40 +0000
Subject: [PATCH 21/21] fix docstring

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

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 667a557eb45..260721b08d9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -428,7 +428,7 @@ const FunctionDoc div_checked_doc{
 const FunctionDoc pow_doc{
     "Raise arguments to power element-wise",
     ("Integer to negative integer power returns an error. However, integer overflow\n"
-     "wraps around. Floating poing power follows std::pow() behaviour.\n"),
+     "wraps around. If either base or exponent is null the result will be null."),
     {"base", "exponent"}};
 
 const FunctionDoc pow_checked_doc{