Merge pull request #28 from dl-solidity-library/feature/sqrt

feature/sqrt

Author: Arvolear

contracts/libs/math/DSMath.sol

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: ALGPL-3.0-or-later-or-later
 // from https://github.com/makerdao/dss/blob/master/src/jug.sol
+//      https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol
 pragma solidity ^0.8.4;
 
 library DSMath {
@@ -57,4 +58,55 @@ library DSMath {
             }
         }
     }
+
+    /**
+     * @notice The function that computes square roots using the Babylonian method
+     * @dev The original implementation can be found here github.com/abdk-consulting/abdk-libraries-solidity
+     */
+    function sqrt(uint256 x) internal pure returns (uint128) {
+        unchecked {
+            if (x == 0) {
+                return 0;
+            } else {
+                uint256 xx = x;
+                uint256 r = 1;
+                if (xx >= 0x100000000000000000000000000000000) {
+                    xx >>= 128;
+                    r <<= 64;
+                }
+                if (xx >= 0x10000000000000000) {
+                    xx >>= 64;
+                    r <<= 32;
+                }
+                if (xx >= 0x100000000) {
+                    xx >>= 32;
+                    r <<= 16;
+                }
+                if (xx >= 0x10000) {
+                    xx >>= 16;
+                    r <<= 8;
+                }
+                if (xx >= 0x100) {
+                    xx >>= 8;
+                    r <<= 4;
+                }
+                if (xx >= 0x10) {
+                    xx >>= 4;
+                    r <<= 2;
+                }
+                if (xx >= 0x4) {
+                    r <<= 1;
+                }
+                r = (r + x / r) >> 1;
+                r = (r + x / r) >> 1;
+                r = (r + x / r) >> 1;
+                r = (r + x / r) >> 1;
+                r = (r + x / r) >> 1;
+                r = (r + x / r) >> 1;
+                r = (r + x / r) >> 1; // Seven iterations should be enough
+                uint256 r1 = x / r;
+                return uint128(r < r1 ? r : r1);
+            }
+        }
+    }
 }

contracts/mock/libs/math/DSMathMock.sol

@@ -7,4 +7,8 @@ contract DSMathMock {
     function rpow(uint256 x_, uint256 n_, uint256 b_) external pure returns (uint256) {
         return DSMath.rpow(x_, n_, b_);
     }
+
+    function sqrt(uint256 x_) external pure returns (uint256) {
+        return DSMath.sqrt(x_);
+    }
 }

contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dlsl/dev-modules",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "license": "MIT",
   "author": "Distributed Lab",
   "description": "Solidity Development Modules by Distributed Lab",