Thomas Kramer

IT-COW | All posts tagged 'C-Aufgaben'

C-Aufgaben: Berechnung einfacher statistischer Kennwerte

By Administrator at Februar 08, 2011 20:31
Filed Under: C(++), Programmierung allgemein, Studium

Im letzten Semester gab es u. a. eine Aufgabe zur Berechnung einfacher statistischer Kennwerte.

 

Diese Aufgabe war insofern interessant weil ich vorher nur den arithmetischen Mittelwert kannte, aber es gibt auch noch einen geometrischen Mittelwert und einen quadratischen Mittelwert.

 

Nachfolgend mein C-Quellcode zu dieser Aufgabe:

 

/*
 * =============================================================
 *
 *       Filename:  6.1.c
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Thomas Kramer
 *        Company:  
 *
 * =============================================================
 */

#include    <stdlib.h>
#include    <stdio.h>
#include  <math.h>
#include  <ctype.h>
#include  <time.h>
#include  <assert.h>

#define FEHLER "Fehler bei Bereichsgrenzen"
#define FEHLER_LOG "Die Logarithmus-Funktion ist nur für Werte größer 0 spezifiziert"

void fuelle_feld (double a[], int n, int unten, int oben);
void gib_feld_aus (double a[], int n);
void tausche_double(double *a, double *b);
void sortiere_feld_aufsteigend(double a[], int n);
void sortiere_feld_absteigend(double a[], int n);
double minimum(double a[], int n);
double maximum(double a[], int n);
double spanne(double a[], int n);
double arithm_mittelwert(double a[], int n);
double geom_mittelwert(double a[], int n);
double quad_mittelwert(double a[], int n);
double mittlere_abweichung(double a[], int n);
double median(double a[], int n);

int main ( )
{
    int n=200;
    int obere_Wertegrenze=100;
    int untere_Wertegrenze=0;
    double a[n];

    fuelle_feld(a, n, untere_Wertegrenze, obere_Wertegrenze);
    gib_feld_aus(a, n);

    printf("Minimum:             %5.1lf\n", minimum(a, n));
    printf("Maximum:             %5.1lf\n", maximum(a, n));
    printf("Spanne:              %5.1lf\n", spanne(a, n));
    printf("arithm. Mittelwert:  %5.1lf\n", arithm_mittelwert(a, n));
    printf("geom. Mittelwert:    %5.1lf\n", geom_mittelwert(a, n));
    printf("quadr. Mittelwert:   %5.1lf\n", quad_mittelwert(a, n));
    printf("mittl. Abweichung:   %5.1lf\n", mittlere_abweichung(a, n));
    printf("Median           :   %5.1lf\n", median(a, n));

    return 0;
}                /* ----------  end of function main  ---------- */

/*  ===  FUNCTION  =========================================================
 *         Name:  fuelle_feld
 *  Description:  füllt Feld mit Zufallszahlen
 *  a          :  Array, das zu füllen ist
 *  n          :  Größe des Arrays
 *  unten      :  untere Grenze des Arrays    
 *  oben       :  obere Grenze des Arrays
 * =====================================================================
 */
void fuelle_feld (double a[], int n, int unten, int oben)
{
    int i;
    assert(a != NULL);

    if ((n<0) || (unten>oben))
    {
    fprintf(stderr, FEHLER);
        exit(1);
    }

    // zufallsfunktion initialisieren, damit nicht immer die gleichen Zufallszahlen herauskommen
    srand(time(NULL));

    // Normalfall Zufallsfunktion: rand() % (oben-unten+1)+unten
    // untere Grenze muss gleichbleiben, obere *10, damit bei Division durch 10 eine Nach-
    // kommastelle übrigbleibt
    for (i=0;i<n;i++) {
        a[i]=(rand() % ((oben-unten)*10)+unten)/10.0;
    }
}

/*  ===  FUNCTION  =========================================================
 *         Name:  gib_feld_aus
 *  Description:  Ausgabe des Feldes/Arrays
 *  a          :  Array, das auszugeben ist
 *  n          :  Größe des Arrays
 * =====================================================================
 */
