Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #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;
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement