DCC 001 Programação de Computadores

Apresentação em tema: "DCC 001 Programação de Computadores"— Transcrição da apresentação:

1 DCC 001 Programação de Computadores
Aula Expositiva Funções Sintaxe Funções, Arquivos Fonte e o Scilab Funções, Matrizes, Loops e Indução Soma dos Elementos de um Vetor Menor Valor Presente em um Vetor Recursividade Funções e Desenvolvimento Top-down DCC 001 Programação de Computadores 2° Semestre de 2011 Prof. Osvaldo Carvalho

2 Funções DCC

3 Cálculo do número de combinações
Faça um programa que Leia 2 inteiros n e k Calcule e imprima o número de combinações de n por k, dado pela fórmula DCC

4 Fatorial – Reaproveitamento do Código
Pare reaproveitarmos o código devemos adaptá-lo para o cálculo dos fatoriais de n, n-k e k fat = 1; for i = 1:n fat = fat*i; end DCC

5 Combinações n/k – Sem Funções
n=input("n="); k=input("k="); fat_n = 1; // Cálculo do fatorial de n for i = 2:n fat_n = fat_n * i; end fat_n_k = 1; // Cálculo do fatorial de n-k for i = 2:(n-k) fat_n_k = fat_n_k * i; fat_k = 1; // Cálculo do fatorial de k for i = 2:k fat_k = fat_k * i; nComb = fat_n/(fat_n_k * fat_k) DCC

6 Combinações n/k – Com Funções
Programa Principal n=input("n="); k=input("k="); nComb = fatorial(n)/(fatorial(n-k) * fatorial(k)) Chamadas da função Função function fat = fatorial(n) fat = 1; for i = 1:n fat = fat*i; end endfunction Código da função DCC

7 Arquivos com Código de Funções
Uma função é normalmente escrita em um arquivo separado do arquivo com o programa principal O arquivo com a função deve ter o mesmo nome da função a extensão .sci (um programa tem a extensão .sce) Para “incorporar” uma função ao Scilab, use exec(<nome do arquivo com a função>) no programa cliente DCC

8 Arquivo com uma Função DCC

9 O comando exec exec("fatorial.sci") n=input("n="); k=input("k=");
nComb = fatorial(n)/... fatorial(n-k)*fatorial(k) O Scilab só toma conhecimento da existência de uma função através do comando exec O arquivo com a função deve estar no mesmo diretório do programa que chama a função DCC

10 Ganhos com o uso de Funções
O uso de parâmetros permite um melhor reaproveitamento do código Programação mais clara Possível divisão do trabalho: um programador faz o programa principal, outro faz a função DCC

11 Parâmetros Formais e Reais
DCC

12 function fat = fatorial(n) fat = 1; for i = 1:n fat = fat*i; end
Parâmetros Formais function fat = fatorial(n) fat = 1; for i = 1:n fat = fat*i; end endfunction Parâmetro de Entrada É fornecido na chamada da função Parâmetro de Saída É calculado pela função DCC

13 Funções com mais de um parâmetro de saída
function [r1, r2] = eq2g(a,b,c) delta = b^2 - 4*a*c r1 = (-b + sqrt(delta))/(2*a) r2 = (-b - sqrt(delta))/(2*a) endfunction Chamada da função eq2g [raiz1,raiz2] = eq2g(x,y,z) DCC

14 Chamada de Função Os parâmetros reais (que podem ser expressões) são copiados sobre os parâmetros formais O controle é transferido para a função, que trabalha sobre os parâmetros formais Parâmetros formais somente ganham existência como variáveis durante a execução da função DCC

15 Execução de Função Alterações feitas pela função sobre parâmetros formais não afetam os parâmetros reais de entrada Variáveis utilizadas pela função não têm nada a ver com variáveis de mesmo nome existentes no programa que chama a função; Estas variáveis locais ganham existência somente durante a execução da função DCC

16 Retorno de Função Os parâmetros reais de saída (normalmente termos em uma expressão, como em y = 1 + sin(x) ) recebem os valores dos parâmetros formais de saída calculados pela função O controle é devolvido para o ponto de chamada DCC

17 Encadeamento de Chamadas
function nComb = Combinacoes(n,k) nComb = fatorial(n)/... (fatorial(n-k) * fatorial(k)) endfunction Nosso programa transformado em função Programa principal exec("Combinacoes.sci") exec("fatorial.sci") n=input("n="); k=input("k="); printf("nComb(%d,%d) = %d",n,k,Combinacoes(n,k)) DCC

18 Encadeamento de Chamadas
Programa Principal Função nComb Função Fatorial DCC

19 Funções como Parâmetros de uma Função
Parâmetros de entrada e de saída de uma função podem ser qualquer coisa: números, strings, booleanos, matrizes de qualquer tipo, e até mesmo outra função! function PlotaPontos(f,x) y = f(x); plot2d(x,y); endfunction DCC