void gib_feld_aus (double a[], int n)
{
    int i;
    assert(a != NULL);

    if (n<0)
    {
    fprintf(stderr, FEHLER);
        exit(1);
    }
    for (i=0;i<n;i++) {
        printf("%05.1lf ", a[i]);
        if (i%10==0) printf("\n");
    }
    printf("\n\n");
}

/*  ===  FUNCTION  =========================================================
 *         Name:  tausche_double
 *  Description:  vertauscht die Inhalte zweier Variablen
 *  a          :  Variable a
 *  b          :  Variable b
 * =====================================================================
 */
void tausche_double(double *a, double *b)
{
    double tmp;
    assert(a != NULL);
    assert(b != NULL);

    tmp=*a;
    *a=*b;
    *b=tmp;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  minimum
 *  Description:  berechne das Minimum im Array
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
double minimum(double a[], int n)
{
    int i;
    double kleinsterWert;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }
    kleinsterWert=a[0];

    for (i=0;i<n;i++)  
    {
        if (a[i]<kleinsterWert)
        {
            kleinsterWert=a[i];
        }
    }

    return kleinsterWert;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  maximum
 *  Description:  berechne das Maximum im Array
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
double maximum(double a[], int n)
{
    int i;
    double groessterWert;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }
    groessterWert=a[0];

    for (i=0;i<n;i++)
    {
        if (a[i]>groessterWert)
        {
            groessterWert=a[i];
        }    
    }

    return groessterWert;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  spanne
 *  Description:  berechne die Spanne im Array (Maximum-Minimum)
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
double spanne(double a[], int n)
{
    return (maximum(a, n) - minimum(a, n));
}

/*  ===  FUNCTION  =========================================================
 *         Name:  arithm_mittelwert
 *  Description:  berechne den arithm. Mittelwert übers Array -> Summe / Anzahl
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
double arithm_mittelwert(double a[], int n)
{
    int i;
    double summe=0;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }

    for (i=0;i<n;i++) {
        summe += a[i];
    }

    return summe/n;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  geom_mittelwert
 *  Description:  berechne den geom. Mittelwert übers Array
 *                -> alle Werte im Array werden miteinander multipliziert,  dann davon
 *                -> die n-te-Wurzel gezogen
 *                -> da aber pow() nicht benutzt werden soll,  wird ein Umweg über die
 *                -> Logarithmen gegangen...
 * a           :  Array
 * n           :  Größe des Arrays
 * =====================================================================
 */
double geom_mittelwert(double a[], int n)
{
    int i;
    double ln_gm=0;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }

    /*-----------------------------------------------------------------------------
     *  arithmetisches Mittel der Logarithmen der Größen xn berechnen
     *  (beinhaltet Division durch Anzahl)
     *  zum Schluß -> eulersche Zahl potenzieren mit dem Mittelwert der Logarithmen
     *-----------------------------------------------------------------------------*/
    for (i=0;i<n;i++) {
        if (a[i]<=0)
        {
      printf(FEHLER_LOG);
            exit(1);
        }
        ln_gm=ln_gm + log(a[i]);        
    }
    ln_gm=exp(ln_gm / n);

    /*-----------------------------------------------------------------------------
     *  Vergleich mit pow()
     *-----------------------------------------------------------------------------*/
    //    for (i=1;i<n;i++) {
    //      mittel=mittel * a[i];
    //    }
    //    mittel=pow(mittel, 1.0/n);

    //    printf("-> Vergleich mit pow(): %05.1lf <-\n", mittel);
    return ln_gm;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  quad_mittelwert
 *  Description:  berechne den quadr. Mittelwert übers Array
 *                -> jeder Wert im Array wird quadriert und miteinander addiert, dann
 *                -> durch die Anzahl dividiert, dann wiederum die Quadratwurzel gezogen
 * a           :  Array
 * n           :  Größe des Arrays
 * =====================================================================
 */
double quad_mittelwert(double a[], int n)
{
    /*-----------------------------------------------------------------------------
     *  potenziert - zu einer beliebigen Basis - wird in C++ so:
     *  exp(exponent * log(basis))
     *-----------------------------------------------------------------------------*/
    int i;
    double mittel=0;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }

    for (i=0;i<n;i++)
    {
        mittel += a[i]*a[i];    
    }    
    mittel = sqrt(mittel / n);

    return mittel;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  mittlere_abweichung
 *  Description:  berechne die mittlere Abweichung übers Array
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
double mittlere_abweichung(double a[], int n)
{
    int i;
    double am = arithm_mittelwert(a, n);
    double mittel=0;
    double zw=0;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }


    /*-----------------------------------------------------------------------------
     *  Betragsstriche in Vorgabe beachten!
     *  aus einer negativen Zahl wird daher wieder eine positive gemacht! (fabs())
     *-----------------------------------------------------------------------------*/
    for (i=0;i<n;i++)
    {
        zw=fabs(a[i] - am);    
        mittel+=zw;
    }
    mittel=mittel/n;

    return mittel;
}

