How to calculate the average value of each column in 2D array?

Question

I am trying to calculate the average value of columns in 2D array, but I cannot figure out the code. The function should return the average value of each column. And I cannot print the result in the function. The print should be in main function.

static double average_columns(double matrix[][]) {
    int i, j, sum = 0, average = 0;
    for (i = 0; i < matrix.length; i++) {
        for (j = 0; j < matrix[i].length; j++) {
            sum = (int) (sum + matrix[i][j]);
        }
        average = sum / matrix[i].length;
        sum = 0;
    }
    return average;
}

Answer 1

This is how you can calculate sum and averages of each row and columns : The below example code will print the sum and averages in the same method and wont return any value. If you need to return the actual sum and average then you need to return double[] which will contains all the sums or averages instead of a double.

CODE

public class Test {
    
    static int m = 3; 
    static int n = 3; 

    public static void main(String[] args) {
        
        int i,j;
        int [][]matrix = new int[m][n]; 
      
        int x = 1; // x fills up the value of the matrix
        for (i = 0; i < m; i++) 
            for (j = 0; j < n; j++) 
                matrix[i][j] = x++; 
      
        
        System.out.println("The matrix is : \n");
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                System.out.print(matrix[i][j] + "    ");
            }
            System.out.println();
        }
        
        System.out.println("\nPrinting the avg of each col ::");
        average_columns(matrix);
        
        System.out.println("\nPrinting the avg of each row ::");
        average_rows(matrix);
        
        System.out.println("\nPrinting the sum of each col ::");
        sum_columns(matrix);
        
        System.out.println("\nPrinting the sum of each row ::");
        sum_rows(matrix);

    }
    
    public static void average_rows(int matrix[][]) {
        int i, j;
        double sum = 0, average = 0;
        for (i = 0; i < matrix.length; i++) {
            for (j = 0; j < matrix[i].length; j++) {
                sum=sum+matrix[i][j];
            }
            average=sum/matrix[i].length;
            System.out.println("Average of row " + (i+1) + " = " + average); 
            sum=0;
        }
    }
    
    public static void average_columns(int matrix[][]) {
        int i, j;
        double sum = 0, average = 0;
        for (i = 0; i < matrix.length; i++) {
            for (j = 0; j < matrix[i].length; j++) {
                sum=sum+matrix[j][i];
            }
            average=sum/matrix[i].length;
            System.out.println("Average of column " + (i+1) + " = " + average);
            sum=0;
        }
    }
    
    public static void sum_columns(int matrix[][]) { 
          
        int i,j;
        double sum = 0;       
        for (i = 0; i < matrix.length; ++i) { 
            for (j = 0; j < matrix.length; ++j) { 
                sum = sum + matrix[j][i]; 
            } 
            System.out.println("Sum of column " + (i+1) + " = " + sum); 
            sum = 0; 
        } 
    } 
    
    public static void sum_rows(int matrix[][]) { 
          
        int i,j;
        double sum = 0;   
        for (i = 0; i < matrix.length; ++i) { 
            for (j = 0; j < matrix.length; ++j) { 
                sum = sum + matrix[i][j]; 
            } 
            System.out.println( "Sum of row " + (i+1) + " = " + sum); 
            sum = 0; 
        } 
    } 


}

OUTPUT

The matrix is : 

1    2    3    
4    5    6    
7    8    9    

Printing the avg of each col ::
Average of column 1 = 4.0
Average of column 2 = 5.0
Average of column 3 = 6.0

Printing the avg of each row ::
Average of row 1 = 2.0
Average of row 2 = 5.0
Average of row 3 = 8.0

Printing the sum of each col ::
Sum of column 1 = 12.0
Sum of column 2 = 15.0
Sum of column 3 = 18.0

Printing the sum of each row ::
Sum of row 1 = 6.0
Sum of row 2 = 15.0
Sum of row 3 = 24.0

Answer 2

1. You need to return a double[] instead of a double from the function.
2. Since the numbers are of type, double, the type of sum should be double.

If all the rows are of equal length:

3. Since you want to add the values of each column, you should add matrix[j][i] (instead of matrix[i][j]) to sum and accordingly average[i] will be sum / matrix.length.

Demo:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Test
        double[][] nums = { { 10, 15, 20 }, { 1, 2, 3 }, { 5, 10, 15 } };
        System.out.println(Arrays.toString(averageColumns(nums)));
    }

    static double[] averageColumns(double matrix[][]) {
        int i, j;
        double[] average = new double[matrix.length];
        for (i = 0; i < matrix.length; i++) {
            double sum = 0;
            for (j = 0; j < matrix[i].length; j++) {
                sum += matrix[j][i];
            }
            average[i] = sum / matrix.length;
        }
        return average;
    }
}

