Calculo Numerico

Prévia do material em texto

Desenvolvido por Fabrício Aguiar 
Cálculo Numérico - Implementações em C 
 
//CONVERSOR BASE DECIMAL 
 
#include<stdio.h> 
#include<stdlib.h> 
 
#define TRUE 1 
#define FALSE 0 
#define MAX 100 
 
int main(void){ 
 
 int quociente,resto,divisor,dividendo,i,j,vet[MAX],teste; 
 printf("\n\n ------ Conversor de base decimal para uma base qualquer ------\n\n\n\n"); 
 printf("Digite o numero: "); 
 scanf("%ld",&dividendo); 
printf("Digite a base a ser convertida: "); 
 scanf("%ld",&divisor); 
 
 teste = TRUE; 
 
 i = 0; 
 while(teste){ 
 resto = dividendo % divisor; 
 quociente = dividendo/divisor; 
 vet[i] = resto; 
 
 dividendo = quociente; 
 i++; 
 
 if(quociente == 0){ 
 teste = FALSE; 
 vet[i] = 1; 
 } 
 } 
 for(j = i-1; j >= 0; j--){ /*impressão do último para o primeiro*/ 
 printf(" %d", vet[j]); 
 } 
 
 printf("\n\n"); 
 system("pause"); 
 return 0; 
} 
 
 
_________________________________________________________________ 
 
// MÉTODOS NUMÉRICOS 
 
 
#include<stdio.h> 
#include<stdlib.h> 
#include<math.h> 
 
int menu(void); 
void bissecao(float a, float b, float c); 
void posicaofalsa(float a, float b, float c); 
void pontofixo(float a, float b, float c, float x0); 
void newton(float a, float b, float c, float x0); 
void secante(float a, float b, float c, float x0, float x1); 
 
float polinomio(float); 
float derivada(float); 
float quici(float); 
float mod(float); 
//função x³-x-1 
 
main(){ 
 int opc; 
 float a,b,e,x,fx,d,h,x0,x1; 
 
 
 do{ 
 opc = menu(); 
 switch(opc){ 
 case 1: 
 printf("\nMETODO DA BISSECAO:\n\n"); 
 printf("Entre com a: ",a); 
 scanf("%f",&a); 
 printf("Entre com b: ",b); 
 scanf("%f",&b); 
 printf("Entre com a precisao: ",e); 
 scanf("%f",&e); 
 d=b-a; 
 if (d<e){ 
 x= a+b; 
 x=x/2; 
 fx= polinomio(x); 
 printf(" \nx= %f e f(x)= %f",x,fx); 
 } 
 bissecao(a,b,e); 
 
 break; 
 case 2: 
 printf("\nMETODO DA POSICAO FALSA:\n\n"); 
 printf("Entre com a: ",a); 
 scanf("%f",&a); 
 printf("Entre com b: ",b); 
 scanf("%f",&b); 
 printf("Entre com a precisao: ",e); 
 scanf("%f",&e); 
 d=b-a; 
 if (d<e){ 
 x= a+b; 
 x=x/2; 
 fx= polinomio(x); 
 printf(" \nx= %f e f(x)= %f",x,fx); 
 } 
 posicaofalsa(a,b,e); 
 break; 
 case 3: 
 printf("\nMETODO DO PONTO FIXO:\n\n"); 
 printf("Q(x) = (x+1)^1/3\n\n"); 
 printf("Entre com a: ",a); 
 scanf("%f",&a); 
 printf("Entre com b: ",b); 
 scanf("%f",&b); 
 printf("Entre com a precisao: ",e); 
 scanf("%f",&e); 
 printf("Entre com o x0: ",x0); 
 scanf("%f",&x0); 
 h=polinomio(x0); 
 h=mod(h); 
 if (h<e){ 
 x= x0; 
 fx= polinomio(x); 
 printf(" \nx= %f e f(x)= %f",x,fx); 
 } 
 pontofixo(a,b,e,x0); 
 break; 
 case 4: 
 printf("\nMETODO DE NEWTON:\n\n"); 
 printf("Entre com a: ",a); 
 scanf("%f",&a); 
 printf("Entre com b: ",b); 
 scanf("%f",&b); 
 printf("Entre com a precisao: ",e); 
 scanf("%f",&e); 
 printf("Entre com o x0: ",x0); 
 scanf("%f",&x0); 
 h=polinomio(x0); 
 h=mod(h); 
 if (h<e){ 
 x= x0; 
 fx= polinomio(x); 
 printf(" \nx= %f e f(x)= %f",x,fx); 
 } 
 newton(a,b,e,x0); 
 break; 
 case 5: 
 printf("Entre com a: ",a); 
 scanf("%f",&a); 
 printf("Entre com b: ",b); 
 scanf("%f",&b); 
 printf("Entre com a precisao: ",e); 
 scanf("%f",&e); 
 printf("Entre com o x0: ",x0); 
 scanf("%f",&x0); 
 printf("Entre com o x1: ",x1); 
 scanf("%f",&x1); 
 h=polinomio(x0); 
 h=mod(h); 
 if (h<e){ 
 x= x0; 
 fx= polinomio(x); 
 printf(" \nx= %f e f(x)= %f",x,fx); 
 } 
 secante(a,b,e,x0,x1); 
 break; 
 case 6: 
 system("funcao.pdf"); 
 break; 
 case 7: 
 printf("Encerrando o programa.\n\n"); 
 break; 
 default: 
 printf("Opcao invalida.\n<Enter>" ); 
 fflush(stdin); 
 getchar(); 
 break; 
 } 
 }while(opc!=7); 
} 
 
