diff --git a/Tests/NumericAnnexTests/ComplexTests.swift b/Tests/NumericAnnexTests/ComplexTests.swift
index 776d69c..03a6844 100644
--- a/Tests/NumericAnnexTests/ComplexTests.swift
+++ b/Tests/NumericAnnexTests/ComplexTests.swift
@@ -1579,7 +1579,7 @@ class ComplexTests : XCTestCase {
     XCTAssertEqual(b.real, 42, accuracy: 0.00000000000001)
 
     let i: Complex128 = .i
-    let actual = Complex.pow(i, i)
+    let actual = i ** i
     XCTAssertEqual(actual.real, Double.exp(-Double.pi / 2))
     XCTAssertEqual(actual.imaginary, 0)
 
@@ -1813,7 +1813,7 @@ class ComplexTests : XCTestCase {
 
     let g: Complex128 = 1 + .i
     let h: Complex128 =
-      Complex.log(g + Complex.pow(-1, 1 / 4) * Complex.sqrt(2 + .i))
+      Complex.log(g + (-1 ** (1 / 4)) * Complex.sqrt(2 + .i))
     XCTAssertEqual(Complex.acosh(g).real, h.real)
     XCTAssertEqual(Complex.acosh(g).imaginary, h.imaginary)
 
diff --git a/Tests/NumericAnnexTests/ExponentiationTests.swift b/Tests/NumericAnnexTests/ExponentiationTests.swift
index 74d415d..ca990c7 100644
--- a/Tests/NumericAnnexTests/ExponentiationTests.swift
+++ b/Tests/NumericAnnexTests/ExponentiationTests.swift
@@ -6,13 +6,12 @@ class ExponentiationTests : XCTestCase {
     for i in -21...21 {
       for j in -7...7 {
         if i == 0 && j < 0 {
-          // In this case, Int.pow(i, j) causes a division-by-zero error.
-          // Likewise, Double.pow(Double(i), Double(j)) also causes the same
-          // error.
+          // In this case, i ** j causes a division-by-zero error.
+          // Likewise, Double(i) ** Double(j) also causes the same error.
           continue
         }
-        let actual = Int.pow(i, j)
-        let expected = Int(Double.pow(Double(i), Double(j)))
+        let actual = i ** j
+        let expected = Int(Double(i) ** Double(j))
         XCTAssertEqual(actual, expected)
       }
     }
@@ -21,8 +20,8 @@ class ExponentiationTests : XCTestCase {
   func testUIntPow() {
     for i in (0 as UInt)...21 {
       for j in (0 as UInt)...7 {
-        let actual = UInt.pow(i, j)
-        let expected = UInt(Double.pow(Double(i), Double(j)))
+        let actual = i ** j
+        let expected = UInt(Double(i) ** Double(j))
         XCTAssertEqual(actual, expected)
       }
     }
diff --git a/Tests/NumericAnnexTests/RealTests.swift b/Tests/NumericAnnexTests/RealTests.swift
index 246a99f..e6e8bd4 100644
--- a/Tests/NumericAnnexTests/RealTests.swift
+++ b/Tests/NumericAnnexTests/RealTests.swift
@@ -241,8 +241,12 @@ extension MockReal : FloatingPoint {
 }
 
 extension MockReal : Real {
-  static func pow(_ base: MockReal, _ exponent: MockReal) -> MockReal {
-    return MockReal(Double.pow(base._value, exponent._value))
+  static func ** (lhs: MockReal, rhs: MockReal) -> MockReal {
+    return MockReal(lhs._value ** rhs._value)
+  }
+
+  static func **= (lhs: inout MockReal, rhs: MockReal) {
+    lhs = lhs ** rhs
   }
 
   func naturalExponential() -> MockReal {
@@ -469,15 +473,15 @@ class RealTests: XCTestCase {
   }
 
   func testFloat() {
-    XCTAssertEqual(Float.pow(-2, -3), -0.125)
-    XCTAssertTrue(Float.pow(0, 42).isZero)
-    XCTAssertTrue(Float.pow(0, 42).sign == .plus)
-    XCTAssertTrue(Float.pow(-0.0, 42).isZero)
-    XCTAssertTrue(Float.pow(-0.0, 42).sign == .plus)
-    XCTAssertTrue(Float.pow(0, 43).isZero)
-    XCTAssertTrue(Float.pow(0, 43).sign == .plus)
-    XCTAssertTrue(Float.pow(-0.0, 43).isZero)
-    XCTAssertTrue(Float.pow(-0.0, 43).sign == .minus)
+    XCTAssertEqual(((-2 as Float) ** -3), -0.125)
+    XCTAssertTrue(((0 as Float) ** 42).isZero)
+    XCTAssertTrue(((0 as Float) ** 42).sign == .plus)
+    XCTAssertTrue(((-0.0 as Float) ** 42).isZero)
+    XCTAssertTrue(((-0.0 as Float) ** 42).sign == .plus)
+    XCTAssertTrue(((0 as Float) ** 43).isZero)
+    XCTAssertTrue(((0 as Float) ** 43).sign == .plus)
+    XCTAssertTrue(((-0.0 as Float) ** 43).isZero)
+    XCTAssertTrue(((-0.0 as Float) ** 43).sign == .minus)
 
     XCTAssertEqual(Float.cbrt(64), 4)
     XCTAssertEqual(Float.cbrt(-64), -4)
@@ -606,15 +610,15 @@ class RealTests: XCTestCase {
   }
 
   func testDouble() {
-    XCTAssertEqual(Double.pow(-2, -3), -0.125)
-    XCTAssertTrue(Double.pow(0, 42).isZero)
-    XCTAssertTrue(Double.pow(0, 42).sign == .plus)
-    XCTAssertTrue(Double.pow(-0.0, 42).isZero)
-    XCTAssertTrue(Double.pow(-0.0, 42).sign == .plus)
-    XCTAssertTrue(Double.pow(0, 43).isZero)
-    XCTAssertTrue(Double.pow(0, 43).sign == .plus)
-    XCTAssertTrue(Double.pow(-0.0, 43).isZero)
-    XCTAssertTrue(Double.pow(-0.0, 43).sign == .minus)
+    XCTAssertEqual(((-2 as Double) ** -3), -0.125)
+    XCTAssertTrue(((0 as Double) ** 42).isZero)
+    XCTAssertTrue(((0 as Double) ** 42).sign == .plus)
+    XCTAssertTrue(((-0.0 as Double) ** 42).isZero)
+    XCTAssertTrue(((-0.0 as Double) ** 42).sign == .plus)
+    XCTAssertTrue(((0 as Double) ** 43).isZero)
+    XCTAssertTrue(((0 as Double) ** 43).sign == .plus)
+    XCTAssertTrue(((-0.0 as Double) ** 43).isZero)
+    XCTAssertTrue(((-0.0 as Double) ** 43).sign == .minus)
 
     XCTAssertEqual(Double.cbrt(64), 4)
     XCTAssertEqual(Double.cbrt(-64), -4)