Output:

[5.333333333333333, 9.0, 12.666666666666666]

If the rows are of different length:

3. You should first find the maximum of the length of rows which will become the size of the double[] average.
4. Finally, use a 2-level nested loop to calculate the values for average[]. The outer loop will run up to average.length and the inner loop will run up to the number of rows. While processing each column, use a counter (e.g. int count) to keep track of the number of values which are added to sum. At the end of the inner loop, average[i] = sum / count.

Demo:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Test
        double[][] nums = { { 10, 15, 20 }, { 1, 2 }, { 5, 10, 15, 25 } };
        System.out.println(Arrays.toString(averageColumns(nums)));
    }

    static double[] averageColumns(double matrix[][]) {
        // Find the maximum of the length of rows
        int max = matrix[0].length;
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[i].length > max) {
                max = matrix[i].length;
            }
        }

        int i, j;
        double[] average = new double[max];
        for (i = 0; i < average.length; i++) {
            double sum = 0;
            int count = 0;
            for (j = 0; j < matrix.length; j++) {
                if (matrix[j].length - 1 >= i) {
                    sum += matrix[j][i];
                    count++;
                }
            }
            average[i] = sum / count;
        }
        return average;
    }
}

Output:

[5.333333333333333, 9.0, 17.5, 25.0]

Answer 3

If you assume a NxN matrix, you can solved with streams:

double[][] matrix = {{1, 5, 15}, {1, 2, 2}, {25, 109, 150}};

List<Double> column_average = Arrays
        .stream(IntStream.range(0, matrix[0].length)
        .mapToObj(c1 -> Arrays.stream(matrix)
                .mapToDouble(doubles -> doubles[c1])
                .toArray())
        .toArray(double[][]::new))
        .map(i -> Arrays.stream(i).average().getAsDouble())
        .collect(Collectors.toList());

or more readable:

double[][] matrix_transpose = IntStream
        .range(0, matrix[0].length)
        .mapToObj(c -> Arrays.stream(matrix)
                .mapToDouble(doubles -> doubles[c])
                .toArray())
        .toArray(double[][]::new);

List<Double> column_average = Arrays
        .stream(matrix_transpose)
        .map(col -> Arrays.stream(col).average().getAsDouble())
        .collect(Collectors.toList());

You do the transpose of the matrix and then you use Arrays.stream(...).average().getAsDouble() to calculate the averages of the arrays.

Answer 4

You can use Stream.reduce method to summarise the elements in columns and then divide each sum by the number of columns:

double[][] matrix = {
        {1.11, 2.22, 3.33, 4.45, 5.56},
        {6.61, 7.76, 8.88, 9.9, 10.11},
        {11.1, 12.2, 13.3, 14.4, 15.5},
        {16.6, 17.7, 18.8, 19.9, 20.0},
        {21.1, 22.2, 23.3, 24.4, 25.5}};

double[] average = Arrays.stream(matrix)
        // summarize in pairs
        // the rows of the matrix
        .reduce((row1, row2) ->
                // iterate over the indices
                // from 0 to row length
                IntStream.range(0, row1.length)
                        // summarize in pairs the
                        // elements of two rows
                        .mapToDouble(i -> row1[i] + row2[i])
                        // an array of sums
                        .toArray())
        // stream containing
        // the resulting array
        // Stream<double[]>
        .stream()
        // iterate over the array of sums
        // Stream<double[]> to DoubleStream
        .flatMapToDouble(Arrays::stream)
        // divide each element by
        // the number of columns
        .map(i -> i / matrix.length)
        .toArray();

System.out.println(Arrays.toString(average));
// [11.304, 12.416, 13.522, 14.61, 15.334]

---

^{See also: Adding up all the elements of each column in a 2d array}

Answer 5

I was having some issues with the above available code so I have written some of my own. Hope it helps someone:

    public double[] averageColumns(double matrix[][]) {
    int rows = matrix.length;
    int cols = matrix[0].length;
    double[] avg = new double[cols];
    double sum = 0;
    for (int i = 0; i < cols; i++){
        sum = 0;
        for(int j = 0; j < rows; j++){
            sum += matrix[j][i];
        }
        avg[i] = sum / rows;
    }
    return avg;
}