#include <stdio.h>
#include <math.h>


void min_max_avg(float **grid, int N, int M,
                 float *min, float *max, float *avg,
                 float *col_min, float *col_max, float *col_avg,
                 float *row_min, float *row_max, float *row_avg) {


    int i, j;


    // compute overall min, max, row_min, and row_max

    //merged min, max, row_min, and row_max into one loop - loop efficiency
    float minimum = INFINITY;   // Use a variable for *max - memory aliasing
    float maximum = -INFINITY;  // Use a variable for *min - memory aliasing

    for (i = 0; i < N; i++) {
        row_min[i] = +INFINITY;
        row_max[i] = -INFINITY;
        row_avg[i] = 0;
        for (j = 0; j < M; j++) {
            if (grid[i][j] < minimum) {
                minimum = grid[i][j];
            }
            if (grid[i][j] > maximum) {
                maximum = grid[i][j];
            }

            if (grid[i][j] < row_min[i]) {
                row_min[i] = grid[i][j];
            }
            if (grid[i][j] > row_max[i]) {
                row_max[i] = grid[i][j];
            }

        }
    }
    *min = minimum;
    *max = maximum;


    // compute overall average and row_avg

    //merged avg and row_avg into one loop - loop efficiency
    float total = 0; // Use a variable for *avg - memory aliasing
    float rowtotal = 0;
    for (i = 0; i < N; i++) {
        row_avg[i] = 0;
        int rowitem[8] = {0,0,0,0,0,0,0,0}; // unroll the loop into an 8 x 8 - loop efficiency
        for (j = 0; j < M-8; j += 8) {
            rowitem[0] += grid[i][j];
            rowitem[1] += grid[i][j+1];
            rowitem[2] += grid[i][j+2];
            rowitem[3] += grid[i][j+3];
            rowitem[4] += grid[i][j+4];
            rowitem[5] += grid[i][j+5];
            rowitem[6] += grid[i][j+6];
            rowitem[7] += grid[i][j+7];

        }

        rowtotal =  rowitem[0] +
                    rowitem[1] +
                    rowitem[2] +
                    rowitem[3] +
                    rowitem[4] +
                    rowitem[5] +
                    rowitem[6] +
                    rowitem[7];

        for (; j < M; j++) {
            rowtotal += grid[i][j];
        }
        total += rowtotal;
        row_avg[i] = (M != 0) ? rowtotal/(float)M : NAN;
    }
    *avg = (N*M > 0) ? total/(float)(M * N) : NAN;




    // compute stats by col
    for (j = 0; j < M; j++) {
        col_min[j] = +INFINITY;
        col_max[j] = -INFINITY;
        col_avg[j] = 0;
        for (i = 0; i < N; i++) {
            if (grid[i][j] < col_min[j]) {
                col_min[j] = grid[i][j];
            }
            if (grid[i][j] > col_max[j]) {
                col_max[j] = grid[i][j];
            }
            col_avg[j] += grid[i][j];
        }
        col_avg[j] = (N != 0) ? col_avg[j]/(float)N : NAN;
    }