feature/prefix-sum (#30)

* init prefix sum lib

* change version

* moved prefix sum lib to array helper lib

* typos

* added prefix sum methods to mock

* added range check & coverage 100%

* typo

* rm range checks

Author: dovgopoly

contracts/contracts-registry/AbstractContractsRegistry.sol

@@ -65,7 +65,7 @@ abstract contract AbstractContractsRegistry is Initializable {
     }
 
     /**
-     *  @notice The function that check if a contract with a given name has been added
+     *  @notice The function that checks if a contract with a given name has been added
      *  @param name_ the name of the contract
      *  @return true if the contract is present in the registry
      */

contracts/libs/arrays/ArrayHelper.sol

@@ -102,4 +102,45 @@ library ArrayHelper {
         array_ = new string[](1);
         array_[0] = elem_;
     }
+
+    /**
+     *  @notice The function to compute the prefix sum array
+     *  @param arr_ the initial array to be turned into the prefix sum array
+     *  @return prefixes_ the prefix sum array
+     */
+    function countPrefixes(
+        uint256[] memory arr_
+    ) internal pure returns (uint256[] memory prefixes_) {
+        if (arr_.length == 0) {
+            return prefixes_;
+        }
+
+        prefixes_ = new uint256[](arr_.length);
+        prefixes_[0] = arr_[0];
+
+        for (uint256 i = 1; i < prefixes_.length; i++) {
+            prefixes_[i] = prefixes_[i - 1] + arr_[i];
+        }
+    }
+
+    /**
+     *  @notice The function that calculates the sum of all array elements from `beginIndex_` to
+     *  `endIndex_` inclusive using its prefix sum array
+     *  @param beginIndex_ the index of the first range element
+     *  @param endIndex_ the index of the last range element
+     *  @return the sum of all elements of the range
+     */
+    function getRangeSum(
+        uint256[] memory prefixes_,
+        uint256 beginIndex_,
+        uint256 endIndex_
+    ) internal pure returns (uint256) {
+        require(beginIndex_ <= endIndex_, "ArrayHelper: wrong range");
+
+        if (beginIndex_ == 0) {
+            return prefixes_[endIndex_];
+        }
+
+        return prefixes_[endIndex_] - prefixes_[beginIndex_ - 1];
+    }
 }

contracts/mock/libs/arrays/ArrayHelperMock.sol

@@ -53,4 +53,16 @@ contract ArrayHelperMock {
     function asArrayString(string memory elem_) external pure returns (string[] memory array_) {
         return elem_.asArray();
     }
+
+    function countPrefixes(uint256[] memory arr_) external pure returns (uint256[] memory) {
+        return arr_.countPrefixes();
+    }
+
+    function getRangeSum(
+        uint256[] memory arr_,
+        uint256 beginIndex_,
+        uint256 endIndex_
+    ) external pure returns (uint256) {
+        return arr_.countPrefixes().getRangeSum(beginIndex_, endIndex_);
+    }
 }

test/libs/arrays/ArrayHelper.test.js

@@ -117,4 +117,47 @@ describe("ArrayHelperMock", () => {
       assert.deepEqual(await mock.asArrayString("1"), ["1"]);
     });
   });
+
+  describe("prefix sum array", () => {
+    function getArraySum(arr) {
+      return arr.reduce((prev, cur) => prev + cur, 0);
+    }
+
+    function countPrefixes(arr) {
+      return arr.map((e, idx) => getArraySum(arr.slice(0, idx + 1)));
+    }
+
+    const array = [0, 100, 50, 4, 34, 520, 4];
+
+    describe("countPrefixes", () => {
+      it("should compute prefix array properly", async () => {
+        assert.deepEqual(await mock.countPrefixes([]), []);
+        assert.deepEqual(
+          (await mock.countPrefixes(array)).map((e) => e.toNumber()),
+          countPrefixes(array)
+        );
+      });
+    });
+
+    describe("getRangeSum", () => {
+      it("should get the range sum properly if all conditions are met", async () => {
+        for (let l = 0; l < array.length; l++) {
+          for (let r = l; r < array.length; r++) {
+            assert.equal((await mock.getRangeSum(array, l, r)).toNumber(), getArraySum(array.slice(l, r + 1)));
+          }
+        }
+      });
+
+      it("should revert if the first index is greater than the last one", async () => {
+        await truffleAssert.reverts(mock.getRangeSum(array, array.length - 1, 0), "ArrayHelper: wrong range");
+        await truffleAssert.reverts(mock.getRangeSum(array, 1, 0), "ArrayHelper: wrong range");
+        await truffleAssert.reverts(mock.getRangeSum(array, 2, 1), "ArrayHelper: wrong range");
+      });
+
+      it("should revert if one of the indexes is out of range", async () => {
+        await truffleAssert.reverts(mock.getRangeSum([], 0, 0));
+        await truffleAssert.reverts(mock.getRangeSum(array, 0, array.length));
+      });
+    });
+  });
 });