Metódos_Numéricos

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define EULER 2.718281828459045235360287
#define NMAX 200
#define erro 0.0000000000000001

typedef double (*Funcao)(double);

//=============================== EQUAÇÕES ====================================================

double f1(double x){//Define a 1ª equação
    return x - cos(x);
}

double f2(double x){//Define a 2ª equação
    return x*x*x - 9*x*x + 27*x - 27;
}

double f3(double x){//Define a 3ª equação
    return pow(EULER,x)-cos(x);
}

double df1(double x){//Define a derivada 1ª da 1ª equação
    return 1 + sin(x);
}

double df2(double x){//Define a derivada 1ª da 2ª equação
    return 3*x*x - 18*x + 27;
}

double df3(double x){//Define a derivada 1ª da 3ª equação
    return pow(EULER,x)+sin(x);
}

double ddf1(double x){//Define a derivada 2ª da 1ª equação
    return cos(x);
}

double ddf2(double x){//Define a derivada 2ª da 2ª equação
    return 6*x - 18;
}

double ddf3(double x){//Define a derivada 2ª da 3ª equação
    return pow(EULER,x)+cos(x);
}

//=============================== MÉTODOS ====================================================

double* bissection_method(Funcao f, double valor_inicial_a, double valor_inicial_b, int* nB){
    double a=valor_inicial_a, b=valor_inicial_b;//define os parametros iniciais
    double* list = (double*)malloc(2*sizeof(double));//aloca memória para a lista das raizes iteradas
    list[0] = a;//primeiros espaços do array reservados para as condições inicias
    list[1] = b;//
    double c;
    int N = 1;//N: número de iterações
    while(N<=NMAX){ //NMAX: número máximo de iterações
        c = (a+b)/2; //aplica método da bissecção
        list = realloc(list, (N+2)*sizeof(double)); //realoca o tamanho da lista de raizes
        list[N+1] = c;// guarda o valor da nova raiz
        *nB = N+2;//guarda o valor do novo tamanho da lista
        if( f(c)==0 || (b-a)/2 < erro){// condição de parada
            printf("[BISSECCAO]: Encontrou a raiz x=%.16lf em %d iteracoes\n", c, N);
            return list;
        }
        N++;
        if((f(c)<0 && f(a)<0) || (f(c)>0 && f(a)>0))// sinal(f(c)) == sinal(f(a))
            a = c;
        else
            b = c;
    }
}

//==========================================================================================

double* secant_method(Funcao f, double valor_inicial_0, double valor_inicial_1, int* nS){
    double x0=valor_inicial_0, x1=valor_inicial_1;
    double* list = (double*)malloc(2*sizeof(double));//alocando memoria inicial no array para os valores iniciais
    list[0] = x0;//espaços inicias reservados para as condições iniciais
    list[1] = x1;//
    double x2;
    int N = 1;
    while(N<=NMAX){
        x2 = x1 - f(x1)*(x1 - x0)/(f(x1)-f(x0));//Aplicando o método da secante
        list = realloc(list, (N+2)*sizeof(double));//realocando tamanho do array
        list[N+1] = x2;//adicionando nova raiz a lista
        *nS = N+2;//guardando o valor do tamanho da lista
        if(fabs(x2-x1) < erro || f(x2)==0){//condição de parada
            printf("[SECANTE]:   Encontrou a raiz x=%.16lf em %d iteracoes\n", x2, N);
            return list;
        }
        N++;
        x0 = x1;
        x1 = x2;
    }
}

//==========================================================================================

