REGIONAL CATALO

ENGENHARIA CIVIL
CLCULO NUMRICO

Eva Tacyanne Nunes Marques

CLCULO NUMRICO
ALGORITMO LINGUAGEM C

CATALO
2017
Sumrio
1. INTRODUO .........................................................................................................3
1.1. Linguagem C...................................................................................................... 3
2. ALGORITMOS ..........................................................................................................4
2.1. Zeros de funes ................................................................................................ 4
2.2. Sistemas lineares ................................................................................................ 5
2.4. Interpolao Polinomial ....................................................................................11
2.5. Integrao numrica FRMULAS DE NEWTON CTES ......................... 12
3. CONCLUSO .........................................................................................................14
4. REFERNCIAS BIBLIOGRFICAS .....................................................................15

2
 1. INTRODUO

O objetivo principal do estudo da lgica de programao a construo de

algoritmos que sejam de modo, coerentes e vlidos. Um algoritmo pode ser definido como
uma sequncia de passos que visam atingir um objetivo muito bem definido.

Na medida em que precisamos especificar em sequncia de passos, necessrio

utilizar ordem, ou seja, pensar com ordem, portanto utiliza-se a lgica.

Quando elaboramos um algoritmo, devemos especificar aes claras e precisas

que a partir de um resultado inicial, aps um perodo de tempo finito produza um estado
final previsvel e bem definido. Isso significa que o algoritmo fixa um padro de
comportamento a ser seguida, uma norma de execuo a ser trilhada, com vistas a alcanar,
como resultado final, a soluo de um problema, garantindo que sempre que executado,
sob as mesmas condies produza o mesmo resultado.

1.1. Linguagem C

Muitas linguagens foram desenvolvidas e por muitos anos utilizadas com

diferentes objetivos e caractersticas, tais como: Fortran, Cobol, Basic, Algols, Pascal e
etc. Mas o que C? C o nome de uma linguagem atualmente utilizada em diferentes
reas e propsitos. Faz parte hoje de uma linguagem considerada avanada, desenvolvida
nos laboratrios Bell nos anos 70.

A definio formal da linguagem pode ser encontrada no livro The C

Programming Language de Brian W. Kernighan e Dennis M. Ritchie (os pais da
linguagem). Nos anos 80 iniciou-se um trabalho de criao de um padro chamado C
ANSI (American National Standardization Institute).

uma linguagem de nvel mdio, pois pode-se trabalhar em um nvel prximo ao

da mquina ou como uma linguagem de alto nvel como outras existentes.

3
 2. Algoritmos

2.1. Zeros de funes

Um dos problemas que ocorrem mais frequentemente em trabalhos cientficos

calcular as razes de equaes da forma: f(x) = 0. A funo f(x) pode ser um polinmio
em x ou uma funo transcendente. Em raros casos possvel obter as razes exatas de
f(x)= 0, como ocorre, por exemplo, supondo-se f(x) um polinmio fatorvel. Sendo assim,
mtodos numricos iterativos so utilizados para determinar aproximadamente a soluo
real x. O processo para encontrar uma soluo envolve duas fases: Isolamento das razes
e o refinamento.

A seguir um modelo algoritmo de exemplificao atribudo a zeros de funes.

Mtodo de Newton-Raphson

#include <stdio.h>
#include <math.h>

main()
{int i;
double xn, x0,xn_1;
double erro;
printf("\n Metodo de Newton-Rhapson para zeros de funcoes f(x).\n\n");
printf("\n Funcao utilizada como exemplo: f(x)= x^2 - 5\n\n");
printf(" Entre com a condicao inicial(xo):");
scanf("%lf",&x0);
printf("\n Erro maximo: ");
scanf("%lf",&erro);
xn = x0;
i = 0;
do { xn_1 = xn;
xn = xn_1 - (pow(xn_1,2) - 5) / (2*xn_1);
i++;
printf("\nx[%2d] = %20.17f",i,xn); }
while (fabs(xn - xn_1) > erro);

4
printf ("\n A raiz obtida foi: %20.17f\n",xn);
return 0; }

2.2. Sistemas lineares

A resoluo de sistemas lineares um problema que surge nas mais diversas reas (ex.
previso do tempo, otimizao de sinais de transito e linhas de metr, mecnica quntica,
etc). Em caso geral os sistemas lineares envolvem m equaes com n incgnitas, o sistema
pode apresentar uma nica soluo, infinitas solues ou no admitir soluo alguma.
Este sistema pode ser descrito na forma matricial Ax=b com A E Rnxm e x, b E Rn.
Analisam-se duas classes de esquemas numricos os mtodos iterativos e mtodos diretos

A seguir um modelo algoritmo de exemplificao atribudo a sistemas lineares.