int menu(void){ 
 int ret; 
 printf("\n\n\n"); 
 printf("===== f(x)= X^3 - X - 1 =====\n\n\n"); 
 printf("[1] - bissecao\n"); 
 printf("[2] - posicao falsa\n"); 
 printf("[3] - pontofixo \n"); 
 printf("[4] - newton\n"); 
 printf("[5] - secante\n"); 
 printf("[6] - grafico\n"); 
 printf("[7] - Sair\n"); 
 printf("\n\nEntre com a opcao: "); 
 fflush(stdin); 
 scanf("%d",&ret); 
 return ret; 
} 
 
float mod(float a){ 
 float x; 
 x= a*a; 
 x=sqrt(x); 
 return x; 
} 
 
float polinomio(float a){ 
 float x; 
 x = (a*a)*a; 
 x= x - a; 
 x= x-1; 
 return x; 
 } 
 
float quici(float a){ 
 float x,y; 
 y=(1.0/3.0); 
 x = a+1; 
 x= pow(x,y); 
 return x; 
} 
 
float derivada(float a){ 
 float x; 
 x = (a*a)*3; 
 x= x-1; 
 return x; 
 } 
 
void bissecao(float a, float b, float c){ 
 int cont=0; 
 float x,fx,fa,fb,s; 
 do{ 
 cont = cont+1; 
 fa=polinomio(a); 
 fb=polinomio(b); 
 x=a+b; 
 x=x/2; 
 fx=polinomio(x); 
 if(fx<0){ 
 a=x; 
 s=b-a; 
 } 
 if(fx>0){ 
 b=x; 
 s=b-a; 
 } 
 
 printf("\n iteracao : %d | b-a = %f | x = %f | f(x) = %f ",cont,s,x,fx); 
 }while(s>c); 
 
 
 
} 
 
void posicaofalsa(float a, float b, float c){ 
 int cont=0; 
 float x,fx,fa,fb,s,y,j,l,m; 
 do{ 
 
 cont = cont+1; 
 fa=polinomio(a); 
 fb=polinomio(b); 
 y=fb-fa; 
 j=a*fb; 
 l=b*fa; 
 x=j-l; 
 x=x/y; 
 
 fx=polinomio(x); 
 m=mod(fx); 
 if(fx<0){ 
 a=x; 
 s=b-a; 
 } 
 if(fx>0){b=x; 
 s=b-a; 
 } 
 
 printf("\n iteracao : %d | b-a = %f | x = %f | f(x) = %f ",cont,s,x,fx); 
 }while(m>=c); 
 
 
 
} 
 
void pontofixo(float a, float b, float c, float x0){ 
 
 //x0=1; 
 int cont=0; 
 float x,s,v,d,fx; 
 do{ 
 cont = cont+1; 
 x = quici(x0); 
 fx=polinomio(x); 
 v=mod(fx); 
 d=x-x0; 
 d=mod(d); 
 if((v<c)||(d<c)){ 
 printf("\n iteracao : %d | x = %f | f(x) = %f ",cont,x,fx); 
 break; 
 } 
 x0=x; 
 
 printf("\n iteracao : %d | x = %f | f(x) = %f ",cont,x,fx); 
 }while((v>c)||(d>c)); 
 
 
 
 } 
 
void newton(float a, float b, float c, float x0){ 
 
 int cont=0; 
 float x,s,v,d,fx,w,k,h; 
 do{ 
 cont = cont+1; 
 w = polinomio(x0); 
 k=derivada(x0); 
 h=w/k; 
 x=x0-h; 
 fx=polinomio(x); 
 v=mod(fx); 
 d=x-x0; 
 d=mod(d); 
 if((v<c)||(d<c)){ 
 printf("\n iteracao : %d | x = %f | f(x) = %f ",cont,x,fx); 
 break; 
 } 
 x0=x; 
 
 printf("\n iteracao : %d | x = %f | f(x) = %f ",cont,x,fx); 
 }while((v>c)||(d>c)); 
 
 
 
 } 
 
void secante(float a, float b, float c, float x0, float x1){ 
 
 int cont=0; 
 float x,s,v,d,fx,w,k,h,j,l,t; 
 j=polinomio(x1); 
 j=mod(j); 
 l=x1-x0; 
 l=mod(l); 
 if ((j<c)||(l<c)){ 
 x= x1; 
 fx= polinomio(x); 
 printf(" \nx= %f e f(x)= %f",x,fx); 
 } 
 
 do{ 
 cont = cont+1; 
 w=x1-x0; 
 k=polinomio(x1); 
 h=polinomio(x0); 
 t=k-h; 
 k= k/t; 
 k=k*w; 
 x=x1-k; 
 fx=polinomio(x); 
 v=mod(fx); 
 d=x-x1; 
 d=mod(d); 
 if((v<c)||(d<c)){ 
 printf("\n iteracao : %d | x = %f | f(x) = %f ",cont,x,fx); 
 break; 
 } 
 x0=x1; 
 x1=x; 
 
 
 printf("\n iteracao : %d | x = %f | f(x) = %f ",cont,x,fx); 
 }while((v>c)||(d>c)); 
 
 
 
 } 
 
 
_________________________________________________________________ 
 
//SISTEMA DIRETO 
 
#include<stdio.h> 
#include<stdlib.h> 
#include<math.h> 
 