20 Funções como Parâmetros de uma Função
function y = MinhaFunc(x) y = exp(- x .^ 2); endfunction // Testador PlotaPontos exec("PlotaPontos.sci"); exec("MinhaFunc.sci"); x = 0:0.1:2*%pi; PlotaPontos(sin,x); PlotaPontos(MinhaFunc,x); DCC

21 Soma dos Elementos de um Vetor
DCC

22 Função Soma dos elementos de um vetor
Queremos programar uma função para calcular a soma de todos os elementos de um vetor (a função sum do Scilab faz isso) Primeiro passo: determinação das entradas e saídas da função Entrada: um vetor Saída: um número igual à soma dos elementos do vetor DCC

23 Cabeçalho de uma Função
function s = Soma(A) // Calcula a soma dos elementos de A endfunction Avanços? Sim: Demos um nome significativo para a função; Determinamos e demos nomes para seus parâmetros formais de entrada e de saída A isto se dá o nome de cabeçalho da função DCC

24 Vamos programar um teste de unidade para a função Soma
Construir um programa que testa o funcionamento de uma função antes mesmo de construir a função é uma prática muito recomendável Vamos programar um teste de unidade para a função Soma DCC

25 O Programa Soma_Teste.sce - 1
exec("Soma.sci"); // Programa que testa a função Soma a = int(10*rand(1,4)) sa = Soma(a) b = int(10*rand(1,6)) sb = Soma(b) c = int(10*rand(1,9)) sc = Soma(c) DCC

26 O Programa Soma_Teste.sce - 2
O programa gera 3 pequenos vetores de inteiros entre 0 e 10 Repare que o “;” foi omitido para que o Scilab imprima automaticamente os vetores gerados A função Soma é chamada três vezes com três parâmetros reais de entrada: a, b e c três parâmetros reais de saída: sa, sb e sc A cada chamada os parâmetros formais s e A recebem os valores dos parâmetros reais DCC

27 Algoritmo para a Soma dos Elementos de um Vetor
Raciocínio indutivo Hipótese de indução: Uma variável s contém a soma dos k primeiros elementos de A, ou seja, s = A(1) A(k) Passo: Fazendo s = s + A(k+1) , teremos s = A(1) A(k) + A(k+1) Repetindo este passo até o último elemento de A, teremos em s a soma de todos os elementos Início k = 0 e s = 0 (o conjunto {A(1),...,A(0)} é vazio) DCC

28 Um Passo do Algoritmo DCC

29 Tamanho de Parâmetros Formais
Problema: qual é o tamanho do parâmetro formal A, se a função Soma pode ser chamada com parâmetros reais de diversos tamanhos? Soluções: a função length(A) retorna o número de elementos em A a função size(A) retorna o número de linhas e de colunas de A DCC

30 A função Soma function s = Soma(A); // Calcula a soma dos
// elementos do vetor A s = 0; for k = 1:length(A) s = s + A(k); end endfunction DCC

31 Saída do Soma_Teste.sce
-->sa = Soma(a) sa = 20. b = -->sb = Soma(b) sb = c = -->sc = Soma(c) sc = 39. DCC

32 Menor valor presente em um Vetor
DCC

33 Menor valor presente em um vetor
Queremos programar uma função que encontre o menor valor presente em um vetor (a função min do Scilab faz isso) Etapas: Construir o cabeçalho da função Construir um programa que teste a função Desenvolver a função DCC

34 Cabeçalho da Função Minimo.sci
function m = Minimo(A) // Encontra o menor valor // presente no vetor A endfunction Temos: Um nome significativo para a função Um parâmetro formal de entrada, o vetor A Um parâmetro formal de saída, m, que deve receber o menor valor presente em A DCC

35 O Programa Minimo_Teste.sci
// Programa que testa a função Minimo exec("Minimo.sci"); a = int(10*rand(1,4)) ma = Minimo(a) b = int(10*rand(1,6)) mb = Minimo(b) c = int(10*rand(1,9)) mc = Minimo(c) DCC

36 Algoritmo para encontrar o Menor Valor presente em um Vetor
Raciocínio indutivo Hipótese de indução: Uma variável m contém o menor valor dentre os k primeiros elementos de A Passo: if A(k+1) < m then m = A(k+1) Repetindo este passo até o último elemento de A, teremos em m o menor dentre todos os elementos Início k = 1 e m = A(1) DCC

37 Dois passos do algoritmo Mínimo
DCC

38 A função Minimo.sci function m = Minimo(A) // Encontra o menor valor
// presente no vetor A m = A(1); for k = 2:length(A) if m > A(k) m = A(k); end endfunction DCC

39 Funções Recursivas DCC

