SHARE
TWEET

Metódos_Numéricos

coolphase May 25th, 2020 (edited) 1,610 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4. #define EULER 2.718281828459045235360287
  5. #define NMAX 200
  6. #define erro 0.0000000000000001
  7.  
  8. typedef double (*Funcao)(double);
  9.  
  10. //=============================== EQUAÇÕES ====================================================
  11.  
  12. double f1(double x){//Define a 1ª equação
  13.     return x - cos(x);
  14. }
  15.  
  16. double f2(double x){//Define a 2ª equação
  17.     return x*x*x - 9*x*x + 27*x - 27;
  18. }
  19.  
  20. double f3(double x){//Define a 3ª equação
  21.     return pow(EULER,x)-cos(x);
  22. }
  23.  
  24. double df1(double x){//Define a derivada 1ª da 1ª equação
  25.     return 1 + sin(x);
  26. }
  27.  
  28. double df2(double x){//Define a derivada 1ª da 2ª equação
  29.     return 3*x*x - 18*x + 27;
  30. }
  31.  
  32. double df3(double x){//Define a derivada 1ª da 3ª equação
  33.     return pow(EULER,x)+sin(x);
  34. }
  35.  
  36. double ddf1(double x){//Define a derivada 2ª da 1ª equação
  37.     return cos(x);
  38. }
  39.  
  40. double ddf2(double x){//Define a derivada 2ª da 2ª equação
  41.     return 6*x - 18;
  42. }
  43.  
  44. double ddf3(double x){//Define a derivada 2ª da 3ª equação
  45.     return pow(EULER,x)+cos(x);
  46. }
  47.  
  48. //=============================== MÉTODOS ====================================================
  49.  
  50. double* bissection_method(Funcao f, double valor_inicial_a, double valor_inicial_b, int* nB){
  51.     double a=valor_inicial_a, b=valor_inicial_b;//define os parametros iniciais
  52.     double* list = (double*)malloc(2*sizeof(double));//aloca memória para a lista das raizes iteradas
  53.     list[0] = a;//primeiros espaços do array reservados para as condições inicias
  54.     list[1] = b;//
  55.     double c;
  56.     int N = 1;//N: número de iterações
  57.     while(N<=NMAX){ //NMAX: número máximo de iterações
  58.         c = (a+b)/2; //aplica método da bissecção
  59.         list = realloc(list, (N+2)*sizeof(double)); //realoca o tamanho da lista de raizes
  60.         list[N+1] = c;// guarda o valor da nova raiz
  61.         *nB = N+2;//guarda o valor do novo tamanho da lista
  62.         if( f(c)==0 || (b-a)/2 < erro){// condição de parada (b-a) é o tamanho do intervalo atual, deseja-se encontrar um intervalo tão pequeno quanto se queira
  63.             printf("[BISSECCAO]: Encontrou a raiz x=%.16lf em %d iteracoes\n", c, N);
  64.             return list;
  65.         }
  66.         N++;
  67.         if( f(a)*f(c) < 0)//raiz em (a, c)
  68.             b = c;
  69.         else// raiz em [c, b)
  70.             a = c;
  71.     }
  72. }
  73.  
  74. //==========================================================================================
  75.  
  76. double* secant_method(Funcao f, double valor_inicial_0, double valor_inicial_1, int* nS){
  77.     double x0=valor_inicial_0, x1=valor_inicial_1;
  78.     double* list = (double*)malloc(2*sizeof(double));//alocando memoria inicial no array para os valores iniciais
  79.     list[0] = x0;//espaços inicias reservados para as condições iniciais
  80.     list[1] = x1;//
  81.     double x2;
  82.     int N = 1;
  83.     while(N<=NMAX){
  84.         if(f(x1) - f(x0) == 0){//Divisão por zero, interromper iteração
  85.             N--;
  86.             printf("[SECANTE]:   Divisao por 0: iteracao interrompida, raiz encontrada: x=%.16lf em %d iteracoes\n", x2, N);
  87.             return list;
  88.         }
  89.  
  90.         x2 = x1 - f(x1)*(x1 - x0)/(f(x1)-f(x0));//Aplicando o método da secante
  91.         list = realloc(list, (N+2)*sizeof(double));//realocando tamanho do array
  92.         list[N+1] = x2;//adicionando nova raiz a lista
  93.         *nS = N+2;//guardando o valor do tamanho da lista
  94.         if(fabs(x2-x1) < erro || f(x2)==0){//condição de parada
  95.             printf("[SECANTE]:   Encontrou a raiz x=%.16lf em %d iteracoes\n", x2, N);
  96.             return list;
  97.         }
  98.         N++;
  99.         x0 = x1;
  100.         x1 = x2;
  101.     }
  102. }
  103.  
  104. //==========================================================================================
  105.  
  106. double* newton_method(Funcao f, Funcao df, double valor_inicial, int* nN){
  107.     double x0 = valor_inicial;//definindo parametro inicial
  108.     double* list = (double*)malloc(sizeof(double));//alocando memória para o array de raizes
  109.     list[0] = x0;//espaço inicial resevado para o parametro inicial
  110.     double x;
  111.     int N = 1;
  112.     while(N<=NMAX){
  113.         if( df(x0) == 0){//Divisão por zero, interromper iteração
  114.             N--;
  115.             printf("[NEWTON]:   Divisao por 0: iteracao interrompida, raiz encontrada: x=%.16lf em %d iteracoes\n", x, N);
  116.             return list;
  117.         }
  118.  
  119.         x = x0 - (f(x0)/df(x0)); //Aplicando o método de Newton
  120.         list = realloc(list, (N+1)*sizeof(double));//realocando o tamanho do array
  121.         list[N] = x;//guardando a nova raiz
  122.         *nN = N+1;//guardando o novo tamanho do array
  123.         if( (fabs(x-x0) < erro) || (f(x) == 0) ){ //condição de parada
  124.             printf("[NEWTON]:    Encontrou a raiz x=%.16lf em %d iteracoes\n", x, N);
  125.             return list;
  126.         }
  127.         N++;
  128.         x0 = x;
  129.     }
  130. }
  131.  
  132. //==========================================================================================
  133.  
  134. double* halley_method(Funcao f, Funcao df, Funcao ddf, double valor_inicial, int* nH){
  135.     double x0 = valor_inicial;//definindo parametro inicial
  136.     double* list = (double*)malloc(sizeof(double));//alocando memória para o array de raizes
  137.     list[0] = x0;// espaço inicial reservado para o parametro inicial
  138.     double x;
  139.     int N = 1;
  140.     while (N<=NMAX){
  141.         if(((df(x0)*df(x0))-(f(x0)*ddf(x0))/2) == 0){//Divisão por zero, interromper iteração
  142.             N--;
  143.             printf("[HALLEY]:   Divisao por 0: iteracao interrompida, raiz encontrada: x=%.16lf em %d iteracoes\n", x, N);
  144.             return list;
  145.         }
  146.  
  147.         x = x0 - ( f(x0)*df(x0)/((df(x0)*df(x0))-(f(x0)*ddf(x0))/2) ); //aplicando o método de Halley
  148.         list = realloc(list, (N+1)*sizeof(double));//realocando tamanho do array
  149.         list[N] = x;//guardando o valor da nova raiz
  150.         *nH = N+1;//guardando o novo valor do tamanho do array
  151.         if( (fabs(x-x0) < erro) || (f(x)==0) ) {//condição de parada
  152.             printf("[HALLEY]:    Encontrou a raiz x=%.16lf em %d iteracoes\n", x, N);
  153.             return list;
  154.         }
  155.         N++;
  156.         x0 = x;
  157.     }
  158. }
  159.  
  160. int main(){
  161.     //============================================================
  162.  
  163.     printf("Equacao a) x-cos(x)=0\n");
  164.     int B1, S1, N1, H1;//Tamanho das listas com as raizes iteradas [INICIAL METÓDO][NUMERO RESPECTIVO A EQUAÇÃO]
  165.     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
  166.     //f1: função a ser aplicado o método
  167.     //0 e 1: parametros iniciais
  168.     //B1: tamanho do array de raizes iteradas a ser retornado
  169.     double* list_secant_1 = secant_method(f1, 3, 4, &S1);
  170.     double* list_newton_1 = newton_method(f1, df1, 4, &N1);
  171.     double* list_halley_1 = halley_method(f1, df1, ddf1, 5, &H1);
  172.     printf("\n\n");
  173.  
  174.     //============================================================
  175.  
  176.     printf("Equacao b) x^3-9x^2+27x-27=0\n");
  177.  
  178.     int B2, S2, N2, H2;
  179.     double* list_bissection_2 = bissection_method(f2, -1, 4, &B2);
  180.     double* list_secant_2 = secant_method(f2, 0, 10, &S2);
  181.     double* list_newton_2 = newton_method(f2, df2, 3.5, &N2);
  182.     double* list_halley_2 = halley_method(f2, df2, ddf2, 3.5, &H2);
  183.     printf("\n\n");
  184.  
  185.     //============================================================
  186.  
  187.     printf("Equacao c) e^x-cos(x)=0\n");
  188.  
  189.     int B3, S3, N3, H3;
  190.     double* list_bissection_3 = bissection_method(f3, -0.6, 6, &B3);
  191.     double* list_secant_3 = secant_method(f3, -0.5, -0.6, &S3);
  192.     double* list_newton_3 = newton_method(f3, df3, -0.55, &N3);
  193.     double* list_halley_3 = halley_method(f3, df3, ddf3, 10, &H3);
  194.     printf("\n\n");
  195.  
  196.     //============================================================
  197.  
  198.     double ordem_convergencia[4][3];
  199.  
  200.     //a raiz x* é igual para todos os métodos na equação 1
  201.     double roots_B[4][3], roots_S[4][3], roots_N[4][3], roots_H[4][3];
  202.  
  203.     for(int i=0; i < 4; i++){
  204.         roots_B[0][i] = list_bissection_1[B1-i-2];
  205.         roots_B[1][i] = list_bissection_2[B2-i-2];
  206.         roots_B[2][i] = list_bissection_3[B3-i-2];
  207.  
  208.         roots_S[0][i] = list_secant_1[S1-i-2];
  209.         roots_S[1][i] = list_secant_2[S2-i-2];
  210.         roots_S[2][i] = list_secant_3[S3-i-2];
  211.  
  212.         roots_N[0][i] = list_newton_1[N1-i-2];
  213.         roots_N[1][i] = list_newton_2[N2-i-2];
  214.         roots_N[2][i] = list_newton_3[N3-i-2];
  215.  
  216.         roots_H[0][i] = list_halley_1[H1-i-2];
  217.         roots_H[1][i] = list_halley_2[H2-i-2];
  218.         roots_H[2][i] = list_halley_3[H3-i-2];
  219.     }
  220.  
  221.     for(int i=0; i < 3; i++){
  222.         ordem_convergencia[0][i] = log(fabs(roots_B[i][1] - roots_B[i][0])/fabs(roots_B[i][2] - roots_B[i][0]))/log(fabs(roots_B[i][2] - roots_B[i][0])/fabs(roots_B[i][3] - roots_B[i][0]));
  223.         ordem_convergencia[1][i] = log(fabs(roots_S[i][1] - roots_S[i][0])/fabs(roots_S[i][2] - roots_S[i][0]))/log(fabs(roots_S[i][2] - roots_S[i][0])/fabs(roots_S[i][3] - roots_S[i][0]));
  224.         ordem_convergencia[2][i] = log(fabs(roots_N[i][1] - roots_N[i][0])/fabs(roots_N[i][2] - roots_N[i][0]))/log(fabs(roots_N[i][2] - roots_N[i][0])/fabs(roots_N[i][3] - roots_N[i][0]));
  225.         ordem_convergencia[3][i] = log(fabs(roots_H[i][1] - roots_H[i][0])/fabs(roots_H[i][2] - roots_H[i][0]))/log(fabs(roots_H[i][2] - roots_H[i][0])/fabs(roots_H[i][3] - roots_H[i][0]));
  226.  
  227.     }
  228.  
  229.     for(int i=0; i<4; i++){
  230.         for(int j=0; j<3; j++){
  231.             printf("Metodo %d, eq %d: ordem de convergencia: %.16lf\n", i+1, j+1, ordem_convergencia[i][j]);
  232.         }
  233.         printf("\n");
  234.     }
  235.  
  236.  
  237.  
  238.     FILE* file;
  239.     file = fopen("tabela.txt", "w");
  240.     int i;
  241.     fprintf(file, "================================================================================\n");
  242.     fprintf(file, "\nEquacao a) x-cos(x)=0\n\n");
  243.     fprintf(file, "================================================================================\n");
  244.     fprintf(file, "\nMÉTODO DA BISSECCAO\n\n");
  245.     for(i=0; i < B1; i++)
  246.         fprintf(file, "%d: %.16lf\n",i, list_bissection_1[i]);
  247.     fprintf(file, "================================================================================\n");
  248.     fprintf(file, "\nMÉTODO DA SECANTE\n\n");
  249.     for(i=0; i < S1; i++)
  250.         fprintf(file, "%d: %.16lf\n",i, list_secant_1[i]);
  251.     fprintf(file, "================================================================================\n");
  252.     fprintf(file, "\nMÉTODO DE NEWTON\n\n");
  253.     for(i=0; i < N1; i++)
  254.         fprintf(file, "%d: %.16lf\n",i, list_newton_1[i]);
  255.     fprintf(file, "================================================================================\n");
  256.     fprintf(file, "\nMÉTODO DA HALLEY\n\n");
  257.     for(i=0; i < H1; i++)
  258.         fprintf(file, "%d: %.16lf\n",i, list_halley_1[i]);
  259.     fprintf(file, "================================================================================\n");
  260.     fprintf(file, "\nEquacao b) x^3-9x^2+27x-27=0\n\n");
  261.     fprintf(file, "================================================================================\n");
  262.     fprintf(file, "\nMÉTODO DA BISSECCAO\n\n");
  263.     for(i=0; i < B2; i++)
  264.         fprintf(file, "%d: %.16lf\n",i, list_bissection_2[i]);
  265.     fprintf(file, "================================================================================\n");
  266.     fprintf(file, "\nMÉTODO DA SECANTE\n\n");
  267.     for(i=0; i < S2; i++)
  268.         fprintf(file, "%d: %.16lf\n",i, list_secant_2[i]);
  269.     fprintf(file, "================================================================================\n");
  270.     fprintf(file, "\nMÉTODO DE NEWTON\n\n");
  271.     for(i=0; i < N2; i++)
  272.         fprintf(file, "%d: %.16lf\n",i, list_newton_2[i]);
  273.     fprintf(file, "================================================================================\n");
  274.     fprintf(file, "\nMÉTODO DA HALLEY\n\n");
  275.     for(i=0; i < H2; i++)
  276.         fprintf(file, "%d: %.16lf\n",i, list_halley_2[i]);
  277.     fprintf(file, "================================================================================\n");
  278.     fprintf(file, "\nEquacao c) e^x-cos(x)=0\n\n");
  279.     fprintf(file, "================================================================================\n");
  280.     fprintf(file, "\nMÉTODO DA BISSECCAO\n\n");
  281.     for(i=0; i < B3; i++)
  282.         fprintf(file, "%d: %.16lf\n",i, list_bissection_3[i]);
  283.     fprintf(file, "================================================================================\n");
  284.     fprintf(file, "\nMÉTODO DA SECANTE\n\n");
  285.     for(i=0; i < S3; i++)
  286.         fprintf(file, "%d: %.16lf\n",i, list_secant_3[i]);
  287.     fprintf(file, "================================================================================\n");
  288.     fprintf(file, "\nMÉTODO DE NEWTON\n\n");
  289.     for(i=0; i < N3; i++)
  290.         fprintf(file, "%d: %.16lf\n",i, list_newton_3[i]);
  291.     fprintf(file, "================================================================================\n");
  292.     fprintf(file, "\nMÉTODO DA HALLEY\n\n");
  293.     for(i=0; i < H3; i++)
  294.         fprintf(file, "%d: %.16lf\n",i, list_halley_3[i]);
  295.  
  296.  
  297.     fclose(file);
  298. //=============================== LIBERAÇÃO DA MEMÓRIA ALOCADA ====================================================
  299.  
  300.     free(list_bissection_1);
  301.     free(list_bissection_2);
  302.     free(list_bissection_3);
  303.  
  304.     free(list_secant_1);
  305.     free(list_secant_2);
  306.     free(list_secant_3);
  307.  
  308.     free(list_newton_1);
  309.     free(list_newton_2);
  310.     free(list_newton_3);
  311.  
  312.     free(list_halley_1);
  313.     free(list_halley_2);
  314.     free(list_halley_3);
  315. //=================================================================================================================
  316.     return 0;
  317. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top