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("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");

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