40 Recursividade Uma função pode chamar outra função
que pode chamar outra função ... E uma função também pode chamar a si própria! Uma função que chama a si própria é uma função recursiva A formulação recursiva é muitas vezes a forma mais natural para a descrição de um algoritmo DCC

41 Fatorial Recursivo Nós sabemos que: 1! = 1, e que
n! = n*(n-1)! para n > 1 function fat = fatorialR(n) if n > 1 then fat = n*fatorialR(n-1) else fat = 1 end endfunction DCC

42 Raciocínio Recursivo n! = n*(n-1)! para n > 1 1! = 1
Solução de um problema é definida utilizando a solução de um problema menor 1! = 1 Problema suficientemente pequeno para ter solução não dependente de problemas menores DCC

43 Fatorial Recursivo – 2 function fat = FatorialR(n)
// Comente os printf para não imprimir printf("\nIniciando FatorialR(%d)",n); if n > 1 then fat = n * FatorialR(n-1); else fat = 1; end printf("\nRetornando Fatorial(%d) = %d",n,fat) endfunction DCC

44 Fatorial Recursivo – 3 Saída: n = 5 Iniciando FatorialR(5)
Retornando Fatorial(1) = 1 Retornando Fatorial(2) = 2 Retornando Fatorial(3) = 6 Retornando Fatorial(4) = 24 Retornando Fatorial(5) = 120 5! = 120 DCC

45 Pilha de Execução - Chamadas
Prog Fat(5) Fat(4) Fat(3) Fat(2) Fat(1) Fat(2) Fat(3) Fat(3) Fat(4) Fat(4) Fat(4) Fat(5) Fat(5) Fat(5) Fat(5) Prog Prog Prog Prog Prog DCC

46 Pilha de Execução – Retornos
Fat(1 Fat(2) Fat(2) Fat(3) Fat(3) Fat(3) Fat(4) Fat(4) Fat(4) Fat(4) Fat(5) Fat(5) Fat(5) Fat(5) Fat(5) Prog Prog Prog Prog Prog Prog DCC

47 Pilha de Execução Chamadas e Retornos
DCC

48 Mínimo Recursivo - 1 É possível formular o algoritmo de descoberta do menor valor presente em um vetor como uma função recursiva Uma possibilidade: Se length(A) == 1, o menor valor em A é A(1) Se length(A) > 1, o menor valor em A é o menor dentre (o menor valor na metade esquerda de A) e (o menor valor na metade direita de A) DCC

49 A função MinimoRecursivo.sci
function m = MinimoR(x) if length(x) == 1 then m = x(1) else half = int(length(x)/2); minLeft = MinimoR(x(1:half)); minRight = MinimoR(x(half+1:length(x))); if minLeft <= minRight then m = minLeft m = minRight end endfunction DCC

50 Funções e Desenvolvimento Top-Down
DCC

51 Funções e Desenvolvimento top-down
Técnica: chamada da função antes de seu desenvolvimento O programador deve especificar o resultado desejado da função, postergando o trabalho de determinar como obter este resultado DCC

52 Menor primo ≥ n Problema:
Construir um programa que lê uma série de números e, para cada número lido, encontra o menor primo que seja maior ou igual a ele Se, por exemplo, o número lido for 4, o programa deve encontrar o número primo 5; se for 11, o programa deve encontrar o próprio 11. O programa deve terminar quando o número lido for menor ou igual a 1 Sabe-se que o conjunto dos números primos é infinito DCC

53 Menor primo ≥ n Programa principal Cuida da interação com o usuário
O problema de encontrar o menor primo ≥ n é “empurrado” para uma função n = input("n = "); while n >= 2 // Encontra o menor primo >= n // e imprime o resultado printf("O menor primo >= %d é %d",... n,MenorPrimoMaiorOuIgual(n)) // Lê n n = input("n = (use n < 2 se quiser parar):"); end DCC

54 Menor primo ≥ n Função MenorPrimoMaiorOuIgual
Loop de procura por um primo Não interage com o usuário Empurra o problema de saber se um número é primo para outra função function p = MenorPrimoMaiorOuIgual(n) p = n; while ~Primo(p) p = p+1 end endfunction DCC

55 Menor primo ≥ n Função Primo function ePrimo = Primo(n) d = 2;
Testa se um número é primo A saída é booleana: %t se for primo, %f senão Usa a função modulo(n,d) que calcula o resto da divisão de n por d function ePrimo = Primo(n) d = 2; while modulo(n,d) ~= 0 d = d+1; end ePrimo = (d == n); endfunction DCC

56 Conclusões Funções são uma ferramenta muito útil de modularização
Seu uso permite o reaproveitamento de código e o encapsulamento de detalhes Funções recursivas são uma outra forma de se prescrever comportamentos repetitivos e, algumas vezes (como veremos), a forma mais natural de se expressar um algoritmo O uso de funções permite o desenvolvimento gradual de programas por refinamentos sucessivos DCC