[APFloat] add power

[ImanHosseini]

No description provided.

[llvmbot]

@llvm/pr-subscribers-llvm-adt

Author: Iman Hosseini (ImanHosseini)

Changes

---

Full diff: https://github.com/llvm/llvm-project/pull/122889.diff

2 Files Affected:

• (modified) llvm/include/llvm/ADT/APFloat.h (+21)
• (modified) llvm/unittests/ADT/APFloatTest.cpp (+15)

diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h
index 9792749230cbf9..803949cf9abcbf 100644
--- a/llvm/include/llvm/ADT/APFloat.h
+++ b/llvm/include/llvm/ADT/APFloat.h
@@ -1536,6 +1536,27 @@ inline APFloat abs(APFloat X) {
   return X;
 }
 
+/// Returns X^N for N >= 0.
+/// Returns X^N for N >= 0.
+inline APFloat pow(const APFloat &X, const int &N) {
+  assert(N >= 0 && "negative exponents not supported.");
+  APFloat Acc = APFloat::getOne(X.getSemantics());
+  if (N == 0) {
+    return APFloat::getOne(X.getSemantics());
+  }
+  APFloat Base = X;
+  int64_t RemainingExponent = N;
+  while (RemainingExponent > 0) {
+    while (RemainingExponent % 2 == 0) {
+      Base = Base * Base;
+      RemainingExponent /= 2;
+    }
+    --RemainingExponent;
+    Acc = Acc * Base;
+  }
+  return Acc;
+};
+
 /// Returns the negated value of the argument.
 inline APFloat neg(APFloat X) {
   X.changeSign();
diff --git a/llvm/unittests/ADT/APFloatTest.cpp b/llvm/unittests/ADT/APFloatTest.cpp
index f291c814886d35..0e4fe151af10af 100644
--- a/llvm/unittests/ADT/APFloatTest.cpp
+++ b/llvm/unittests/ADT/APFloatTest.cpp
@@ -3793,6 +3793,21 @@ TEST(APFloatTest, abs) {
   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
 }
 
+TEST(APFloatTest, pow) {
+  APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
+  APFloat Two = APFloat(APFloat::IEEEsingle(), "2.0");
+  APFloat Four = APFloat(APFloat::IEEEsingle(), "4.0");
+  APFloat Eight = APFloat(APFloat::IEEEsingle(), "8.0");
+  APFloat NegTwo = APFloat(APFloat::IEEEsingle(), "-2.0");
+  APFloat NegEight = APFloat(APFloat::IEEEsingle(), "-8.0");
+
+  EXPECT_TRUE(One.bitwiseIsEqual(pow(One, 0)));
+  EXPECT_TRUE(One.bitwiseIsEqual(pow(One, 3)));
+  EXPECT_TRUE(Four.bitwiseIsEqual(pow(Two, 2)));
+  EXPECT_TRUE(Eight.bitwiseIsEqual(pow(Two, 3)));
+  EXPECT_TRUE(NegEight.bitwiseIsEqual(pow(NegTwo, 3)));
+}
+
 TEST(APFloatTest, neg) {
   APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
   APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");

[ImanHosseini]

I am not an expert on float edge cases.
What special case should we test here? @arsenm

[kuhar]

What special case should we test here?

IEEE 754-2019 does list a bunch of edge cases for pown -- we could adopt those.

[jcranmer-intel]

pow is absolutely the wrong name for this function, since there is a standard pow function that this does not implement. powi (which is the LLVM intrinsic name) or pown would work better, though I worry that this is too numerically inaccurate to be a correct implementation of pown.

[ImanHosseini]

Thanks @jcranmer-intel . I will rename to powi.

[kuhar]

pown would work better, though I worry that this is too numerically inaccurate to be a correct implementation of pown

@jcranmer-intel do we have some reference implementation of pown in llvm?

[ImanHosseini]

I don't think we do (even in libc): https://libc.llvm.org/headers/math/index.html

[arsenm]

I don't think we should add this unless it's correctly rounded

[arsenm]

This should canonicalize the value

[ImanHosseini]

For N==0? Can you explain?

[arsenm]

All paths through the function, but yes this one too. Signaling nans should be quieted

[arsenm]

Test the zeroes, the infinities, nan (particularly that signaling nan is quieted with payload preserved in the no-op case). Also largest denormal / smallest normal, largest normal.

[ImanHosseini]

Anything left out? I've added tests covering these.

[github-actions]

✅ With the latest revision this PR passed the C/C++ code formatter.

[kuhar]

Do you have some other usecase in mind other than #122450 ? If not, I don't think we should land this until we agree on that.
I'm going to add a blocking review to make sure we don't accidentally land this.

[ImanHosseini]

@arsenm there are now tests for quieting SNaNs.
Now what should we test for correct rounding?

[ImanHosseini]

gcc's powi builtin: https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#index-_005f_005fbuiltin_005fpowi
: https://github.com/gcc-mirror/gcc/blob/26b2d9f27ca24f0705641a85f29d179fa0600869/libgcc/libgcc2.c#L2582
It is not named pown (to avoid confusion with guarantees that pown makes) but powi, and we aren't committing to any precision or rounding guarantee. Same as with gcc's powi.