int menu(void); 
void trisuperior(float a[4][4], float b[4]); 
void gauss(float a[4][4], float b[4]); 
void LU(float a[4][4], float b[4]); 
void cholesky(float a[4][4]); 
 
 
main(){ 
 int opc,i,j; 
 float a[4][4]; 
 float b[4]; 
 float x[4]; 
 
 
 do{ 
 opc = menu(); 
 switch(opc){ 
 case 1: 
 printf("\nMETODO DE GAUSS:\n\n"); 
 for(i=0;i<4;i++){ 
 for(j=0;j<4;j++){ 
 printf("Entre com a[%d][%d]: ",i+1,j+1,a[i][j]); 
 scanf("%f",&a[i][j]); 
} 
} 
 for(i=0;i<4;i++){ 
 printf("Entre com b[%d]: ",i+1,b[i]); 
 scanf("%f",&b[i]); 
} 
for(i=0;i<4;i++){ 
 printf("|"); 
 for(j=0;j<4;j++){ 
 printf(" %3.2f ",a[i][j]); 
 } 
 printf("| %.2f |\n",b[i]); 
 } 
 printf("\n"); 
 
 gauss(a,b); 
 
 break; 
 case 2: 
 printf("\nFATORACAO LU:\n\n"); 
 for(i=0;i<4;i++){ 
 for(j=0;j<4;j++){ 
 printf("Entre com a[%d][%d]: ",i+1,j+1,a[i][j]); 
 scanf("%f",&a[i][j]); 
} 
} 
 for(i=0;i<4;i++){ 
 printf("Entre com b[%d]: ",i+1,b[i]); 
 scanf("%f",&b[i]); 
} 
for(i=0;i<4;i++){ 
 printf("|"); 
 for(j=0;j<4;j++){ 
 printf(" %3.2f ",a[i][j]); 
 } 
 printf("| %.2f |\n",b[i]); 
 } 
 printf("\n"); 
 LU(a,b); 
 break; 
 case 3: 
 printf("\nFATORACAO DE CHOLESKY:\n\n"); 
 for(i=0;i<4;i++){ 
 for(j=0;j<4;j++){ 
 printf("Entre com a[%d][%d]: ",i+1,j+1,a[i][j]); 
 scanf("%f",&a[i][j]); 
} 
} 
 
 cholesky(a); 
 
 break; 
 
 case 4: 
 printf("Encerrando o programa.\n\n"); 
 break; 
 default: 
 printf("Opcao invalida.\n<Enter>" ); 
 fflush(stdin); 
 getchar(); 
 break; 
 } 
 }while(opc!=4); 
} 
 
int menu(void){ 
 int ret; 
 printf("\n\n\n"); 
 printf("SISTEMAS METODO DIRETO\n\n"); 
 printf("[1] - Gauss\n"); 
 printf("[2] - LU\n"); 
 printf("[3] - Cholesky \n"); 
 printf("[4] - Sair\n"); 
 printf("\n\nEntre com a opcao: "); 
 fflush(stdin); 
 scanf("%d",&ret); 
 return ret; 
} 
 
float mod(float a){ 
 float x; 
 x= a*a; 
 x=sqrt(x); 
 return x; 
} 
 
void trisuperior(float a[4][4], float b[4]){ 
 float x[4],s,h; 
 int k,i,j,n; 
 n=4; 
 if(a[n-1][n-1]!=0){ 
 if(b[n-1]==0){ 
 x[n-1]=0; 
 }else{ 
 x[n-1]=b[n-1]/a[n-1][n-1]; 
 } 
 } 
 n=n-1; 
 x[n-1]=b[n-1]/a[n-1][n-1]; 
 
 for (k=n-1;k>-1;k--){ 
 s=0; 
 for(j=k+1;j<n;j++){ 
 h=a[k][j]*x[j]; 
 s=s+h; 
 x[k]=b[k]-s; 
 } 
 x[k]=x[k]/a[k][k]; 
 } 
 
 
 for(i=0;i<4;i++){ 
 printf("|"); 
 for(j=0;j<4;j++){ 
 printf("%3.2f ",a[i][j]); 
 } 
 printf("| %.2f | = | %.2f |\n",b[i],x[i]); 
 } 
 printf("\n"); 
} 
 
void gauss(float a[4][4], float b[4]){ 
 int k,i,j,n=4; 
 float m,r,h,y; 
 
 
 
 for (k=0;k<n-1;k++){ 
 for (i=k+1;i<n-1;i++){ 
 m=a[i][k]/a[k][k]; 
 a[i][k]=0; 
 for (j=k+1;j<n-1;j++){ 
 h=m*a[k][j]; 
 a[i][j]=a[i][j]- h; 
 } 
 y=m*b[k]; 
 b[i]=b[i]-y;} 
 } 
 
 
 
 trisuperior(a,b); 
 
} 
 
