The pow function optimized

Author: 3sGgpQ8H

ABDKMath64x64.sol

@@ -326,25 +326,76 @@ library ABDKMath64x64 {
    * @return signed 64.64-bit fixed point number
    */
   function pow (int128 x, uint256 y) internal pure returns (int128) {
-    uint256 absoluteResult;
-    bool negativeResult = false;
-    if (x >= 0) {
-      absoluteResult = powu (uint256 (x) << 63, y);
-    } else {
-      // We rely on overflow behavior here
-      absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
-      negativeResult = y & 1 > 0;
-    }
+    bool negative = x < 0 && y & 1 == 1;
 
-    absoluteResult >>= 63;
+    uint256 absX = uint128 (x < 0 ? -x : x);
+    uint256 absResult;
+    absResult = 0x100000000000000000000000000000000;
 
-    if (negativeResult) {
-      require (absoluteResult <= 0x80000000000000000000000000000000);
-      return -int128 (absoluteResult); // We rely on overflow behavior here
+    if (absX <= 0x10000000000000000) {
+      absX <<= 63;
+      while (y != 0) {
+        if (y & 0x1 != 0) {
+          absResult = absResult * absX >> 127;
+        }
+        absX = absX * absX >> 127;
+
+        if (y & 0x2 != 0) {
+          absResult = absResult * absX >> 127;
+        }
+        absX = absX * absX >> 127;
+
+        if (y & 0x4 != 0) {
+          absResult = absResult * absX >> 127;
+        }
+        absX = absX * absX >> 127;
+
+        if (y & 0x8 != 0) {
+          absResult = absResult * absX >> 127;
+        }
+        absX = absX * absX >> 127;
+
+        y >>= 4;
+      }
+
+      absResult >>= 64;
     } else {
-      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-      return int128 (absoluteResult); // We rely on overflow behavior here
+      uint256 absXShift = 63;
+      if (absX < 0x1000000000000000000000000) { absX <<= 32; absXShift -= 32; }
+      if (absX < 0x10000000000000000000000000000) { absX <<= 16; absXShift -= 16; }
+      if (absX < 0x1000000000000000000000000000000) { absX <<= 8; absXShift -= 8; }
+      if (absX < 0x10000000000000000000000000000000) { absX <<= 4; absXShift -= 4; }
+      if (absX < 0x40000000000000000000000000000000) { absX <<= 2; absXShift -= 2; }
+      if (absX < 0x80000000000000000000000000000000) { absX <<= 1; absXShift -= 1; }
+
+      uint256 resultShift = 0;
+      while (y != 0) {
+        require (absXShift < 64);
+
+        if (y & 0x1 != 0) {
+          absResult = absResult * absX >> 127;
+          resultShift += absXShift;
+          if (absResult > 0x100000000000000000000000000000000) {
+            absResult >>= 1;
+            resultShift += 1;
+          }
+        }
+        absX = absX * absX >> 127;
+        absXShift <<= 1;
+        if (absX >= 0x100000000000000000000000000000000) {
+            absX >>= 1;
+            absXShift += 1;
+        }
+
+        y >>= 1;
+      }
+
+      require (resultShift < 64);
+      absResult >>= 64 - resultShift;
     }
+    int256 result = negative ? -int256 (absResult) : int256 (absResult);
+    require (result >= MIN_64x64 && result <= MAX_64x64);
+    return int128 (result);
   }
 
   /**
@@ -614,69 +665,6 @@ library ABDKMath64x64 {
     return uint128 (result);
   }
 
-  /**
-   * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
-   * number and y is unsigned 256-bit integer number.  Revert on overflow.
-   *
-   * @param x unsigned 129.127-bit fixed point number
-   * @param y uint256 value
-   * @return unsigned 129.127-bit fixed point number
-   */
-  function powu (uint256 x, uint256 y) private pure returns (uint256) {
-    if (y == 0) return 0x80000000000000000000000000000000;
-    else if (x == 0) return 0;
-    else {
-      int256 msb = 0;
-      uint256 xc = x;
-      if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; }
-      if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
-      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
-      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
-      if (xc >= 0x100) { xc >>= 8; msb += 8; }
-      if (xc >= 0x10) { xc >>= 4; msb += 4; }
-      if (xc >= 0x4) { xc >>= 2; msb += 2; }
-      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore
-
-      int256 xe = msb - 127;
-      if (xe > 0) x >>= uint256 (xe);
-      else x <<= uint256 (-xe);
-
-      uint256 result = 0x80000000000000000000000000000000;
-      int256 re = 0;
-
-      while (y > 0) {
-        if (y & 1 > 0) {
-          result = result * x;
-          y -= 1;
-          re += xe;
-          if (result >=
-            0x8000000000000000000000000000000000000000000000000000000000000000) {
-            result >>= 128;
-            re += 1;
-          } else result >>= 127;
-          if (re < -127) return 0; // Underflow
-          require (re < 128); // Overflow
-        } else {
-          x = x * x;
-          y >>= 1;
-          xe <<= 1;
-          if (x >=
-            0x8000000000000000000000000000000000000000000000000000000000000000) {
-            x >>= 128;
-            xe += 1;
-          } else x >>= 127;
-          if (xe < -127) return 0; // Underflow
-          require (xe < 128); // Overflow
-        }
-      }
-
-      if (re > 0) result <<= uint256 (re);
-      else if (re < 0) result >>= uint256 (-re);
-
-      return result;
-    }
-  }
-
   /**
    * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
    * number.