Noções de programação para

o desenvolvimento de ferramentas matemáticas

utilizando a linguagem C

JEANFSON DUTRA DE OLIVEIRA

ANTONIO CARLOS LIMA DO NASCIMENTO
Universidade Federal do Pará

4o Colóquio da Região Centro-Oeste

Novembro de 2015
Sumário

1 ESCREVENDO O PRIMEIRO PROGRAMA: Noções textuais 1

1.1 Estrutura de um programa . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Printf e as strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 TRABALHANDO COM DADOS 3

2.1 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Scanf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 If-else e if-else encadeados . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 LAÇOS DE REPETIÇÃO E FUNÇÕES 7

3.1 O comando FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 O comando WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Onde colocar as funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 ALGUNS ALGORÍTIMOS PARA O ESTUDO DO CÁLCULO 11

4.1 Calculo de volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.2 Cálculo de uma área sob uma curva . . . . . . . . . . . . . . . . . . . . . 14
4.3 Aproximação de raízes reais pelo método da Bisseção . . . . . . . . . . . 15

Referências Bibliográficas 17

iii
 Capítulo 1

ESCREVENDO O PRIMEIRO
PROGRAMA: Noções textuais

1.1 Estrutura de um programa

Um programa é uma sequência de códigos (comandos) escritos de forma
conveniente para solucionar um problema ou visualizar um resultado previsto. A essa
sequência estruturada e lógica de códigos, damos o nome de algorítmo e para que o
mesmo seja compilado é preciso que ele obedeça à estrutura da linguagem trabalhada.
Em C, a estrutura básica para que os compiladores traduzam os comandos para a
linguagem de “máquina”, ou seja, a liguagem binária, são as seguintes:
• Bibliotecas;

• Funções;

• Blocos de códigos.
Abaixo podemos observar um exemplo de estrutura básica de um programa em C.
1 # include < stdio .h >
2 main ()
3 {}
Na linha 1 temos o comando include que adiciona a biblioteca stdio.h. Essa
biblioteca nada mais é do que um arquivo com um conjunto de informações funcionais
presente em algum lugar no disco rígido, que informa ao compilador de que maneira
irá traduzir para a linguagem binária os blocos de código.
Na linha 2 temos uma função chamada main, que vem seguida de () (parênteses)
pois toda função em C deve ser seguida de parênteses. Essa função serve para
inserirmos os blocos de código, ou para ser mais preciso, é aqui que começa o programa
propriamente dito.
Na linha 3 temos os caracteres {} (chaves), é entre as chaves que escrevemos todos os
blocos de código, ou seja, todas as instruções que queremos que o computador execute.
Os blocos de código inseridos a partir da função main() são repletos de outras
funções que indicam de que maneira o computador deverá proceder com as
informações. E para que o computador possa “conversar” com o ser humano através
dos programas, é essencial que esse computador saiba processar textos em nossa

1
 2 Capítulo 1: ESCREVENDO O PRIMEIRO PROGRAMA: Noções textuais

língua. Trabalharemos agora em cima da função que nos permite escrever textos em
um programa.

1.2 Printf e as strings

A printf é a função que nos permite escrever strings (conjunto de caracteres) em
um código (programa) em C. É essa função que faz a comunicação programa-usuário.
Como já foi dito, toda função deve ser seguida de () (parênteses), mas em toda
função que compõe os blocos de código, devem ser seguidas também após os
parênteses de ; (ponto e vírgula), em especial, as frases que quisermos escrever
na printf devem estar entre “ ” (aspas duplas) que por sua vez devem estar entre
parênteses. Resumindo, todas as frases que quisermos escrever em um programa em
C devem estar dentro da função printf(“ ”);.
ATENÇÃO!!!!! VALE LEMBRAR QUE A LINGUAGEM C É CASE SENSITIVE,
OU SEJA, DIFERE ENTRE MAIÚSCULAS E MINÚSCULAS, POR EXEMPLO: Printf
é diferente de printf que é diferente de PRINTF, SENDO ASSIM, printf é uma função
em C mas Printf não existe em C.
EXEMPLO:
Vamos escrever um programa que imprima na tela a famosa frase HELLO
WORLD!.
1 # include < stdio .h >
2 main ()
3 {
4 printf ( " HELLO WORLD ! " ) ;
5 }
A frase que deverá ser impressa pelo programa é : HELLO WORLD!
Podemos usar de vários printf para escrever diferentes frases ou escrever uma
única frase. Vamos reescrever o mesmo programa anterior com três printf:
1 # include < stdio .h >
2 main ()
3 {
4 printf ( " HELLO " ) ;
5 printf ( " " ) ;
6 printf ( " WORLD ! " ) ;
7 }
Note que na linha 5, o printf imprime um ESPAÇO. Todos os espaços são
reconhecidos dentro da printf, mas fora das funções, os espaços não tem sentido, logo,
printf(“1,2,3”); é o mesmo que printf (“1,2,3”);.
Para pularmos linhas dentro da printf, usamos um caractere especial: \n que seria
o mesmo que digitar ENTER se estivéssemos em um editor de texto normal.
Capítulo 2