void LU(float a[4][4], float b[4]){ 
 float c[4],pv,m,q,ux,soma,linha,t,y[4],x[4],z,l[4][4],u[4][4]; 
 int p[4],i,j,k,r,aux,n=4; 
 
 linha=0.0; 
 for(i=n-1;i>=0;i--){ 
 for(j=0;j<n;j++){ 
 linha = linha + a[i][j]; 
 } 
 if(linha==0){ 
 n=n-1; 
 } 
 } 
 
 for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 l[i][j]=0; 
 u[i][j]=0; 
 } 
 l[i][i]=1; 
 } 
 
 
 j=n-1; 
 for (i=0;i<n;i++){ 
 p[i]=j; 
 j--; 
 } 
 for(k=0;k<n-1;k++){ 
 pv = mod(a[k][k]); 
 r=k; 
 for(i=k+1;i<n;i++){ 
 m = mod(a[i][k]); 
 if (m >pv){ 
 pv=m; 
 r=i; 
 } 
 } 
 if(pv==0){ 
 printf("a matriz A é singular"); 
 break; 
 } 
 if(r!=k){ 
 aux =p[k]; 
 p[k]=p[r]; 
 p[r]=aux; 
 for(j=0;j<n;j++){ 
 ux=a[k][j]; 
 a[k][j]=a[r][j]; 
 a[r][j]=ux; 
 } 
 } 
 
 for(i=k+1;i<n;i++){ 
 m=a[i][k]/a[k][k]; 
 a[i][k]=m; 
 for(j=k+1;j<n;j++){ 
 q=m*a[k][j]; 
 a[i][j]=a[i][j]-q; 
 } 
 } 
 } 
 
 //resolução sistemas triangulares 
 
 
 
 for(i=0;i<n;i++){ 
 r=p[i]; 
 c[i]=b[r]; 
 } 
 
 for(i=0;i<n;i++){ 
 soma=0; 
 for(j=0;j<=i-1;j++){ 
 t=(a[i][j]*y[j]); 
 l[i][j]=a[i][j]; 
 soma=soma+t; 
 } 
 y[i]=c[i]-soma; 
 } 
 for(i=n-1;i>=0;i--){ 
 soma=0; 
 for(j=i+1;j<n+1;j++){ 
 t=(a[i][j]*x[j]); 
 //u[i][j]=a[i][j]; 
 soma=soma+t; 
 } 
 z=y[i]-soma; 
 x[i]=z/a[i][i]; 
 } 
 
for (i=0;i<n;i++){ 
 p[i]=i; 
 } 
 for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 r=p[i]; 
 printf("p[%d]=%d\n",i,p[i]); 
 u[i][j]=a[r][j]; 
 } 
 } 
 
 
 for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 if(i>j){ 
 u[i][j]=0; 
 } 
 } 
 } 
 
 
 printf("L= \n"); 
 for(i=0;i<n;i++){ 
 printf("|"); 
 for(j=0;j<n;j++){ 
 printf(" %3.2f ",l[i][j]); 
 } 
 printf("|\n"); 
 } 
 printf("\n"); 
 printf("U= \n"); 
 for(i=0;i<n;i++){ 
 printf("|"); 
 for(j=0;j<n;j++){ 
 printf(" %3.2f ",u[i][j]); 
 } 
 printf("|\n"); 
 } 
 printf("\n"); 
 
 
 for(i=0;i<n;i++){ 
 // printf("|"); 
 printf("x = | %.2f | e y = | %.2f |\n",x[i],y[i]); 
 } 
 printf("\n"); 
 
} 
 
void cholesky(float a[4][4]){ 
 int k,j,i,n,t,ts; 
 float soma,linha,g[4][4],q,r,m,h,s; 
 n=4; 
 
 for(i=0;i<n;i++){ 
 
 for(j=0;j<n;j++){ 
 if(i<j){ 
 g[i][j]=0; 
 } 
 } 
 } 
 
 
g[0][0]=sqrt(a[0][0]); 
for(i=0;i<n;i++){ 
 g[i][0]=a[i][0]/g[0][0]; 
} 
 
q=g[1][0]*g[1][0]; 
g[1][1]=a[1][1]- q; 
g[1][1]=sqrt(g[1][1]); 
 
m=g[2][0]*g[1][0]; 
g[2][1]= a[2][1]-m; 
g[2][1]=g[2][1]/g[1][1]; 
 
q=g[2][0]*g[2][0]; 
q=q+(g[2][1]*g[2][1]); 
g[2][2]=a[2][2]-q; 
g[2][2]=sqrt(g[2][2]); 
 
m=g[3][0]*g[1][0]; 
g[3][1]= a[3][1]-m; 
g[3][1]=g[3][1]/g[1][1]; 
 
m=g[3][0]*g[2][0]; 
h=g[3][1]*g[1][1]; 
m=m+h; 
g[3][2]= a[3][2]-m; 
g[3][2]=g[3][2]/g[2][2]; 
 
q=g[3][0]*g[3][0]; 
q=q+(g[3][1]*g[3][1]); 
q=q+(g[3][2]*g[3][2]); 
g[3][3]=a[3][3]-q; 
g[3][3]=sqrt(g[3][3]); 
 
 linha=0.0; 
 for(i=n-1;i>=0;i--){ 
 for(j=0;j<n;j++){ 
 linha = linha + a[i][j]; 
 } 
 if(linha==0){ 
 n=n-1; 
 } 
 } 
 for(i=n-1;i>=0;i--){ 
 for(j=0;j<n;j++){ 
 if(a[i][j]!=a[j][i]){ 
 ts=1; 
 printf("\nErro ! Matriz nao e simetrica\n"); 
 break; 
 } 
 if(ts==1){ 
 break; 
 } 
 } 
 } 
 
 if(ts!=1){ 
 for(i=0;i<n;i++){ 
 printf("|"); 
 for(j=0;j<n;j++){ 
 printf("%3.2f ",g[i][j]); 
 } 
 printf("|\n"); 
 } 
 printf("\n"); 
 } 
 } 
 
 
_________________________________________________________________ 
 
//SISTEMA ITERATIVO 
 
