misc: cleanup

misc: cleanup

distribution/std-lib/Standard/src/Base/Data/Vector.enso

@@ -398,28 +398,6 @@ type Vector
         len = Math.min this.length that.length
         here.new len i-> function (this.at i) (that.at i)
 
-    ## Performs a pair-wise operation passed in `function` on consecutive
-       elements of `this` and `that`. The `function` is applied only when the
-       corresponding element exists in `that` vector.
-       The result of this function is a vector of `this` length.
-       > Example
-         To pairwise-sum two vectors:
-             [1, 2, 3].zip_1 [4, 5, 6] (+) == [5, 7, 9]
-       > Example
-         To pairwise-sum two vectors, when `this` is longer:
-             [1, 2, 3, 4].zip_1 [4, 5, 6] (+) == [5, 7, 9, 4]
-       > Example
-         To pairwise-sum two vectors, when `that` is longer:
-             [1, 2, 3].zip_1 [4, 5, 6, 7] (+) == [5, 7, 9]
-       > Example
-         To pairwise-sum two vectors, when `that` is empty:
-             [1, 2, 3].zip_1 [] (+) == [1, 2, 3]
-    zip_1 : Vector -> (Any -> Any -> Any) -> Vector
-    zip_1 that function=[_, _] =
-        that_len = that.length
-        here.new this.length i->
-           if that_len <= i then this.at i else function (this.at i) (that.at i)
-
     ## Extend `this` vector to the length of `n` appending elements `elem` to
        the end. If the new length `n` is less than existing length, `this`
        vector is returned.

std-bits/src/main/java/org/enso/image/data/Matrix.java

@@ -113,6 +113,13 @@ public static double[] get(Mat mat, int row, int column) {
     return data;
   }
 
+  /**
+   * Per-element addition of two matrices.
+   *
+   * @param mat1 the first matrix to add.
+   * @param mat2 the second matrix to add.
+   * @param dst the matrix holding the result of the operation.
+   */
   public static void add(Mat mat1, Mat mat2, Mat dst) {
     Core.add(mat1, mat2, dst);
   }
@@ -128,6 +135,13 @@ public static void add(Mat mat, Scalar scalar, Mat dst) {
     Core.add(mat, scalar, dst);
   }
 
+  /**
+   * Per-element subtraction of two matrices.
+   *
+   * @param mat1 the first matrix to subtract from.
+   * @param mat2 the second matrix to subtract.
+   * @param dst the matrix holding the result of the operation.
+   */
   public static void subtract(Mat mat1, Mat mat2, Mat dst) {
     Core.subtract(mat1, mat2, dst);
   }
@@ -142,6 +156,13 @@ public static void subtract(Mat mat, Scalar scalar, Mat dst) {
     Core.subtract(mat, scalar, dst);
   }
 
+  /**
+   * Per-element multiplication of two matrices.
+   *
+   * @param mat1 the first matrix to multiply.
+   * @param mat2 the second matrix to multiply.
+   * @param dst the matrix holding the result of the operation.
+   */
   public static void multiply(Mat mat1, Mat mat2, Mat dst) {
     Core.multiply(mat1, mat2, dst);
   }
@@ -156,6 +177,13 @@ public static void multiply(Mat mat, Scalar scalar, Mat dst) {
     Core.multiply(mat, scalar, dst);
   }
 
+  /**
+   * Per-element division of two matrices.
+   *
+   * @param mat1 the dividend matrix.
+   * @param mat2 the divisor matrix.
+   * @param dst the matrix holding the result of the operation.
+   */
   public static void divide(Mat mat1, Mat mat2, Mat dst) {
     Core.divide(mat1, mat2, dst);
   }

test/Tests/src/Data/Vector_Spec.enso

@@ -180,12 +180,6 @@ spec = Test.group "Vectors" <|
         [1, 2, 3].zip [4, 5, 6] (+) . should_equal [5, 7, 9]
         [1, 2, 3].zip [4, 5, 6, 7] (+) . should_equal [5, 7, 9]
         [].zip [4, 5, 6] (+) . should_equal []
-    Test.specify "should zip_1 elements" <|
-        [1, 2, 3].zip_1 [] (+) . should_equal [1, 2, 3]
-        [1, 2, 3].zip_1 [4] (+) . should_equal [5, 2, 3]
-        [1, 2, 3].zip_1 [4, 5, 6] (+) . should_equal [5, 7, 9]
-        [1, 2, 3].zip_1 [4, 5, 6, 7] (+) . should_equal [5, 7, 9]
-        [].zip_1 [4, 5, 6] (+) . should_equal []
     Test.specify "should flat_map elements" <|
         [1, 2, 3].flat_map (_ -> []) . should_equal []
         [1, 2, 3].flat_map (_ -> [0, 1]) . should_equal [0, 1, 0, 1, 0, 1]