3.3 WORKING GOOD

#include <stdio.h>
#include <stdlib.h>
#define N 10
#define M 20

const float right = -5.0, left = 4.0, up = 2.0, down = 3.0;

void occurence(float t[N][M]);
void createL(float t[N][M]);
void createU(float t[N][M]);
void createR(float t[N][M]);
void createD(float t[N][M]);
void calcCorners(float t[N][M]);
void printarray(float*);
void initialize(float t[N][M]);
void denormalize(float t[N][M]);
void loadTemp(float tTemp[N][M], float*);
void normalize(float t[N][M]);
float next(int, int, float t[N][M]);
int round(float);

int main() {
    float t[N][M], tNew[N][M], tTemp[N][M];
    float* ptr;
    float* ptrNew;
    float* ptrTemp;
    int i, j, k;
    int time;

    ptr = &t[0][0];
    ptrNew = &tNew[0][0];

    initialize(t);
    normalize(t);
    printarray(ptr);
    denormalize(t);

    while(1)
    {
        ptrTemp = &t[0][0];
        printf("Enter an integer for the time: ");
        scanf("%d", &time);

        if (time!=0)
        {
            loadTemp(tTemp, ptrTemp);
            for (k=0; k<time; k++)
            {
                for (i=0; i<N; i++)
                {
                    if (i != 0 && i != N - 1)
                    {
                        for (j=0; j<M; j++)
                        {
                            if (j != 0 && j != M - 1)
                            {
                                tNew[i][j] = next(i, j, tTemp);
                            }
                        }
                    }
                }
                createL(tNew);
                createR(tNew);
                createD(tNew);
                createU(tNew);
                calcCorners(tNew);
                ptrTemp = &tNew[0][0];
                loadTemp(tTemp, ptrTemp);
                /*normalize(tNew)
                printarray(&tTemp[0][0]);*/
            }
        }
        else
        {
            return 0;
        }
        normalize(tNew);
        printarray(ptrNew);
        occurence(tNew);
    }
    system("pause");

    return 0;
}

/* i am tired */

void occurence(float t[N][M])
{
    int count, i, j, l, k;
    float tOcc[N][M], hasAppeared[10];
    for (i=0; i<10; i++)
    {
        hasAppeared[i] = 0.0;
    }
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            count = 0;
             for (k=0; k<N; k++)
            {
                for (l=0; l<M; l++)
                {
                    if (t[i][j] == t[k][l])
                    {
                        count++;
                    }
                }
            }
            tOcc[i][j] = count;
            /*printf("%g appears %g times.\n", t[i][j], tOcc[i][j]);*/
        }
    }
    printf("Temperature:\tOccurency:\tStars:\n");
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            if (hasAppeared[(int)t[i][j]] != 1)
            {
                printf("%g\t\t(%g)\t\t", t[i][j], tOcc[i][j]);
                for (k=0; k<tOcc[i][j]; k++)
                {
                    putchar('*');
                }
                putchar('\n');
                hasAppeared[(int)t[i][j]] = 1;
            }
        }
    }/*
    for (i=0; i<10; i++)
    {
        printf("%d (%g)\t", i, hasAppeared[i]);
        for (j=0; j<(int)hasAppeared[i]; j++)
        {
            printf("*");
        }
        putchar('\n');
    }*/
    return;
}

int round(float num)
{
    return num < 0 ? num - 0.5 : num + 0.5;
}

void denormalize(float t[N][M])
{
    initialize(t);
    return;
}

void normalize(float t[N][M])
{
    int i, j, k;
    float min = t[0][0], max = t[0][0], Dx;
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            if (t[i][j] < min)
            {
                min = t[i][j];
            }
        }
    }
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            if (t[i][j] > max)
            {
                max = t[i][j];
            }
        }
    }
    Dx = (max - min) / 10;/*
    printf("Dx = %g\nMax = %g and Min = %g\n\n", Dx, max, min);*/
    /*
    for (k=0; k<10; k++)
    {
        printf("[%g, %g) ==> %dth Area\n", k*Dx + min, (k+1)*Dx + min, k);
    }*/


    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            for (k=0; k<10; k++)
            {
                if (t[i][j] == max)
                {
                    t[i][j] = 9.0;
                }
                if (t[i][j] >= (k*Dx + min) && t[i][j] < ((k + 1)*Dx + min))
                {
                    t[i][j] = k;
                    break;
                }
            }
        }
    }
    return;
}

void loadTemp(float tTemp[N][M], float* ptrTemp)
{
    int i, j;
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            tTemp[i][j] = *(ptrTemp + M*i + j);
        }
    }
    return;
}

void calcCorners(float t[N][M])
{
    float ur, ul, dr, dl;
    ur = ( right + up ) / 2;
    dr = ( right + down ) / 2;
    ul = ( left + up ) / 2;
    dl = ( left + down ) / 2;
    t[0][0] = ul;
    t[0][M-1] = ur;
    t[N-1][0] = dl;
    t[N-1][M-1] = dr;
    return;
}

void createR(float t[N][M])
{
    int i;
    for (i=0; i<N; i++)
    {
        t[i][M-1] = right;
    }
    return;
}

void createL(float t[N][M])
{
    int i;
    for (i=0; i<N; i++)
    {
        t[i][0] = left;
    }
    return;
}

void createD(float t[N][M])
{
    int i;
    for (i=0; i<M; i++)
    {
        t[N-1][i] = down;
    }
    return;
}

void createU(float t[N][M])
{
    int i;
    for (i=0; i<M; i++)
    {
        t[0][i] = up;
    }
    return;
}

void initialize(float t[N][M])
{
    int i, j;
    printf("Time: 0\n");
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            t[i][j] = 1.0;
        }
    }
    createL(t);
    createR(t);
    createD(t);
    createU(t);
    calcCorners(t);
    return;
}

void printarray(float* pointer)
{
    int i, j;
    for (i=0; i<N; i++)
    {
        for (j=0; j<M; j++)
        {
            printf("%.2f\t", *(pointer + M*i + j));
        }
        putchar('\n');
    }
    printf("\n------------------------------------------------------\n");
    return;
}

float next(int i, int j, float t[N][M])
{
    float tNewElement;
    tNewElement = 0.1 * (t[i-1][j-1] + t[i-1][j] + t[i-1][j+1] + t[i][j-1] + 2 * t[i][j] + t[i][j+1] + t[i+1][j-1] + t[i+1][j] + t[i+1][j+1]);
    return tNewElement;
}