#include<stdio.h> 
#include<stdlib.h> 
#include<math.h> 
 
int menu(void); 
void jacobi(float a[4][4], float b[4],float x[4],float e); 
void seidel(float a[4][4], float b[4],float x[4],float e); 
 
 
 
main(){ 
 int opc,i,j; 
 float a[4][4]; 
 float b[4]; 
 float x[4]; 
 float e; 
 
 
 do{ 
 opc = menu(); 
 switch(opc){ 
 case 1: 
 printf("\nMETODO DE GAUSS-JACOBI:\n\n"); 
 for(i=0;i<4;i++){ 
 for(j=0;j<4;j++){ 
 printf("Entre com a[%d][%d]: ",i+1,j+1); 
 scanf("%f",&a[i][j]); 
} 
} 
 for(i=0;i<4;i++){ 
 printf("Entre com b[%d]: ",i+1); 
 scanf("%f",&b[i]); 
} 
 for(i=0;i<4;i++){ 
 printf("Entre com x0[%d]: ",i+1); 
 scanf("%f",&x[i]); 
} 
printf("Entrecom a precisao: "); 
 scanf("%f",&e); 
 printf("\n"); 
 for(i=0;i<4;i++){ 
 printf("|"); 
 for(j=0;j<4;j++){ 
 printf(" %3.2f ",a[i][j]); 
 } 
 printf("| %.2f |\n",b[i]); 
 } 
 printf("\n"); 
 
 jacobi(a,b,x,e); 
 
 break; 
 case 2: 
 printf("\nMETODO DE GAUSS-SEIDEL:\n\n"); 
 for(i=0;i<4;i++){ 
 for(j=0;j<4;j++){ 
 printf("Entre com a[%d][%d]: ",i+1,j+1); 
 scanf("%f",&a[i][j]); 
} 
} 
 for(i=0;i<4;i++){ 
 printf("Entre com b[%d]: ",i+1); 
 scanf("%f",&b[i]); 
} 
 for(i=0;i<4;i++){ 
 printf("Entre com x0[%d]: ",i+1); 
 scanf("%f",&x[i]); 
} 
printf("Entre com a precisao: "); 
 scanf("%f",&e); 
 printf("\n"); 
 for(i=0;i<4;i++){ 
 printf("|"); 
 for(j=0;j<4;j++){ 
 printf(" %3.2f ",a[i][j]); 
 } 
 printf("| %.2f |\n",b[i]); 
 } 
 printf("\n"); 
 
 seidel(a,b,x,e); 
 break; 
 
 
 case 3: 
 printf("Encerrando o programa.\n\n"); 
 break; 
 default: 
 printf("Opcao invalida.\n<Enter>" ); 
 fflush(stdin); 
 getchar(); 
 break; 
 } 
 }while(opc!=3); 
} 
 
int menu(void){ 
 int ret; 
 printf("\n\n\n"); 
 printf("SISTEMAS METODO ITERATIVO\n\n"); 
 printf("[1] - Gauss-Jacobi\n"); 
 printf("[2] - Gauss-Seidel\n"); 
 printf("[3] - Sair\n"); 
 printf("\n\nEntre com a opcao: "); 
 fflush(stdin); 
 scanf("%d",&ret); 
 return ret; 
} 
 
float mod(float a){ 
 float x; 
 x= a*a; 
 x=sqrt(x); 
 return x; 
} 
 
 
 
void jacobi(float a[4][4], float b[4],float x[4], float e){ 
 
int i,j,CL,CC,CN,cont,n=4; 
float max,soma,numerador,denominador,linha,m,h,d,z,p,dv,y[4],bt[4],md,nm,bta[4]; 
// x= (k) e y=(k+1) 
 
 linha=0.0; 
 for(i=n-1;i>=0;i--){ 
 for(j=0;j<n;j++){ 
 linha = linha + a[i][j]; 
 } 
 if(linha==0){ 
 n=n-1; 
 } 
 } 
 
max= 0; 
for(i=0;i<n;i++){ 
 soma = 0; 
 for(j=0;j<n;j++){ 
 if(i!=j){ 
 m=mod(a[i][j]); 
 soma=soma+ m; 
 } 
 } 
 m=mod(a[i][j]); 
 soma=soma/m; 
 if(max<soma){ 
 max=soma; 
 } 
 } 
 if(max<1){ 
 printf("\n\nCriterio das linhas satisfeito\n"); 
 CL=1; 
 }else{ 
 CL=0; 
 
 } 
 
 
for(j=0;j<n;j++){ 
soma=0; 
for(i=0;i<n;i++){ 
 if(i!=j){ 
 m=mod(a[i][j]); 
 soma=soma+m; 
 } 
 } 
 m=mod(a[i][j]); 
 soma=soma/m; 
 if(max<soma){ 
 max=soma; 
 } 
 } 
 if(max<1){ 
 printf("\n\nCriterio das colunas satisfeito\n"); 
 CC=1; 
 }else{ 
 CC=0; 
 } 
 
 for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 md=md+mod(a[i][j]); 
 } 
 if(md>nm){ 
 nm=md; 
 } 
 } 
 if(nm<1){ 
 printf("\n\nCriterio das normas satisfeito\n"); 
 CN=1; 
 } 
 
for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 md=md+mod(a[j][i]); 
 } 
 if(md>nm){ 
 nm=md; 
 } 
 } 
 if(nm<1){ 
 printf("\n\nCriterio das normas satisfeito\n"); 
 CN=1; 
 } 
 
 