TRABALHANDO COM DADOS

2.1 Operadores lógicos

Temos que compreender o computador como uma grande máquina de calcular.
Para escrevermos um simples “OI”, o computador faz inúmeros cálculos para
converter em binários os códigos que você digitou no teclado e em seguida processar e
refazer os cálculos para devolver no monitor a palavra que foi digitada. Vamos então
conhecer os operadores lógicos (caracteres especiais) que trabalharemos operações em
C:

• + (símbolo de MAIS) utilizado para somar valores;

• - (símbolo de MENOS) utilizado para subtrair valores;

• * (símbolo de asterisco) utilizado para multiplicar valores;

• / (símbolo de barra invertida) utilizado para dividir valores;

• % (símbolo de porcentagem) utilizado para calcular o RESTO da divisão de

dois valores INTEIROS.

OBSERVAÇÃO: neste último símbolo (%), não faz sentido utilizarmos ao trabalhar
com números reais, pois não existe resto na divisão de dois números reais. Em C, a
operação entre dois números reais produz um número real.
Podemos fazer operações com valores dentro da própria função printf com o
auxílio de outra função chamada scanf, mas antes disso precisamos entender o
conceito de variáveis em C.

2.1.1 Variáveis
Para inserirmos variáveis em C precisamos primeiro identificar o tipo dessa
variável, ou seja, se esse dado será apenas um caractere ou um número INTEIRO ou
ainda um número REAL. Vejamos como definir o tipo de variáveis:

• char define um único caractere (1, a, x, s, F, !, #, etc);

• int define um número inteiro (1, -5, -250, 1000, etc);

3
 4 Capítulo 2: TRABALHANDO COM DADOS

• float define um número real não inteiro (3.14, 0.13445, 100.0,47564.000, etc);
• double define um número real não inteiro com maior capacidade de casas
decimais (3.1415, 85438.48475634637372764, etc).
OBSERVAÇÃO: Em C, a vírgula é representada por um ponto (.). A diferença entre
float e double é que o primeiro tem capacidade de 4 bits enquanto o último tem 8 bits,
ou seja, maior capacidade de armazenamento.

2.2 Scanf
A função scanf é usada para a leitura de dados inseridos a partir do teclado. Para
que isso seja possível é necessário o uso de um caractere especial de atribuição para ser
usado dentro da função scanf. Os caracteres são:
• %d caractere para escrita de números inteiros;
• %f caractere para escrita de números reais;
• %c caractere par escrita de strings;
• %e e %E caractere para escrita de notação científica.
Para que a atribuição dos dados sejam inseridos nas variáveis a partir da scanf é
preciso informar com o caractere & (e comercial), seguido da variável a ser atribuida.
Analisemos o seguinte programa:
1 # include < stdio .h >
2 main ()
3 {
4 int n1 , n2 ;
5 printf ( " Digite o primeiro numero : " ) ;
6 scanf ( " % d " , & n1 ) ;
7 printf ( " Digite o segundo numero : " ) ;
8 scanf ( " % d " , & n2 ) ;
9 printf ( " O resultado e % d + % d = % d \ n " , n1 , n2 , n1 + n2 ) ;
10 }
Declaramos duas variáveis n1 e n2 do tipo int (inteiro). Depois, uma frase pede
para o usuário inserir um número. Após isso, entra a função scanf que captura o
número digitado no teclado e escreve no caractere %d indicando que é um número
inteiro. Em seguida a função scanf insere o número digitado na variável n1 através do
caractere &. Depois entra outra frase pedindo ao usuário outro número e após isso,
uma outra scanf captura o valor digitado, mas desta vez, inserindo o valor na variável
n2. Por ultimo, uma função printf escreve os valores digitados entre aspas duplas com
os caracteres %d e pula uma linha com \n. Após as aspas, inserimos os respectivos
valores a serem substituídos pelos caracteres %d e o terceiro %d ainda dentro das aspas
duplas é subtituido pelo terceiro número indicado pela soma das duas variáveis n1 +
n2.
Analisemos agora um programa que calcula a área e o perímetro de uma
circunferência:
 2.3: If-else e if-else encadeados 5

1 # include < stdio .h >

2 main ()
3 {
4 float raio , perimetro ;
5 double Pi = 3 ,141592654 , area ;
6 printf ( " Introduza o raio da circunferencia : " ) ;
7 scanf ( " % f " , & raio ) ;
8 area = Pi * raio * raio ;
9 perimetro = 2* Pi * raio ;
10 printf ( " Area = % f \ n \ n " , area ) ;
11 printf ( " Perimetro = % f \ n \ n " , perimetro ) ;
12 }
Agora neste programa, definimos duas variáveis raio e perimetro do tipo real
e outras duas variáveis Pi e area do tipo real mas com maior capacidade de casas
decimais e também definimos o valor de Pi que deixa de ser variável para se tornar
constante. Depois da printf e scanf, definimos a forma das variáveis area e perimetro
como sendo a fórmula da área e do perímetro de uma circunferência, observando que
em C não existe potência, por isso a multiplicação da variável raio duas vezes. Por fim
mais duas printf com os resultados dos cálculos.

2.3 If-else e if-else encadeados

As funções if e else nada mais são do que funções para determinar condições para
a execução de uma ou mais operações dentro de um programa. São funções que
literalmente fazem o que dizem em seus significados em português: if-else = se-então.
São condições que trabalham com verdadeiro e falso utilizando a relação de ordem
e de igual ou diferente como mostrado abaixo:

• > maior que;

• < menor que;

• >= maior ou igual;

• <= menor ou igual;

• == igual;

• != diferente;

Note que o símbolo de = significa atribuição de valor. Para dizer que um valor é IGUAL
a outro devemos usar ==. Resumindo, if diz que se uma condição for verdadeira
aplicará uma instrução, caso contrário, else, executará outra função ou encerrará o
programa. Vejamos o seguinte programa que diz se um número é negativo ou pisitivo:
 6 Capítulo 2: TRABALHANDO COM DADOS

1 # include < stdio .h >

2 main ()
3 {
4 float x ;
5 printf ( " Introduza um numero : " ) ;
6 scanf ( " % f " , & x ) ;
7 if (x >0)
8 printf ( " O numero % f e PISITIVO !!! " , x ) ;
9 else
10 printf ( " O numero % f e NEGATIVO !!! " , x ) ;
11 }
Até a função scanf tudo já é conhecido. Após isso, temos a função if que diz que se a
variável x do tipo real for maior que zero, o programa deverá qualificar o número que
o usuário digitou como PISITIVO, caso contrário, usamos a função else que deverá
qualificar o número digitado como NEGATIVO. Isso se deve porque a linguagem C
não sabe quando um número é negativo ou positivo, apenas reconhece a relação de
ordem dos números, ou seja, a linguagem C sabe que 1 é maior que -1, mas não sabe
que 1 é positivo e que -1 é negativo. Assim devemos “ensinar” quando os números
são positivos ou negativos.
Se analisarmos matematicamente o programa anterior, veremos que ele apresentará
um possível erro caso o usuário digite o número zero. O programa indicará que zero é
negativo ja que o número x deve ser maior que zero, caso contrário, o programa deverá
indicar que x é negativo.
É por causa desses casos que em C, podemos utilizar as funções if-else de forma
encadeada, ou seja, if-else encadeados significa mais de um par de if-else. Assim,
para consertar o programa anterior, utilizaremos if-else encadeados, vejamos:
1 # include < stdio .h >
2 main ()
3 {
4 float x ;
5 printf ( " Introduza um numero : " ) ;
6 scanf ( " % f " , & x ) ;
7 if ( x !=0)
8 if (x >0)
9 printf ( " O numero % f e PISITIVO !!! " , x ) ;
10 else
11 printf ( " O numero % f e NEGATIVO !!! " , x ) ;
12 else
13 printf ( " % f e o numero neutro !!! " , x ) ;
14 }
Agora no primeiro if, indicamos que x deve ser diferente de zero, se sim,
então deverá acontecer outro if que indicamos que x deve ser maior que zero, se
isso for verdade o programa imprimirá POSITIVO, caso contrário (else), imprimirá
NEGATIVO, se essas duas condições forem falsas, ou seja se x não for maior nem
menor que zero, então é claro que x será igual a zero, então a primeira condição do
primeiro if será falsa e o programa executará a instrução do ultimo else que diz que
zero é NEUTRO.
 Capítulo 3

LAÇOS DE REPETIÇÃO E FUNÇÕES

3.1 O comando FOR

O comando for é usado para repetir a execução de uma sequência de comandos
certo número de vezes. Esse comando é usado quando sabemos, a priore, o número de
repetições que devem ser executadas.

Um exemplo bastante elementar para mostrar a estrutura do for é o programa que

mostra os números naturais de 1 a 10 em ordem crescente.
1 # include < stdio .h >
2 int main () {
3 int i ;
4 for ( i =1; i <=10; i ++) {
5 printf ( " % d " ,i ) ;
6 }
7 return 0;
8 }
Podemos programar o somatório dos n primeiros números naturais:
1 # include < stdio .h >
2 int main () {
3 int i , soma =0 , n =100;
4 for ( i =1; i <= n ; i ++) {
5 soma = soma + i ;
6 }
7 printf ( " % d " , soma ) ;
8 return 0;
9 }
Note que no código acima, a variável n, linha 4, controla o número de vezes em que
o comando for será repetido. Já na linha 5 temos a lei de formação do somatório.

3.2 O comando WHILE

Assim como o for, o while é um comando de repetição. A vantagem do while
em relação ao for é que não necessitamos saber quantas repetições serão realizadas.

7
 8 Capítulo 3: LAÇOS DE REPETIÇÃO E FUNÇÕES

Como exemplo implementamos um programa que calcula o MDC entre dois números
naturais.
1 # include < stdio .h >
2
3 int main () {
4 int r =1 , p =60 , n =12 , mdc ;
5 printf ( " O MDC entre % d e % d eh : " ,p , n ) ;
6 while ( r !=0) {
7 r=p%n;
8 if ( p % n ==0) {
9 mdc = n ;
10 } else {
11 p=n;
12 n=r;
13 }
14 }
15 printf ( " % d \ n " , mdc ) ;
16 return 0;
17 }

3.3 Onde colocar as funções

Na Linguagem C, a criação de funções é o mecanismo adequado para codificar
tarefas específicas. Muitas funções já vem com as bibliotecas da linguagem C. A
printf(), scanf(), if(), for(), log(), cos() são alguns exemplos de funções. A função mais
importante é a main(), pois somente o que for escrito dentro dela será executado.
Dependendo do projeto, faz-se necessário criar funções que podem ser chamadas
para dentro da função principal. Para entender como criar, declarar e chamar uma
função, vamos analisar o seguinte programa que calcula o fatorial de um número
natural:
1 # include < stdio .h >
2
3 double fat ( double x ) ;
4
5 int main () { // INICIO DA FUNCAO PRINCIPAL
6 double x ;
7
8 printf ( " \ n \ t informe o numero que voce quer calcular o fatorial :
");
9 scanf ( " % lf " ,& x ) ;
10
11 if (x <=1) {
12 printf ( " \ n \ n \ t o fatorial de %. f eh : 1 \ n \ n " ,x ) ;
13 } else {
14 printf ( " \ n \ n \ t o fatorial de %. f eh : %. f \ n \ n " ,x , fat ( x ) ) ;
15 }
16 return 0;
 3.3: Onde colocar as funções 9

17 } // FIM DA FUNCAO PRINCIPAL

18
19 // // FUNCAO O FATORIAL
20 double fat ( double x ) {
21 double fat ;
22
23 for ( fat =1; x >1; x =x -1) {
24 fat = fat * x ;
25 }
26 return fat ;
27 }
No código acima, a função principal está escrita entre as linhas 5 e 17. Note que a
função responsável pelo cálculo do fatorial está escrita entre as linhas 20 e 27, isto é,
fora da função principal. Para que essa função possa ser visualizada pela função main(),
primeiro devemos declará-la antes da função principal, logo abaixo da biblioteca stdio.h
(linha 3). Apos esses passos, basta chamar a função fat para dentro da função principal
(linha 14).
10 Capítulo 3: LAÇOS DE REPETIÇÃO E FUNÇÕES
 Capítulo 4

ALGUNS ALGORÍTIMOS PARA O

ESTUDO DO CÁLCULO

4.1 Calculo de volume

Vamos dar exemplos de três funções para calcular os volumes da esfera, do cilindro
e do cubo. Aqui iremos mostrar a estrutura e a utilidade da função switch(), que é
própria das bibliotecas da Linguagem C. Além disso, faremos uso das funções if() e
while(), já vistas anteriormente.
Note, que no código abaixo, (linha 2), incluímos uma nova biblioteca, stdlib.h, pois
iremos precisar de funções próprias desta biblioteca. Na linha 3, definimos uma
constante global PI à qual atribuímos o valor 3,141592654, que pode ser usada em
qualquer função do algorítimo. Nas linhas 4,5,6 e 7 foram declaradas as funções que
iremos chamar para dentro da função principal main(). Na linha 8 declaramos uma
variável global (opcao), pois a usaremos em diferentes momentos no programa.
Note que dentro da função principal só há a função menu(), mas isso é o bastante,
pois para dentro dela serão chamadas as demais funções.
1 # include < stdio .h >
2 # include < stdlib .h >
3 # define PI 3.141592654
4 void menu () ;
5 void VolumeEsfera () ;
6 void VolumeCilindro () ;
7 void VolumeCubo () ;
8 int opcao ;
9
10 int main () { // inicio da funcao principal
11
12 menu () ;
13
14 return 0;
15 } // fim da funcao principal
16 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
17 void menu () { // esta funcao gera o menu
18

11
 12 Capítulo 4: ALGUNS ALGORÍTIMOS PARA O ESTUDO DO CÁLCULO

19 printf ( " \ n \ t \ t = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n " ) ;

20 printf ( " \ t \ t = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n " ) ;
21 printf ( " \ t \ t \ t ESCOLHA UMA DAS OPCOES ABAIXO \ n \ n " ) ;
22 printf ( " \ n \ t \ t \ t [1] VOLUME DA ESFERA " ) ;
23 printf ( " \ n \ n \ t \ t \ t \ t [2] VOLUME DO CILINDRO " ) ;
24 printf ( " \ n \ n \ t \ t \ t \ t \ t [3] VOLUME DO CUBO " ) ;
25 printf ( " \ n \ t \ t = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n " ) ;
26 printf ( " \ t \ t = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n " ) ;
27
28 printf ( " \ n \ t \ t \ t OPCAO : " ) ; scanf ( " % d " ,& opcao ) ;
29
30 while (( opcao <1) ||( opcao >3) ) {
31 printf ( " \ a OPCAO INVALIDA . DIGITE UM NUMERO ENTRE 1 E 3 \ t " ) ;
32 menu () ; scanf ( " % d " , & opcao ) ;
33 }
34
35 switch ( opcao ) {
36
37 case 1:
38 printf ( " \ n \ t * Voce escolheu calcular o VOLUME DA ESFERA *\ n " ) ;
39 VolumeEsfera () ;
40 break ;
41
42 case 2:
43 printf ( " \ n \ tVoce escolheu calcular o VOLUME DO CILINDRO \ n " ) ;
44 VolumeCilindro () ;
45 break ;
46
47 case 3:
48 printf ( " \ n \ t * Voce escolheu calcular o VOLUME DO CUBO *\ n " ) ;
49 VolumeCubo () ;
50 break ;
51
52 } // fim do switch
53 } // fim da funcao menu ()
54 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
55 void VolumeEsfera () {
56 float r , volume ;
57
58 printf ( " \ n \ t \ t Para o calculo do VOLUME da ESFERA informe o valor
do RAIO " ) ;
59 printf ( " \ n \ n \ t \ t RAIO = " ) ;
60 scanf ( " % f " ,& r ) ;
61
62 volume = (4* PI * r * r * r ) /3;
63
64 printf ( " \ n \ n \ t \ t O VOLUME da esfera de raio % f eh : % f \ n \ n " ,r ,
volume ) ;
65
66 printf ( " \ n \ t (1) CALCULAR NOVAMENTE \ n \ t (2) MENU \ n \ t
 4.1: Calculo de volume 13

67 (3) SAIR \ n \ t \ t \ tOPCAO : " ) ; scanf ( " % d " ,& opcao ) ;

68 if ( opcao ==1) { VolumeEsfera () ;} if ( opcao ==2) { menu () ;}
69 if ( opcao ==3) { exit (1) ;}
70 }
71 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
72 void VolumeCilindro () {
73 float r , h , volume ;
74
75 printf ( " \ n \ t \ t Para o calculo do VOLUME do CILINDRO informe o
valor do RAIO e da ALTURA : " ) ;
76 printf ( " \ n \ n \ t \ t RAIO : " ) ;
77 scanf ( " % f " ,& r ) ;
78
79 printf ( " \ n \ n \ t \ t ALTURA : " ) ;
80 scanf ( " % f " ,& h ) ;
81
82 volume = PI * r * r * h ;
83
84 printf ( " \ n \ n \ t \ t O VOLUME do CILINDRO de raio % f e altura % f eh :
% f \ n \ n " ,r ,h , volume ) ;
85
86 printf ( " \ n \ t (1) CALCULAR NOVAMENTE \ n \ t (2) MENU \ n \ t
87 (3) SAIR \ n \ t \ t \ tOPCAO : " ) ; scanf ( " % d " ,& opcao ) ;
88 if ( opcao ==1) { VolumeCilindro () ;} if ( opcao ==2) { menu () ;}
89 if ( opcao ==3) { exit (1) ;}
90 }
91 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
92 void VolumeCubo () {
93 float l , volume ;
94
95 printf ( " \ n \ t \ t Para o calculo do VOLUME do CUBO informe o valor
do LADO : " ) ;
96 scanf ( " % f " ,& l ) ;
97
98 volume = l * l * l ;
99
100 printf ( " \ n \ n \ t \ t O VOLUME do CUBO de LADO % f eh : % f
101 \ n \ n " ,l , volume ) ;
102
103 printf ( " \ n \ t (1) CALCULAR NOVAMENTE \ n \ t (2) MENU \ n \ t
104 (3) SAIR \ n \ t \ t \ tOPCAO : " ) ; scanf ( " % d " ,& opcao ) ;
105 if ( opcao ==1) { VolumeCubo () ;} if ( opcao ==2) { menu () ;}
106 if ( opcao ==3) { exit (1) ;}
107 }
 14 Capítulo 4: ALGUNS ALGORÍTIMOS PARA O ESTUDO DO CÁLCULO

4.2 Cálculo de uma área sob uma curva

Aqui faremos uso da biblioteca math.h, da função for() e de uma função que será
chamada para dentro da função main, onde iremos informar e intervalo e o número
de partições que iremos dividi-lo para obtermos uma boa aproximação da área sob a
curva limitada pelo referido intervalo.
1 # include < stdio .h >
2 # include < stdlib .h >
3 # include < math .h >
4
5 float f ( float x ) ;
6
7 int main () {
8 float inicial , final , deltaX , x0 , xi =0 , soma =0;
9 int n , i ;
10
11 printf ( " \ n \ n \ t Digite o valor INICIAL do intervalo : " ) ;
12 scanf ( " % f " ,& inicial ) ;
13
14 printf ( " \ n \ n \ t Digite o valor FINAL do intervalo : " ) ;
15 scanf ( " % f " ,& final ) ;
16
17 printf ( " \ n \ n \ t Digite o numero de particoes que sera dividido o
intervalo
18 (%.2 f ,%.2 f ) : " , inicial , final ) ;
19 scanf ( " % d " , & n ) ;
20
21 deltaX =(( final - inicial ) / n ) ;
22 x0 = inicial ;
23
24 for ( i =0; i < n ; i ++) {
25 xi = x0 +( i * deltaX ) ;
26 soma = soma + f ( xi ) * deltaX ;
27 }
28 if ( soma <0)
29 soma = soma *( -1) ; // ESTE COMANDO GARANTE QUE O RESULTADO DA
INTEGRAL SEJA SEMPRE POSITIVO
30
31 printf ( " \ n \ t O valor aproximado da integral eh : % f \ n " , soma ) ;
32
33 return 0;
34 }
35
36 float f ( float x ) { // // funcao a ser chamada
37 float s ;
38
39 s = pow (x ,3) ;
40 return ( s ) ;
41 }
 4.3: Aproximação de raízes reais pelo método da Bisseção 15

4.3 Aproximação de raízes reais pelo método da Bisseção

O Método da Bisseção é usado no Cálculo numérico para encontrar aproximações
de raízes reais de funções polinomiais e transcendentes. Esse método é sempre
convergente. Eis uma implementação do Método da Bisseção em Linguagem C:

1 # include < stdio .h >

2 # include < stdlib .h >
3 # include < math .h >
4
5 float f1 ( float x ) {
6 return x * x + x ; }
7
8 void MetodoBisseccao () ; // esta funcao realiza os calculos do metodo
da bisseccao
9 int main () { // Inicio da funcao principal
10
11 MetodoBisseccao () ;
12
13 return 0;
14 } // Fim da funcao principal
15
16 void MetodoBisseccao () {
17 int n ;
18 do { // para repetir a funcao
19
20 double x , xr ,a ,b , M , epsilon , k =1;
21
22 printf ( " \ n \ n \ t Digite o valor de epsilon : " ) ;
23 scanf ( " % lf " ,& epsilon ) ;
24
25 printf ( " \ n \ t Digite os extremos do intervalo [a , b ] que contem uma
raiz : " ) ;
26
27 printf ( " \ n a : " ) ;
28 scanf ( " % lf " ,& a ) ;
29
30 printf ( " \ n b : " ) ;
31 scanf ( " % lf " ,& b ) ;
32
33 // PARA A TABELA
34 printf ( " \ niteracao x f1 ( x ) \ t |b - a |\ n " ) ;
35
36 if ( f1 ( a ) * f1 ( b ) >0) {
37 printf ( " \ n \ t O INTERVALO DADO NAO SATISFAZ AO TEOREMA \ n \ n \ n " ) ;
system ( " pause " ) ; exit (1) ;
38 }
39 else { // primeiro ELSE
40 if ( fabs (b - a ) < epsilon ) { // segundo IF
41 xr =( a + b ) /2;
 16 Capítulo 4: ALGUNS ALGORÍTIMOS PARA O ESTUDO DO CÁLCULO

42 printf ( " \ n \ n \ tA raiz aproximada pelo metodo da bisseccao eh : % lf "

, xr ) ;
43 k =1;
44 } // fim do segundo IF
45 else { // segundo ELSE
46
47 M = f1 ( a ) ;
48 do { // inicio do segundo do () para repeticao
49 x =( a + b ) /2;
50
51 // VALORES PARA A TABELA
52 printf ( " \ n %. lf \ t \ t %.10 lf \ t %.5 lf \ t %.10 lf " ,k ,x , f1 ( x ) , fabs (a
- b ) /2) ;
53
54 k = k +1;
55
56 if ( M * f1 ( x ) >0) { // terceiro IF
57 a = x ;
58 M = f1 ( a ) ;
59 } // fim do terceiro IF
60 else {
61 b = x ;
62 }
63 } // fim do segundo DO
64
65 while ( fabs (b - a ) >= epsilon ) ; // FIM DO WHILE
66 } // fim do segundo ELSE
67 } // fim do primeiro ELSE
68
69 printf ( " \ n \ n \ nA RAIZ APROXIMADA PELO METODO DA BISSECCAO EH : %.10
lf \ n \ n \ n " ,( a + b ) /2) ;
70
71 printf ( " (1) CALCULAR NOVAMENTE \ n (2) SAIR \ t \ t " ) ;
72 scanf ( " % d " ,& n ) ;
73 } while ( n ==1) ;
74 if ( n !=1) {
75 exit (1) ;
76 }
77 } // // fim da funcao que realiza os calculos do metodo da bisseccao
Referências Bibliográficas

[1] CELES FILHO, Waldemar. Introdução a estruturas de dados: com técnicas de

programação em C. [7 a Reimpr.], Rio de Janeiro: Elsevier, 2004.

[2] DAMAS, Luís. Linguagem C. [Reimpr.], Rio de Janeiro: LTC, 2012.

[3] RUGGIERO, Marcia Aparecida Gomes. Cálculo Numérico: Aspectos teóricos e

computacionais. 2.ed, São Paulo: Makron Books, 1996.

[4] SPERANDIO, Décio. Cálculo Numérico: características matemáticas e computacionais

dos métodos numéricos. São Paulo: Pearson, 2003.

17