Newton Ahmed korriegert

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

typedef double (*func_t)(double);
double func1(double x);
double func2(double x);

double func1 (double x)
{

    return 2*sin(x)-0.5;

}

double func2(double x)

{

    return 2*cos(x);

}

typedef struct value_s

{
    double *arg;
    double *funcval;
    long size;
} value_t;

typedef enum boolean_e
{
    FALSE=0,
    TRUE=1
} boolean_t;

value_t *values_allocate(long size)

{

       /* value_t *val=0;
        if(!(val=malloc(sizeof(value_t))))
           {
               fprintf(stderr,"Fehler val allozieren.\n");
               return 0;
           }
        if(!(val->arg=calloc(size,sizeof(double))))
            {
                fprintf(stderr,"Fehler arg alloz.\n");
                free(val);
                return 0;
            }
            if(!(val->funcval=calloc(size,sizeof(double))))
            {
                fprintf(stderr,"Fehler funcval allozi.\n");
                free(val);
                return 0;
            }
            val->size=size;
            return val;
*/

   value_t *val=calloc(1,sizeof(value_t));

    if(!val)
    {
        fprintf(stderr,"Kein Speicher Alloziert\n");
        return 0;
    }

    val->arg=calloc(size,sizeof(double));
    val->funcval=calloc(size,sizeof(double));

    if(!val->arg || !val->funcval)
    {
        fprintf(stderr,"Kein Speicher alloziert\n");
        free(val);
        return 0;
    }
    val->size=size;
return val;
}

boolean_t values_insert(value_t *val,double arg,double values,long index)

{
    /*if(index>=0 && index<val->size)
    {
        val->arg[index]=arg;
        val->arg[index]=values;
        return 1;
    }
    return 0;*/

    if(!val)
    {
        fprintf(stderr,"Kein Speicher vorhanden\n");
        return 0;
    }

    if(index<0 || index>=val->size)
    {
        fprintf(stderr,"Falscher Index\n");
    }

    val->arg[index]=arg;
    val->funcval[index]=values;

    return 1;
}

boolean_t values_free(value_t *val)

{
    /*if(val!=NULL)
    {
        free(val->arg);
        free(val->funcval);
        free(val);
        return 1;
    }
    else
        return 0;*/

    if(!val)
    {
        fprintf(stderr,"Kein Speicher zum freigeben\n");
        return 0;
    }

    free(val->arg);
    free(val->funcval);
    free(val);

    return 1;

}

boolean_t values_print(value_t *val)

{

    long i=0;

    if(!val)
    {
        fprintf(stderr,"Nichts zum ausgeben");
        return 0;
    }

    printf("Index    Argument   Functionsvalue\n");

    for(i=0; i<val->size; i++)
        {
            printf("%ld:      %5g         %5g\n",i,val->arg[i],val->funcval[i]);
        }

    return 1;

}

double newton_step(double x0,func_t func,func_t derivate)

{
    if(derivate(x0) ==0)
    {
        fprintf(stderr,"Divison durch NULL\n");
        return 0;
    }

    return x0-func(x0)/derivate(x0);

}

void newton_iter(double x0,long steps,double precision,func_t func,func_t derivate)

{

    long i=0;

    double xn=0;

    value_t *val=values_allocate(steps);

    values_insert(val,x0,func(x0),0);

    for(i=0; i<steps && (fabs(val->funcval[i])>precision); i++)

    {

        xn=newton_step(val->arg[i],func,derivate);

        values_insert(val,xn,func(xn),i+1);

    }

    values_print(val);

    values_free(val);

}



int main()

{

    value_t *val=0;

    long size=0,c=0,index=0,steps=0;

    double arg=0,funcval=0,x0=0,precision=0;

    do

    {

        printf("1:Allocate\n");

        printf("2:Insert Value\n");

        printf("3:Free Memory\n");

        printf("4:Print\n");

        printf("4:Newton Step\n");

        printf("5:Newton Iteration\n");

        printf("0:Terminate\n");

        scanf("%ld",&c);

        switch(c)

        {

        case 1:

            printf("Size: ");

            scanf("%ld",&size);

            val=values_allocate(size);

            break;

        case 2:

            printf("Index: ");

            scanf("%ld",&index);

            printf("Argument: ");

            scanf("%lf",&arg);

            values_insert(val,arg,func1(arg),index);

            break;

        case 3:

            values_free(val);

            val=0;

            break;

        case 4:

            values_print(val);

            break;

        case 5:

            printf("x0: ");

            scanf("%lf",&x0);

            printf("x1= %lf",newton_step(x0,func1,func2));

            break;

        case 6:

            printf("Startwert:");

            scanf("%lf",&arg);

            printf("Steps: ");

            scanf("%ld",&steps);

            printf("Genauigkeit: ");

            scanf("%lf",&precision);

            newton_iter(arg,steps,precision,func1,func2);

            break;



        }

    }
    while(c != 0);





    return 0;

}