Fixed method names, fixed documentation

Author: tweimer

bin/jama2/Matrix.class

@@ -1518,75 +1518,83 @@ public double trace()
     }
 
     /**
-     * Applys the given operator to all elements, modifying this Matrix.
-     * @param operator Operator to be applied
-     * @throws NullPointerException iff operator == null
+     * Applys the given operator to all elements, returning a new Matrix.
+     * @param operator Operator to be applied to this Matrix and B
+     * @return new Matrix with the result
+     * @throws NullPointerException iff operator == null or B == null
+     * @see {@link #transformEquals(DoubleUnaryOperator)}
+     * to modify this Matrix instead of returning a new one
      */
-    public void transform(final DoubleUnaryOperator operator)
+    public Matrix transform(final DoubleUnaryOperator operator)
     {
+        final Matrix M = new Matrix(this.m, this.n);
         for (int i = 0; i < this.m; i++)
         {
             for (int j = 0; j < this.n; j++)
             {
-                this.A[i][j] = operator.applyAsDouble(this.A[i][j]);
+                M.A[i][j] = operator.applyAsDouble(this.A[i][j]);
             }
         }
+        return M;
     }
 
     /**
-     * Applys the given operator to all elements, returning a new Matrix.
+     * Applys the given operator to all elements, modifying this Matrix.
      * @param operator Operator to be applied
-     * @return new Matrix with the result
      * @throws NullPointerException iff operator == null
+     * @see {@link #transform(DoubleUnaryOperator)}
+     * to return a new Matrix instead of modifying this Matrix
      */
-    public Matrix transformEquals(final DoubleUnaryOperator operator)
+    public void transformEquals(final DoubleUnaryOperator operator)
     {
-        final Matrix M = new Matrix(this.m, this.n);
         for (int i = 0; i < this.m; i++)
         {
             for (int j = 0; j < this.n; j++)
             {
-                M.A[i][j] = operator.applyAsDouble(this.A[i][j]);
+                this.A[i][j] = operator.applyAsDouble(this.A[i][j]);
             }
         }
-        return M;
     }
 
     /**
-     * Applys the given operator to all elements, modifying this Matrix.
+     * Applys the given operator to all elements, returning a new Matrix.
      * @param B another Matrix
      * @param operator Operator to be applied
+     * @return new Matrix with the result
      * @throws NullPointerException iff operator == null
+     * @see {@link #transformEquals(Matrix, DoubleBinaryOperator)}
+     * to modify this Matrix instead of returning a new one
      */
-    public void transform(final Matrix B, final DoubleBinaryOperator operator)
+    public Matrix transform(final Matrix B, final DoubleBinaryOperator operator)
     {
+        final Matrix M = new Matrix(this.m, this.n);
         for (int i = 0; i < this.m; i++)
         {
             for (int j = 0; j < this.n; j++)
             {
-                this.A[i][j] = operator.applyAsDouble(this.A[i][j], B.A[i][j]);
+                M.A[i][j] = operator.applyAsDouble(this.A[i][j], B.A[i][j]);
             }
         }
+        return M;
     }
 
     /**
-     * Applys the given operator to all elements, returning a new Matrix.
+     * Applys the given operator to all elements, modifying this Matrix.
      * @param B another Matrix
-     * @param operator Operator to be applied
-     * @return new Matrix with the result
-     * @throws NullPointerException iff operator == null
+     * @param operator Operator to be applied to this Matrix and B
+     * @throws NullPointerException iff operator == null or B == null
+     * @see {@link #transform(Matrix, DoubleBinaryOperator)}
+     * to return a new Matrix instead of modifying this Matrix
      */
-    public Matrix transformEquals(final Matrix B, final DoubleBinaryOperator operator)
+    public void transformEquals(final Matrix B, final DoubleBinaryOperator operator)
     {
-        final Matrix M = new Matrix(this.m, this.n);
         for (int i = 0; i < this.m; i++)
         {
             for (int j = 0; j < this.n; j++)
             {
-                M.A[i][j] = operator.applyAsDouble(this.A[i][j], B.A[i][j]);
+                this.A[i][j] = operator.applyAsDouble(this.A[i][j], B.A[i][j]);
             }
         }
-        return M;
     }
 
     /**