if(CL==1)printf("\n\nCriterio das linhas satisfeito\n\n"); 
if(CC==1)printf("\n\nCriterio das colunas satisfeito\n\n"); 
if(CN==1)printf("\n\nCriterio das normas satisfeito\n\n"); 
if((CL==1)||(CC==1)||(CN==1)){ 
 cont = 0; 
 do{ 
 cont=cont+1; 
 numerador =0; 
 denominador =0; 
 for(i=0;i<n;i++){ 
 y[i]=0; 
 for(j=0;j<n;j++){ 
 if(i!=j){ 
 h=a[i][j]*x[j]; 
 y[i]=y[i]+h; 
 } 
 } 
 d=b[i]-y[i]; 
 y[i]=1.0/a[i][i]; 
 y[i]=y[i]*d; 
 z=y[i]-x[i]; 
 z=mod(z); 
 if(numerador<z){ 
 numerador =z; 
 } 
 p=mod(y[i]); 
 if(denominador<p){ 
 denominador=mod(y[i]); 
 } 
 } 
 for(i=0;i<n;i++){ 
 x[i]=y[i]; 
 } 
 
 dv=numerador/denominador; 
 
 }while(dv<e); 
 
 
 
 for(i=0;i<n;i++){ 
 printf("x = |%.2f|\n",x[i]); 
 } 
 printf("iteracao : %d\n",cont); 
 
 
 
} 
 
 
} 
void seidel(float a[4][4], float b[4], float x[4], float e){ 
int i,j,CL,CC,CS,CN,cont,n=4; 
float numerador,denominador,linha,t,h,d,v,dv,y[4],m,max,mb,aux,md,nm,bt[4],bta[4],soma; 
 
 linha=0.0; 
 for(i=n-1;i>=0;i--){ 
 for(j=0;j<n;j++){ 
 linha = linha + a[i][j]; 
 } 
 if(linha==0){ 
 n=n-1; 
 } 
 } 
 
 max= 0; 
for(i=0;i<n;i++){ 
 soma = 0; 
 for(j=0;j<n;j++){ 
 if(i!=j){ 
 m=mod(a[i][j]); 
 soma=soma+ m; 
 } 
 } 
 m=mod(a[i][j]); 
 soma=soma/m; 
 if(max<soma){ 
 max=soma; 
 } 
 } 
 if(max<1){ 
 printf("\n\nCriterio das linhas satisfeito\n"); 
 CL=1; 
 }else{ 
 CL=0; 
 
 } 
 
 
for(j=0;j<n;j++){ 
soma=0; 
for(i=0;i<n;i++){ 
 if(i!=j){ 
 m=mod(a[i][j]); 
 soma=soma+m;} 
 } 
 m=mod(a[i][j]); 
 soma=soma/m; 
 if(max<soma){ 
 max=soma; 
 } 
 } 
 if(max<1){ 
 printf("\n\nCriterio das colunas satisfeito\n"); 
 CC=1; 
 }else{ 
 CC=0; 
 } 
 
 for(i=0;i<n;i++){ 
 
 for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 bt[i]=bt[i]+mod(a[i][j]); 
 
 } 
 bt[i]=bt[i]/mod(a[i][i]); 
 for(j=0;j<n;j++){ 
 aux=mod(a[i][j])*bt[i]; 
 } 
bta[i]=bta[i]+aux; 
bta[i]=bta[i]/mod(a[i][i]); 
} 
for(i=0;i<n;i++){ 
 if(mb<bta[i]){ 
 mb=bta[i]; 
} 
} 
if(mb<1){ 
 printf("\n\nCriterio de Sassenfeld satisfeito\n"); 
 CS=1; 
 } 
 
for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 bt[i]=bt[i]+mod(a[j][i]); 
 
 } 
 bt[i]=bt[i]/mod(a[j][j]); 
 for(j=0;j<n;j++){ 
 aux=mod(a[j][i])*bt[i]; 
 } 
bta[i]=bta[i]+aux; 
bta[i]=bta[i]/mod(a[j][j]); 
} 
for(i=0;i<n;i++){ 
 if(mb<bta[i]){ 
 mb=bta[i]; 
} 
} 
if(mb<1){ 
 printf("\n\nCriterio de Sassenfeld satisfeito\n"); 
 CS=1; 
 } 
 
for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 md=md+mod(a[i][j]); 
 } 
 if(md>nm){ 
 nm=md; 
 } 
 } 
 if(nm<1){ 
 printf("\n\nCriterio das normas satisfeito\n"); 
 CN=1; 
 } 
 
for(i=0;i<n;i++){ 
 for(j=0;j<n;j++){ 
 md=md+mod(a[j][i]); 
 } 
 if(md>nm){ 
 nm=md; 
 } 
 } 
 if(nm<1){ 
 printf("\n\nCriterio das normas satisfeito\n"); 
 CN=1; 
 } 
 
 
 
