Merge pull request #2250 from o1-labs/api/dynamicarray/reverse

DynamicArray support reverse feature

Author: querolita

CHANGELOG.md

@@ -20,6 +20,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Added
 
 - Lazy mode for prover index computation. https://github.com/o1-labs/o1js/pull/2143
+- Added reverse functionality to `DynamicArray` and indexed `forEach` and `forEachReverse` variants.
 - Added `ZkProgram.analyzeSingleMethod(methodName: string)` to analyze a single method of a ZkProgram. https://github.com/o1-labs/o1js/pull/2217
   - This is an addition to `ZkProgram.analyzeMethods()` which analyzes all methods of a ZkProgram by executing them.
   - Now only a single method is analyzed at a time.

src/lib/provable/dynamic-array.ts

@@ -274,12 +274,26 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
    * Iterate over all elements of the array.
    *
    * The callback will be passed an element and a boolean `isDummy` indicating
-   * whether the value is part of the actual array.
+   * whether the value is part of the actual array. Optionally, an index can be
+   * passed as a third argument (used in `forEachReversed`)
    */
-  forEach(f: (t: ProvableValue, isDummy: Bool) => void) {
-    zip(this.array, this.#dummyMask()).forEach(([t, isDummy]) => {
-      f(t, isDummy);
-    });
+  forEach(f: (t: ProvableValue, isDummy: Bool, i?: number) => void): void {
+    zip(this.array, this.#dummyMask()).forEach(([t, isDummy], i) => f(t, isDummy, i));
+  }
+
+  /**
+   * Iterate over all elements of the array, in reverse order.
+   *
+   * The callback will be passed an element and a boolean `isDummy` indicating whether the value is part of the actual array.
+   *
+   * Note: the indices are also passed in reverse order, i.e. we always have `t = this.array[i]`.
+   */
+  forEachReverse(f: (t: ProvableValue, isDummy: Bool, i: number) => void) {
+    zip(this.array, this.#dummyMask())
+      .reverse()
+      .forEach(([t, isDummy], i) => {
+        f(t, isDummy, this.capacity - 1 - i);
+      });
   }
 
   /**
@@ -519,6 +533,21 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
     return sliced;
   }
 
+  /**
+   * Returns a new array with the elements reversed.
+   */
+  reverse(): DynamicArray<ProvableValue, Value> {
+    let Array = DynamicArray(this.innerType, { capacity: this.capacity });
+    // first, copy the inner array of length capacity and reverse it
+    let array = this.array.slice().reverse();
+
+    // now, slice off the padding that is now at the beginning of the array
+    let capacity = new Field(this.capacity);
+    return new Array(array, capacity).slice(
+      capacity.sub(this.length).seal()
+    );
+  }
+
   /**
    * Concatenates the current array with another dynamic array, returning a new
    * dynamic array with the values of both arrays. The capacity of the new array

src/lib/provable/test/dynamic-array.unit-test.ts

@@ -581,6 +581,14 @@ import { Provable } from '../provable.js';
           // Checking inclusion of elements
           assert(bytes.includes(new UInt8(1)));
           assert(bytes.includes(new UInt8(20)).not());
+
+          // Reverse the array
+          let reversed = bytes.reverse();
+          for (let i = 0; i < 8; i++) {
+            assert(reversed.get(new Field(i)).value.equals(new Field(8 - i)));
+            // the original array is not modified
+            assert(bytes.get(new Field(i)).value.equals(new Field(i + 1)));
+          }
         },
       },
     },