double* newton_method(Funcao f, Funcao df, double valor_inicial, int* nN){
    double x0 = valor_inicial;//definindo parametro inicial
    double* list = (double*)malloc(sizeof(double));//alocando memória para o array de raizes
    list[0] = x0;//espaço inicial resevado para o parametro inicial
    double x;
    int N = 1;
    while(N<=NMAX){
        x = x0 - (f(x0)/df(x0)); //Aplicando o método de Newton
        list = realloc(list, (N+1)*sizeof(double));//realocando o tamanho do array
        list[N] = x;//guardando a nova raiz
        *nN = N+1;//guardando o novo tamanho do array
        if( (fabs(x-x0) < erro) || (f(x) == 0) ){ //condição de parada
            printf("[NEWTON]:    Encontrou a raiz x=%.16lf em %d iteracoes\n", x, N);
            return list;
        }
        N++;
        x0 = x;
    }
}

//==========================================================================================

double* halley_method(Funcao f, Funcao df, Funcao ddf, double valor_inicial, int* nH){
    double x0 = valor_inicial;//definindo parametro inicial
    double* list = (double*)malloc(sizeof(double));//alocando memória para o array de raizes
    list[0] = x0;// espaço inicial reservado para o parametro inicial
    double x;
    int N = 1;
    while (N<=NMAX){
        x = x0 - ( f(x0)*df(x0)/((df(x0)*df(x0))-(f(x0)*ddf(x0))/2) ); //aplicando o método de Halley
        list = realloc(list, (N+1)*sizeof(double));//realocando tamanho do array
        list[N] = x;//guardando o valor da nova raiz
        *nH = N+1;//guardando o novo valor do tamanho do array
        if( (fabs(x-x0) < erro) || (f(x)==0) ) {//condição de parada
            printf("[HALLEY]:    Encontrou a raiz x=%.16lf em %d iteracoes\n", x, N);
            return list;
        }
        N++;
        x0 = x;
    }
}

int main(){
    //============================================================

    printf("Equacao a) x-cos(x)=0\n");

    int B1, S1, N1, H1;//Tamanho das listas com as raizes iteradas [INICIAL METÓDO][NUMERO RESPECTIVO A EQUAÇÃO]
    double* list_bissection_1 = bissection_method(f1, 0, 1, &B1);//aplica o método da bissecção, retorna um array com as raizes iteradas e guarda o tamanho do array na variavel B1
    //f1: função a ser aplicado o método
    //0 e 1: parametros iniciais
    //B1: tamanho do array de raizes iteradas a ser retornado
    double* list_secant_1 = secant_method(f1, 0, 1, &S1);
    double* list_newton_1 = newton_method(f1, df1, 0, &N1);
    double* list_halley_1 = halley_method(f1, df1, ddf1, 0, &H1);
    printf("\n\n");

    //============================================================

    printf("Equacao b) x^3-9x^2+27x-27=0\n");

    int B2, S2, N2, H2;
    double* list_bissection_2 = bissection_method(f2, 0, 4, &B2);
    double* list_secant_2 = secant_method(f2, 4, 5, &S2);
    double* list_newton_2 = newton_method(f2, df2, 3.5, &N2);
    double* list_halley_2 = halley_method(f2, df2, ddf2, 3.5, &H2);
    printf("\n\n");

    //============================================================

    printf("Equacao c) e^x-cos(x)=0\n");

    int B3, S3, N3, H3;
    double* list_bissection_3 = bissection_method(f3, -2, -1, &B3);
    double* list_secant_3 = secant_method(f3, -3, -1, &S3);
    double* list_newton_3 = newton_method(f3, df3, 1, &N3);
    double* list_halley_3 = halley_method(f3, df3, ddf3, 1, &H3);
    printf("\n\n");

    //============================================================

//=============================== LIBERAÇÃO DA MEMÓRIA ALOCADA ====================================================
    free(list_bissection_1);
    free(list_bissection_2);
    free(list_bissection_3);

    free(list_secant_1);
    free(list_secant_2);
    free(list_secant_3);

    free(list_newton_1);
    free(list_newton_2);
    free(list_newton_3);

    free(list_halley_1);
    free(list_halley_2);
    free(list_halley_3);
//=================================================================================================================
    return 0;
}