Obliczanie średniej arytmetycznej w macierzach

Question

Mam za zadanie napisać program który będzie liczył między innymi średnie arytmetyczne głównych przekątnych macierzy. Czy da się to wykonać jakoś napisaną już w kodzie funkcją get_mean_value czy trzeba do tego będzie napisać osobną fukncję? 

#include <stdio.h>
#include <locale.h>
/* we'll need this one for calloc */
#include <stdlib.h>
#pragma warning (disable: 4996);

double get_mean_value(int vector_size, double* vector_data) {

    double sum_value = 0.0, avg_value;

    for (int i = 0; i < vector_size; ++i) {
        sum_value += vector_data[i];
    }

    avg_value = sum_value / vector_size;

    return avg_value;
}






int main() {
    setlocale(LC_ALL, "pl_PL");
    int r, c, a[100][100], i, j;
    printf("Podaj liczbę wierszy macierzy (między 1 a 100): ");
    scanf("%d", &r);

    /* oczywiście tutaj trzeba dostosowac do własnych potrzeb - np. jeśli chcemy mieć macierz n x n, to spokojnie wystarczy jeden wymiar zostawić itd. */
    printf("Podaj liczbę kolumn macierzy (między 1 a 100): ");
    scanf("%d", &c);

    if (r == 0 || c == 0) {
        printf("Error");
        return 0;
    } else{
 


    printf("\nWprowadź elementy macierzy:\n");
    for (i = 0; i < r; ++i) {

        for (j = 0; j < c; ++j) {
            printf("Wprowadź element a%d%d: ", i + 1, j + 1);
            scanf("%d", &a[i][j]);
        }
    }
    }



    /* Średnia l-tego wiersza  */

    int row_number = 1;
    row_number--;

    double* row;
    /* Przydzielanie pamięci dla l elementów */
    row = (double*)calloc(r, sizeof(double));
    if (row == NULL) {
        printf("Error!!! memory not allocated.");
        exit(0);
    }

    for (i = 0; i < r; ++i) {

        for (j = 0; j < c; ++j) {
            if (i == row_number) {
                row[j] = (double)a[i][j];
            }
        }
    }

    /* uzyskujemy wynik funkcji */
    double avg;

    avg = get_mean_value(r, row);
    printf("\nŚrednia arytmetyczna l-tym wierszu: \n %.2f", avg);
    printf("\n\n");




    free(row);


    /*Srednia w l-tej kolumnie*/

    int column_number = 4;
    column_number--;

    if (column_number < c) {
       
        double* column;
        /* Przydzielanie pamięci dla l elementów */
        column = (double*)calloc(r, sizeof(double));
        if (column == NULL) {
            printf("Error!!! memory not allocated.");
            exit(0);
        }

        for (i = 0; i < r; ++i) {

            for (j = 0; j < c; ++j) {
                if (i == column_number) {
                    column[j] = (double)a[j][i];
                }
            }
        }

        /* uzyskujemy wynik funkcji */
        double avg1;

        avg1 = get_mean_value(c, column);
        printf("\nŚrednia arytmetyczna l-tej kolumnie: \n %.2f", avg1);
        printf("\n\n");




        free(row);
    }
    else {
        printf("Nie można obliczyć średniej, taka kolumna nie istnieje w podanej macierzy.");
        printf("\n\n");
    }



    /* Srednia arytmetyczna głównej przekątnej */


    int main_diagonal;
    main_diagonal--;

    double* row;
    /* Przydzielanie pamięci dla l elementów */
    row = (double*)calloc(r, sizeof(double));
    if (row == NULL) {
        printf("Error!!! memory not allocated.");
        exit(0);
    }

    for (i = 0; i < r; ++i) {

        for (j = 0; j < c; ++j) {
            if (i == row_number) {
                row[j] = (double)a[i][j];
            }
        }
    }

    /* uzyskujemy wynik funkcji */
    double avg;

    avg = get_mean_value(r, row);
    printf("\nŚrednia arytmetyczna l-tym wierszu: \n %.2f", avg);
    printf("\n\n");

    return 0;
}

 

Comments

Jakby tablice dwuwymiarowe potraktować jako ciągłe, to jeśli dodać do tej funkcji parametr (nazwijny go roboczo step) określający co który element wziąć do obliczeń, to przy tablicy N na N jeśli step podasz 1 dostaniesz obliczenie dla wiersza, step równe N obliczy średnią kolumny, N-1 da przekątną pochyloną w lewo (\), a N+1 w prawo (/).

---

W jaki sposób określić to co który element wziąć przy liczeniu przekątnych?