cont=0; 
if(CL==1)printf("\n\nCriterio das linhas satisfeito\n\n"); 
if(CC==1)printf("\n\nCriterio das colunas satisfeito\n\n"); 
if(CN==1)printf("\n\nCriterio das normas satisfeito\n\n"); 
if(CS==1)printf("\n\nCriterio de Sassenfeld satisfeito\n\n"); 
if((CL==1)||(CC==1)||(CN==1)||(CS==1)){ 
do{ 
 cont=cont+1; 
 numerador=0; 
 denominador=0; 
 for(i=0;i<n;i++){ 
 y[i]=0; 
 
 for(j=0;j<n;j++){ 
 if(i!=j){ 
 t=a[i][j]*x[j]; 
 y[i]=y[i]+t; 
 } 
 } 
 
 h=b[i]-y[i]; 
 y[i]=1.0/a[i][i]; 
 y[i]=y[i]*h; 
 
 d=y[i]-x[i]; 
 d=mod(d); 
 v=mod(y[i]); 
 
 if(numerador<d){ 
 numerador = d; 
 
 } 
 if(denominador<v){ 
 denominador=mod(y[i]); 
 
 } 
 
 x[i]=y[i]; 
 dv=numerador/denominador; 
 } 
 
 }while(dv>e); 
 
 for(i=0;i<n;i++){ 
 printf("x = |%.3f|\n",x[i]); 
 } 
 printf("\niteracao = %d",cont); 
 
} 
} 
} 
 
 
_________________________________________________________________ 
 
//INTERPOLAÇÃO 
 
 
#include<stdio.h> 
#include<stdlib.h> 
#include<math.h> 
 
int menu(void); 
void lagrange(void); 
void newton(void); 
 
int retornaIndiceInicial(int numPtos,int grau,float pto,float *x,float *y); 
float retornaDiferencaDividida(int k, float pto,float *x,float *y ); 
 
main(){ 
 int opc,i,j; 
 
 
 do{ 
 opc = menu(); 
 switch(opc){ 
 case 1: 
 printf("\nFORMA DE LAGRANGE:\n\n"); 
 
 lagrange(); 
 
 break; 
 case 2: 
 printf("\nFORMA DE NEWTON:\n\n"); 
 
 newton(); 
 break; 
 
 
 case 3: 
 printf("Encerrando o programa.\n\n"); 
 break; 
 default: 
 printf("Opcao invalida.\n<Enter>" ); 
 fflush(stdin); 
 getchar(); 
 break; 
 } 
 }while(opc!=3); 
} 
 
int menu(void){ 
 int ret; 
 printf("\n\n\n"); 
 printf("INTERPOLACAO\n\n"); 
 printf("[1] - Lagrange\n"); 
 printf("[2] - Newton\n"); 
 printf("[3] - Sair\n"); 
 printf("\n\nEntre com a opcao: "); 
 fflush(stdin); 
 scanf("%d",&ret); 
 return ret; 
} 
 
float mod(float a){ 
 float x; 
 x= a*a; 
 x=sqrt(x); 
 return x; 
} 
 
 
 
void lagrange(void){ 
int n,i,j; 
float *x,*f,xbarra,P,Pn,d,t,h; 
printf("Entre com n: "); 
scanf("%d",&n); 
 
 if(x!=NULL) free(x); 
 
 x = (float*)malloc(n*sizeof(float)); 
 
 if(x==NULL) printf("Erro em alocacao (Definicoes).\n\n" ); 
 
 if(f!=NULL) free(f); 
 
 f = (float*)malloc(n*sizeof(float)); 
 
 if(f==NULL) printf("Erro em alocacao (Definicoes).\n\n" ); 
 
for(i=0;i<n;i++){ 
 
printf("Entre com x[%d]:",i+1 ); 
scanf("%f",&x[i]); 
 
} 
for(i=0;i<n;i++){ 
 
printf("Entre com f[%d]:",i+1 ); 
scanf("%f",&f[i]); 
 
} 
 
printf("Entre com xbarra: "); 
scanf("%f",&xbarra); 
 
Pn = 0; 
for(j=0;j<n;j++){ 
P=1; 
for(i=0;i<n;i++){ 
if(i!=j){ 
d=xbarra - x[i]; 
h = x[j]-x[i]; 
P = P*(d/h); 
} 
} 
t= P*f[j]; 
Pn = Pn + t; 
 
} 
printf("f(xbarra) = %.2f\n", Pn); 
 
 
 
} 
void newton(void){ 
int i,k,t,numPtos,teste,grau; 
float p,h,u,r,m,termo,pto,*x,*y; 
 
printf("Entre com o grau do polinomio: "); 
scanf("%d",&grau); 
printf("Entre com n: "); 
scanf("%d",&numPtos); 
 
 if(x!=NULL) free(x); 
 
 x = (float*)malloc(numPtos*sizeof(float)); 
 
 if(x==NULL) printf("Erro em alocacao (Definicoes).\n\n" ); 
 
 if(y!=NULL) free(y); 
 
 y = (float*)malloc(numPtos*sizeof(float)); 
 
 if(y==NULL) printf("Erro em alocacao (Definicoes).\n\n" ); 
 
for(i=0;i<numPtos;i++){ 
 
printf("Entre com x[%d]:",i+1 ); 
scanf("%f",&x[i]); 
 
} 
for(i=0;i<numPtos;i++){ 
 
printf("Entre com f[%d]:",i+1 ); 
scanf("%f",&y[i]); 
 
} 
 
printf("Entre com o ponto: "); 
scanf("%f",&pto); 
 
k = retornaIndiceInicial(numPtos,grau, pto, x, y ); 
termo = 1; 
p = y[k]; 
 
if(numPtos>=grau){ 
 teste = numPtos; 
}else{ 
 teste=k+1; 
} 
 
for(i=0;i<teste;i++){ 
/*t=k+i;*/ 
h=x[/*t-1*/i]; 
u=pto-h; 
termo = termo * u; 
} 
 
r= retornaDiferencaDividida( k, pto, x, y ); 
//printf("termo=%f e r=%f\n",termo,r); 
m=termo * r; 
p = p + m; 
//} 
printf("O valor do polinomio no ponto dado e: %.2f", p); 
 
} 
 
 
int retornaIndiceInicial(int numPtos,int grau,float pto,float *x,float *y){ 
int i; 
 
if(pto<=x[grau]){ 
 for(i=0;i<=grau;i++){ 
 if(pto<=x[i]){ 
 // printf("< grau pto=%f e x[%d]=%f e y[%d]=%f\n",pto,grau,x[grau],i+1,y[i]);return i; 
 } 
 } 
 } 
if(pto>x[grau]){ 
 for(i=grau;i<=numPtos;i++){ 
 if(pto<=x[i]){ 
 return i; 
 } 
 return 0; 
 } 
 } 
} 
 
 
float retornaDiferencaDividida(int k, float pto,float *x,float *y ){ 
 float d,d1,d2,d3,s,s1; 
 
if(k!=0){ 
d=x[k]-pto; 
d1=x[k]-x[k-1]; 
d2=pto-x[k-1]; 
d3=x[k]-x[k-1]; 
s=y[k-1]*(d/d1); 
s1=y[k]*(d2/d3); 
s=s+s1; 
return s; 
} 
return y[0]; 
 
} 
 
 
_________________________________________________________________ 
 
