Fixes #66

src/main/java/org/la4j/matrix/AbstractMatrix.java

@@ -555,6 +555,16 @@ public double diagonalProduct() {
         return result;
     }
 
+    @Override
+    public double product() {
+        return fold(Matrices.asProductAccumulator(1));
+    }
+
+    @Override
+    public double sum() {
+        return fold(Matrices.asSumAccumulator(0));
+    }
+
     @Override
     public Matrix triangularize() {
         return triangularize(factory);

src/main/java/org/la4j/matrix/AbstractSafeMatrix.java

@@ -221,6 +221,16 @@ public double diagonalProduct() {
         return self.diagonalProduct();
     }
 
+    @Override
+    public double product() {
+        return self.product();
+    }
+
+    @Override
+    public double sum() {
+        return self.sum();
+    }
+
     @Override
     public double determinant() {
         return self.determinant();

src/main/java/org/la4j/matrix/Matrix.java

@@ -313,6 +313,20 @@ public interface Matrix extends Externalizable {
      */
     double diagonalProduct();
 
+    /**
+     * Productizes up all elements of the matrix
+     * 
+     * @return the product of all elements of the matrix
+     */
+    double product();
+
+    /**
+     * Summarizes up all elements of the matrix
+     * 
+     * @return the sum of all elements of the matrix
+     */
+    double sum();
+
     /**
      * Returns the "determinant" of this matrix.
      * <p>

src/main/java/org/la4j/vector/AbstractSafeVector.java

@@ -147,6 +147,16 @@ public Vector divide(double value, Factory factory) {
         return self.divide(value, factory);
     }
 
+    @Override
+    public double product() {
+        return self.product();
+    }
+
+    @Override
+    public double sum() {
+        return self.sum();
+    }
+
     @Override
     public double innerProduct(Vector vector) {
         return self.innerProduct(vector);

src/main/java/org/la4j/vector/AbstractVector.java

@@ -240,6 +240,16 @@ public Vector divide(double value, Factory factory) {
         return multiply(1.0 / value, factory);
     }
 
+    @Override
+    public double product() {
+        return fold(Vectors.asProductAccumulator(1));
+    }
+
+    @Override
+    public double sum() {
+        return fold(Vectors.asSumAccumulator(0));
+    }
+
     @Override
     public double innerProduct(Vector vector) {
 

src/main/java/org/la4j/vector/Vector.java

@@ -221,6 +221,20 @@ public interface Vector extends Externalizable {
      */
     Vector divide(double value, Factory factory);
 
+    /**
+     * Productizes all elements of the vector
+     * 
+     * @return product of all vector elements
+     */
+    double product();
+
+    /**
+     * Summarizes all elements of the vector
+     * 
+     * @return sum of all elements of the vector
+     */
+    double sum();
+
     /**
      * Calculates the inner product of this vector and given {@code vector}.
      * 

src/test/java/org/la4j/matrix/AbstractMatrixTest.java

@@ -756,7 +756,7 @@ public void testTrace_3x3() {
         assertTrue(Math.abs(a.trace() - 15.0) < Matrices.EPS);
     }
 
-    public void testProduct_3x3() {
+    public void testDiagonalProduct_3x3() {
 
         Matrix a = factory().createMatrix(new double[][] {
                 { 1.0, 0.0, 0.0 },
@@ -767,6 +767,28 @@ public void testProduct_3x3() {
         assertTrue(Math.abs(a.diagonalProduct() - 45.0) < Matrices.EPS);
     }
 
+    public void testProduct_3x3() {
+
+        Matrix a = factory().createMatrix(new double[][] {
+                {1.0, 1.0, 1.0},
+                {1.0, 5.0, 1.0},
+                {1.0, 1.0, 9.0}
+        });
+
+        assertTrue(Math.abs(a.product() - 45.0) < Matrices.EPS);
+    }
+
+    public void testSum_3x3() {
+
+        Matrix a = factory().createMatrix(new double[][] {
+                { 1.0, 0.0, 0.0 },
+                { 0.0, 5.0, 0.0 },
+                { 0.0, 0.0, 9.0 } 
+        });
+
+        assertTrue(Math.abs(a.sum() - 15.0) < Matrices.EPS);
+    }
+
     public void testDeterminant_3x3() {
 
         Matrix a = factory().createMatrix(new double[][] {

src/test/java/org/la4j/vector/AbstractVectorTest.java

@@ -316,6 +316,24 @@ public void testMultiply_3_3x1() {
         assertEquals(c, a.multiply(b));
     }
 
+    public void testProduct_3() {
+
+        Vector a = factory().createVector(new double[]
+                {2.0, 4.0, 6.0}
+        );
+
+        assertTrue(Math.abs(a.product() - 48.0) < Vectors.EPS);
+    }
+
+    public void testSum_3() {
+
+        Vector a = factory().createVector(new double[]
+                {2.0, 4.0, 6.0}
+        );
+
+        assertTrue(Math.abs(a.sum() - 12.0) < Vectors.EPS);
+    }
+
     public void testDivide_3() {
 
         Vector a = factory().createVector(new double[]