/*  ===  FUNCTION  =========================================================
 *         Name:  sortiere_feld_aufsteigend
 *  Description:  Sortierung aufsteigend A-Z BUBBLESORT
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
void sortiere_feld_aufsteigend(double a[], int n)
{
    int x, y;
    int maxindex=n;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }

    for (x=0; x<maxindex; x++)
    {
        for (y=1;y<(maxindex-x-1);y++)
        {
            if (a[y]>a[y+1])
            {
                tausche_double(&a[y], &a[y+1]);
            }        
        }
    }    

    //    printf("\n");
    //    for (x=0;x<n;x++) {
    //      printf("%05.1lf <--> ", a[x]);
    //        if (x%10==0) printf("\n");        
    //    }
}

/*  ===  FUNCTION  =========================================================
 *         Name:  sortiere_feld_absteigend
 *  Description:  Sortierung absteigend Z-A BUBBLESORT
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
void sortiere_feld_absteigend(double a[], int n)
{
    int x, y;
    int maxindex=n;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }

    for (x=0;x<maxindex;x++)
    {
        for (y=1;y<(maxindex-x-1);y++)
        {
            if (a[y]<a[y+1])
            {
                tausche_double(&a[y], &a[y+1]);
            }
        }
    }

    // printf("\n");
    // for (x=0;x<n;x++)
    //   printf("%05.1lf <--> ", a[x]);
    // if (x%10==0) printf("\n");
    //
}

/*  ===  FUNCTION  =========================================================
 *         Name:  median
 *  Description:  -> "Du schreibst alle Werte der Größe nach auf und dann fängst du an "
 *                -> "die Werte zu streichen, immer den größten und den kleinsten. Es  "
 *                -> "bleibt dann entweder ein Wert übrig, das ist dann der Median     "
 *                -> "oder es bleiben 2 Werte übrig, die zählst du zusammen und teilst "
 *                -> "das Ergebnis durch 2, das ist dann ebenfalls der Median.         "
 *  a          :  Array
 *  n          :  Größe des Arrays
 * =====================================================================
 */
double median(double a[], int n)
{
    double ergebnis=0;
    int index1=0;
    int index2=0;
    int i=0;
    assert(a != NULL);

    if (n<=0)
    {
    printf(FEHLER);
        exit(1);
    }

    double b[n];

    for (i=0;i<=(n-1);i++)
    {
      b[i]=a[i];
    }
    
    sortiere_feld_aufsteigend(b, n);
    // sortiere_feld_absteigend(a, n);

    // nicht vergessen, wenn das Ergebnis einer Division einer ungeraden Zahl in einer
    // Ganzzahl gespeichert wird, wird abgeschnitten, nicht aufgerundet.
    index1=n/2;
    index2=n/2-1;
    if (n%2 == 0) {
        // ->gerade anzahl<-
        // beiden zahlen in der mitte: bei 200 logischerweise 100 und 101
        // davon das arithmetische Mittel
        ergebnis=(b[index1]+b[index2])/2;
    } else {
        // ->ungerade Anzahl<-, einer muss übrig bleiben
        ergebnis=b[index2];
    }  

    return ergebnis;

}

 

Tag-Wolke

Monats-Liste