//INTEGRAL 
 
#include<stdio.h> 
#include<stdlib.h> 
#include<math.h> 
 
int menu(void); 
void trapezio(void); 
void simpson(void); 
 
 
main(){ 
 int opc,i,j; 
 
 
 do{ 
 opc = menu(); 
 switch(opc){ 
 case 1: 
 printf("\nREGRA DOS TRAPEZIOS:\n\n"); 
 
 trapezio(); 
 
 break; 
 case 2: 
 printf("\nREGRA 1/3 SIMPSON:\n\n"); 
 
 simpson(); 
 break; 
 
 
 case 3: 
 printf("Encerrando o programa.\n\n"); 
 break; 
 default: 
 printf("Opcao invalida.\n<Enter>" ); 
 fflush(stdin); 
 getchar(); 
 break; 
 } 
 }while(opc!=3); 
} 
 
int menu(void){ 
 int ret; 
 printf("\n\n\n"); 
 printf("INTEGRAL\n\n"); 
 printf("[1] - Trapezio\n"); 
 printf("[2] - Simpson\n"); 
 printf("[3] - Sair\n"); 
 printf("\n\nEntre com a opcao: "); 
 fflush(stdin); 
 scanf("%d",&ret); 
 return ret; 
} 
 
float mod(float a){ 
 float x; 
 x= a*a; 
 x=sqrt(x); 
 return x; 
} 
 
 
 
void trapezio(void){ 
/*Reais: h, x, soma, R; 
Inteiras: i, n.*/ 
float h,x0,soma,sf,d,R,x[2],*f; 
int i,n; 
 
printf("Entre com n:"); 
scanf("%d",&n); 
if(f!=NULL) free(f); 
 
 f = (float*)malloc(n*sizeof(float)); 
 
 if(f==NULL) printf("Erro em alocacao (Definicoes).\n\n" ); 
 
 
 
printf("Entre com x0:"); 
scanf("%f",&x[0]); 
printf("Entre com xn:"); 
scanf("%f",&x[1]); 
for(i=0;i<=n;i++){ 
printf("Entre com f(x%d):",i); 
scanf("%f",&f[i]); 
} 
 
if(n==0){ 
printf("Divisao por zero"); 
}else if(n<0){ 
printf("Intervalo Invalido"); 
}else{ 
h = x[1] - x[0]; 
h=h/n; 
x0 = x[0] + h; 
soma = f[0]+f[n]; 
for(i=1;i<n;i++){ 
soma = soma + (2*f[i]); 
x0 = x0 + h; 
} 
 
R = (h/2.0) * soma; 
printf("O resultado da integral da funcao f e : %f ", R); 
} 
 
} 
void simpson(void){ 
float h,x0,SomaPares,SomaImpares,soma,R,*f,x[2]; 
int i,n; 
 
printf("Entre com n:"); 
scanf("%d",&n); 
if(f!=NULL) free(f); 
 
 f = (float*)malloc(n*sizeof(float)); 
 
 if(f==NULL) printf("Erro em alocacao (Definicoes).\n\n" ); 
 
 
 
printf("Entre com x0:"); 
scanf("%f",&x[0]); 
printf("Entre com xn:"); 
scanf("%f",&x[1]); 
for(i=0;i<=n;i++){ 
printf("Entre com f(x%d):",i); 
scanf("%f",&f[i]); 
} 
 
if(n==0){ 
printf("Divisao por zero"); 
}else if(n<0){ 
printf("Intervalo Invalido"); 
}else{ 
h = x[1] - x[0]; 
h=h/n; 
x0 = x[0] + h; 
soma = f[0]+f[n]; 
SomaPares =0.0; 
SomaImpares=0.0; 
for(i=1;i<n;i++){ 
if(i%2==0){ 
SomaPares = SomaPares + (2*f[i]); 
}else{ 
 SomaImpares=SomaImpares+(4*f[i]); 
 } 
x0 = x0 + h; 
} 
soma = soma + SomaPares; 
soma= soma + SomaImpares; 
R = (h/3.0) * soma; 
printf("O resultado da integral da funcao f e : %f ",R); 
} 
 
} 
 
Desenvolvido por Fabrício Aguiar