// Mtodo de eliminao de Gauss para soluo de equaes.

#include <stdio.h>
#include <conio.h>

void main()
{ int i,j,k,n; float temp,a[9][9],x[9]; char pausa='\0';

// Leitura do numero de equaes.

clrscr(); cout<<"Entre com o numero de equaes:"; cin>>n; n--; clrscr();

//Leitura dos termos das equaes.

for (i=0;i<=n;i++)
{ cout<<"Linha <<i<<\n";
for (j=0;j<=n;j++)
{ cout<<"Fornea o termo de <<j<>a[i][j]; }
cout<<"O valor da soluo e:";cin>>a[i][j];
clrscr();}

// Mostra a matriz original

cout<<"\n\n\n\nMatriz original:\n";
for (i=0;i<=n;i++)
{ for (j=0;j<=n+1;j++) {cout.width(8); cout<<<"\n";}

// Processo de triangularizao da matriz.

for (k=0;k<n;k++)
for (i=k+1;i<=n;i++)
{ temp=(-1.0)*a[i][k]/a[k][k]; for (j=0;j<=n+1;j++) a[i][j]=(temp*a[k][j])+a[i][j]; }
// Mostra a matriz modificada
cout<<"\n\n\n\nMatriz modificada:\n";
for (i=0;i<=n;i++)
{ for (j=0;j<=n+1;j++) {cout.width(8); cout<<<"\n";}

5
/* PAUSA */ do { pausa=getch();} while (pausa=='\0');
// Determinao da soluo das equaes.
clrscr();
for (i=n;i>=0;i=i-1)
{ x[i]=a[i][n+1]; for (j=n;j>i;j=j-1) x[i]-=x[j]*a[i][j]; x[i]=x[i]/a[i][i];}

// Sada de Resultados.
for (i=0;i<=n;i++)
cout<<"X[<<i<<<x[i]<<\n;

/* PAUSA */ do { pausa=getch();} while (pausa=='\0');}

2.3.Ajuste de curvas: MTODO DOS MNIMOS QUADRADOS

Em geral, experimentos geram uma gama de dados que devem ser analisados para a
criao de um modelo. Tal analise tem como objetivo determinar certas propriedades para
se obter uma funo matemtica que represente ou que se ajuste aos dados pr-
estabelecidos, de modo que, permita fazer simulaes do processo de forma confivel,
reduzindo as possveis repeties desnecessrias. Portanto, o esquema dos mnimos
quadrados fornece uma funo que melhor representa os dados pr-estabelecidos.

A seguir um modelo algoritmo de exemplificao atribudo ao ajuste de curvas.

Determinar a parbola de equao = 1 2 + 21 + 3 que melhor se ajusta aos

pontos (x1, y1) = (2, 0), (x2, y2) = (1, 2), (x3, y3) = (1, 2) e (x4, y4) = (2, 10) no sentido
4
dos mnimos quadrados, ou seja, tal que =1( 1 2 2 3)2 seja mnimo.
Devemos criar trs funes: f1(x) = 2 , f2(x) = x e f3(x) = 1. Para criar tais funes em
C, podemos fazer o seguinte cdigo.

#include<stdio.h> /* controle de entrada e sada */

#include<stdlib.h> /* biblioteca padro */

float F(int i, float x) /* funes f1(x), f2(x), , fm(x) */

{
switch (i)
{
case 0:
return (pow(x,2)); /* F(o,x)=x^2 */
break;
case 1:
return (x); /* F (1,x)=x */
break;
case 2:

6
return (1); /* F (2,x)=1 */
break;
}
}
int main ()
{
printf (%f\n, F(0,3)) ; /* escreve F (0,3) */
printf (%f\n, F(1,2016)) ; /* escreve F (2,2016) */
printf (%f\n, F(2,2016)) ; /* escreve F (2,2016) */
system (PAUSE);
}

Portanto a sada desse programa : 9.000000; 2016.000000; 1.000000

Para calcularmos os coeficientes de fij, temos o seguinte cdigo.

# include <stdio.h> /* entrada e sada */
# include <stdlib.h> /* biblioteca padro */

# define m 3 /* nmero de coeficiente a serem determinados */

# define n 4 /* nmero de pontos fornecidos */

float F(int i, float x) /* funes f1(x), f2(x), , fm(x) */

{
switch (i)
{
case 0:
return (pow(x,2)); /* F(o,x)=x^2 */
break;
case 1:
return (x); /* F (1,x)=x */
break;
case 2:
return (1); /* F (2,x)=1 */
break;
}
}
void fij (float f [m] [n], float x[n]) /* retorna os coeficientes fij */
{
int i,j,k;
float soma;
for (i=0; i<=m-1; i++)
{
for (j=i; j<=m-1; j++)
{
soma=0
for (k=0; k<=n-1; k++) */ fij= fi(x1) fj(x1)+ ... + fi(xn) fj(xn) */
{
soma=soma + F(i, x[k]) + F(j, x[k]) ;
}

7
f [i] [j]=soma;
f [j] [i]= f [i] [j];
}
}
}
int main ()
{
float x [n]= {-2,-1,1,2}, /* x1=-2, x2=-1, x3=1, x4=2 */
y [n]= {0,2,2,10}, /* y1=0, y2=2, y3=2, y4=10 */
f [m] [n], b [m];
int i;
fij (f,x); /* calcula a matriz f */
printf (%f\n, f [0] [2] );
system (PAUSE);
}

A sada dos coeficientes de fij de 10.000000

Clculo dos termos independentes b1, b2 e b3.

# include <stdio.h>
# include <stdlib.h>

# define m 3 /* nmero de coeficiente a serem determinados */

# define n 4 /* nmero de pontos fornecidos */

float F(int i, float x) /* funes f1(x), f2(x), , fm(x) */

{
switch (i)
{
case 0:
return (pow(x,2)); /* F(o,x)=x^2 */
break;
case 1:
return (x); /* F (1,x)=x */
break;
case 2:
return (1); /* F (2,x)=1 */
break;
}
}
void bi (float b [m] , float x[n], float y[n]) /* retorna os termos independentes bi */
{
int i, k;
float soma;
for (i=0; i<=m-1; i++)
{
soma=0
for (k=0; k<=n-1; k++) /* yifi(x1) + ... + ynf(xn) */
{
8
soma=soma + y[k] + F(i, x[k]) ;
}
b[i]=soma;
}
}
int main ()
{
float x [n]= {-2,-1,1,2},
y [n]= {0,2,2,10},
f [m] [n], b [m];
int i;
bi (b,x,y);
printf (%f\n, b [2] );
system (PAUSE);
}

A sada dos termos independentes de 14.000000

Programa completo.
Determinao da parbola y=a_1x^2+a_2x+a_3 que melhor se ajusta aos pontos (-2,0),
(-1,2), (1,2) e (2,10),
no sentido dos MNIMOS QUADRADOS.
output: a_1, a_2, a_3

# include <stdio.h> /* entrada e sada */

# include <stdlib.h> /* biblioteca padro */

# define m 3 /* nmero de coeficiente a serem determinados */

# define n 4 /* nmero de pontos fornecidos */

float F(int i, float x) /* funes f1(x), f2(x), , fm(x) */

{
switch (i)
{
case 0:
return (pow(x,2)); /* F(o,x)=x^2 */
break;
case 1:
return (x); /* F (1,x)=x */
break;
case 2:
return (1); /* F (2,x)=1 */
break;
}
}
void fij (float f [m] [n], float x[n]) /* retorna os coeficientes fij */
{
int i,j,k;
float soma;

9
for (i=0; i<=m-1; i++)
{
for (j=i; j<=m-1; j++)
{
soma=0
for (k=0; k<=n-1; k++)
{
soma=soma + F(i, x[k]) + F(j, x[k]) ;
}
f [i] [j]=soma;
f [j] [i]= f [i] [j];
}
}
}
void bi (float b [m] , float x[n], float y[n]) /* retorna os termos independentes bi */
{
int i, k;
float soma;
for (i=0; i<=m-1; i++)
{
soma=0
for (k=0; k<=n-1; k++)
{
soma=soma + y[k] + F(i, x[k]) ;
}
b[i] =soma;

}
}
void solve (float [m] [n] , float [m]); /* resolve o sistema linear */

int main ()
{
float x [n]= {-2,-1,1,2}, /* x1=-2, x2=-1, x3=1, x4=2 */
y [n]= {0,2,2,10}, /* y1=0, y2=2, y3=2, y4=10 */
f [m] [n], b [m];
int i;
fij (f,x);
bi (b,x,y);
solve (f,b);
for (i=0; i<m; i++ )
printf (%f\n, b [i] );
system (PAUSE);
}
void solve (float [m] [n] , float b[m])
{
register in i, j ,k;
float w [m];

for (k=0; k<m; k++) {

10
for (i=0; i<k; i++) {
w [i] = f [k] [i];
for (j=0; j<i; j++)
w [i] -= w [j] * f [i] [j];
f [k] [i] = w [i] * f [i] [i];
}
for (i=0; i<k; i++)
f [k] [k] -= w [i] * f [k] [i];
f [k] [k] = 1.0 / f [k] [k] ;
}

for (k=1; k<m; k++)

for (i=0; i<k; i++)
b [k] -= f [k] [i] * b [i];
for (k=m-1; k>=0; k--) {
b [k] *= f [k] [k];
for (i=k+1; i<m; i++)
b [k] -= f [i] [k] * b [i];
}
}

A sada para a determinao da parbola de 1.000000; 2.000000; 1.000000

Portanto, a1=1; a2=2; a3=1

2.4. Interpolao Polinomial

A interpolao outra forma de encontrar uma funo que represente um conjunto de

dados tabelados. Pode-se estabelecer que, interpolar uma funo, y = f(x), em um
conjunto discreto de pontos pertencentes a um intervalo (a, b), consiste em substitu-la,
ou aproxim-la, por outra funo, y = g(x). Esta condio chamada de condio de
interpolao e o polinmio que satisfaz esta condio chamado de polinmio
interpolador.

A seguir um modelo algoritmo de exemplificao atribudo interpolao polinomial.

/* Determinacao de Polinomio de Interpolador

-> Descricao das Variaveis

* DIM: Dimensao dos vetores

* X[]: Vetor com os pontos x
* Y[]: Vetor com os pontos y
*/
#define N 4
#define DIM 5
#include<stdio.h>

11
main(){
//---Declaracao de Variaveis
float
X[DIM]={30,35,45,50,55},Y[DIM]={0.5,0.57358,0.70711,0.76604,0.81915},L[N];
float P=1,AUX,XB=40,POL=0;
int I,J,K;
for(I=0;I<N;I++){
for(K=0,J=0;J<N;J++,K++){
if(J!=I){
AUX=(XB-X[J])/(X[I]-X[J]);
P=P*AUX;
}
}
L[I]=P;
P=1;
}
for(I=0;I<N;I++){
printf("\nL[%d] = %f",I,L[I]);
POL=POL+Y[I]*L[I];
}
printf("\nPolinomio Interpolador: P|%d|(%f) = %f",N-1,XB,POL);

2.5. Integrao numrica FRMULAS DE NEWTON CTES

Uma forma de se obter uma aproximao para a integral de f(x) num intervalo [a,b],
atravs da integrao numrica . A ideia bsica desse mtodo de integrao a
substituio da funo f(x) por um polinmio que a aproxime razoavelmente no intervalo
[a,b]. Assim o problema fica resolvido pela integrao de polinmios.

A integrao numrica aplicada quando a primitiva da funo no conhecida ou

quando s conhecemos a funo f(x) num conjunto discreto de pontos. As frmulas de
Newton-Ctes so baseadas na estratgia de aproximar a funo f(x) por um polinmio
interpolador e aproximamos a integral pela integral do polinmio.

A seguir um modelo algoritmo de exemplificao atribudo a integrao numrica.

// Integrao numrica utilizando a regra dos trapzios.

#include <stdio.h>

double f(double x);

int main()
12
{
// Declarao de variveis.
int i;
int n = 0; // Nmero de parties.
double a, b; // Limites do intervalo de integrao.
double sum = 0; // Valor do integral.
double h;
double x;

// Entrada de dados.
printf("Este programa calcula o integral de e^(-x^2) no intervalo [a,b]\n\n");
printf("Introduza limite inferior a \n");
scanf("%lf", &a);
printf("Introduza limite superior b (b>a)\n");
scanf("%lf", &b);
printf("Introduza nmero de parties do intervalo (n>1)\n");
scanf("%d", &n);

// Calcular dimenso de cada partio.

h = (b - a) / (n);

// Inicializar x.
x = a;

// Ciclo de clculo.
for (i = 1; i <= n - 1; i++)
{
sum = sum + f(x) + f(x + h);
x = x + h;
}
sum = sum * h / 2;

// Escrita do resultado.
printf("O resultado da soma e': %lf\n", sum);

return 0;
} // end main()

//
// Funo a integrar.
//
double f(double x)
{
return 1.0 / exp(x * x);
} // end f()

13
 3. CONCLUSO

Pode-se definir que o processo de utilizao de recursos algoritmos para clculo

numrico desempenha um fator essencial de segurana e credibilidade dos conceitos
apresentados, tornando-os concretos. Uma vez que, os conceitos de controle do fluxo de
execuo, a estrutura sequencial, a estrutura de seleo e a estrutura de repetio precisa
dos algoritmos maximiza uma correta aplicao dos mtodos estudados.

14
 4. REFERNCIAS BIBLIOGRFICAS

RUGGIERO, M. A. G.; LOPES, V. R. Cculo Numrico: Aspectos tericos e

computacionais. So Paulo: Makron Books, 1996.

PEREIRA, T. A. C.; Algoritmo e Programao de Computadores. UFG

Universidade Federal de Gois. 2013.

http://www1.univap.br/spilling/CN/CN.htm. Acesso em: 27/08/2017

15