Instituto Federal de Educação, Ciência e Tecnologia de São Paulo - IFSP Campus de Caraguatatuba Licenciatura em Matemática 10 Semestre de 2013 Cálculo Numérico – CN Prof. Lineu Mialaret Aula 14: Análise de Algoritmos (2)

Análise de Algoritmos Operações Primitivas (1) Caso deseje-se analisar um algoritmo sem efetuar experimentos, deve-se seguir os seguintes passos: 1. Codifique o algoritmo em alguma linguagem de programação de alto nível (como a linguagem Java); 2. Compile o programa em alguma linguagem executável de baixo nível (como o bytecode da Java Virtual Machine - JVM ); 3. Determine para cada instrução i da linguagem de baixo nível, o tempo ti necessário para executar a instrução; 4. Determine para cada instrução i da linguagem de baixo nível, o número de vezes ni que a instrução i é executada quando o algoritmo é executado; e 5. Some os produtos ni.ti para todas as instruções. Isto fornece o tempo de execução do algoritmo. Esta abordagem pode dar uma estimativa mais precisa do tempo de execução do algoritmo, mas é complicada de ser realizada.

Análise de Algoritmos Operações Primitivas (2) Essa abordagem anterior requer um conhecimento detalhado da linguagem de baixo nível gerada pela compilação de um programa e o ambiente no qual ele é executado. Assim, ao invés desse tipo de abordagem, pode-se efetuar a análise diretamente sobre o código fonte ou sobre o pseudocódigo, usando-se o conceito de operações primitivas. Operações Primitivas são as computações de alto nível que são independentes da linguagem de programação e podem ser identificadas no pseudocódigo.

Análise de Algoritmos Operações Primitivas (3) Pode-se definir um conjunto de operações primitivas de alto nível que são independentes da linguagem de programação utilizada, como por exemplo: Atribuir um valor a uma variável; Chamar uma rotina; Efetuar uma operação aritmética (exemplo: somar 2 inteiros); Comparar dois números; Indexar um array; e Retornar de uma função. Desta forma, inspecionando-se o pseudocódigo, pode-se contar o número de operações primitivas executadas por um algoritmo.

Análise de Algoritmos Operações Primitivas (4) De forma mais específica, uma operação primitiva corresponde a uma instrução de baixo nível com um tempo de execução constante, mas que depende do ambiente de software e hardware. Em vez de tentar determinar o tempo de execução específico de cada operação primitiva, simplesmente conta-se quantas operações primitivas serão executadas e usa-se este número t como uma estimativa de alto nível do tempo de execução do algoritmo. Essa contagem de operações está relacionada com o tempo de execução em um hardware e software específicos, pois cada operação corresponde a uma instrução realizada em tempo constante e existe um número fixo de operações primitivas.

Análise de Algoritmos Operações Primitivas (5) Nesta abordagem, assume-se implicitamente que os tempos de execução de operações primitivas diferentes serão similares. Assim, o número t de operações primitivas que um algoritmo realiza será proporcional ao tempo de execução daquele algoritmo.

Análise de Algoritmos Operações Primitivas (6) - Exemplo Exemplo de Pseudo Código (Algoritmo arrayMax): Algoritmo arrayMax(A, n): Entrada: um array contendo n inteiros Saída: o máximo elemento em A currentMax  A[0] for i  1 to n-1 do if currentMax < A[i] then currentMax  A[i] return currentMax

Análise de Algoritmos Operações Primitivas (7) – Exemplo - Análise Análise do Algoritmo arrayMax: Inicializar a variável currentMax para A[0] corresponde a duas operações primitivas (indexar um array e atribuir um valor para uma variável) e é executado somente uma vez no começo do algoritmo. Isto é, essa inicialização contribui com duas unidades para a conta do número de operações do algoritmo; No começo do loop for, o contador i é inicializado em 1. Esta ação corresponde a executar uma operação primitiva (atribuir um valor para uma variável); Antes de entrar no corpo do loop for, a condição i < n é verificada. Esta ação corresponde a executar uma ação primitiva (comparar dois números). Uma vez que o contador i começa com 1 e é incrementado por 1 no final de cada iteração do loop, a comparação i < n é realizada n vezes. Assim, ela contribui com n unidades para a conta.

Análise de Algoritmos Operações Primitivas (8) – Exemplo - Análise Análise do Algoritmo arrayMax: O corpo do loop for é executado n - 1 vezes (para valores 1,2,3... n - 1 do contador). Em cada iteração, A[i] é comparado com currentMax (duas operações primitivas, indexação e comparação), A[currentMax] é possivelmente atribuída a currentMax (duas operações primitivas, indexação e atribuição) e o contador i é incrementado (duas operações primitivas, somatório e atribuição). Por esta razão, em cada iteração do loop, ou quatro ou seis operações primitivas são realizadas, dependendo se A[i]  currentMax ou A[i] > currentMax. Portanto, o corpo do loop contribui entre 4(n-1) e 6(n-1) unidades para a conta. Retornar o valor da variável currentMax corresponde a uma operação primitiva e é executado uma só vez.

Análise de Algoritmos Operações Primitivas (9) – Exemplo - Análise Resumindo: o numero de operações primitivas t(n) executadas pelo algoritmo arrayMax é no mínimo 2 + 1 + n + 4(n - 1) + 1 = 5n e no máximo 2 + 1 + n + 6(n - 1) + 1 = 7n - 2 o melhor caso (t(n) = 5n) ocorre quando A[0] é o elemento máximo, de maneira que a variável currentMax nunca sofre atribuição. o pior caso (t(n) = 7n - 2) ocorre quando os elementos estão em ordem crescente, de modo que a variável currentMax sempre sofre atribuição em cada iteração do loop for.

Análise de Algoritmos Operações Primitivas (9) – Exemplo - Análise

Análise de Algoritmos Pior Caso X Melhor Caso (1)

Análise de Algoritmos Pior Caso X Melhor Caso (2)

Análise de Algoritmos Avaliação da Abordagem de Operações Primitivas (1) Teve-se que entrar num elevado grau de detalhe para analisar o tempo de execução de um algoritmo simples como arrayMax. Essa análise levanta uma série de questões: Esse nível de detalhe é mesmo necessário? Qual a importância de se determinar exatamente o número de operações primitivas realizadas por um algoritmo? Qual o grau de cuidado que se deve ter ao definir o conjunto de operações primitivas realizadas por um algoritmo? Por exemplo, quantas operações primitivas são usadas na atribuição y = a*x + b ? Na atribuição anterior pode se argumentar que são duas operações aritméticas e uma atribuição, mas pode-se não estar considerando atribuições de resultados intermediários a variáveis temporárias, por exemplo.

Análise de Algoritmos Avaliação da Abordagem de Operações Primitivas (2) Em geral, cada passo numa descrição em pseudocódigo e cada comando numa linguagem de alto nível correspondem a um pequeno número de operações primitivas que não dependem do tamanho da entrada. Dessa forma, pode-se realizar uma análise simplificada que estima o número de operações realizadas, exceto por um fator constante, simplesmente contando os passos do pseudocódigo ou os comandos da linguagem de alto nível usada. No caso do algoritmo arrayMax, essa análise simplificada indica que entre 5n e 7n – 2 passos são executados para uma entrada de tamanho n.

Análise de Algoritmos Avaliação da Abordagem de Operações Primitivas (3) Na análise de algoritmos, é importante concentrar-se na taxa de crescimento do tempo de execução como uma função do tamanho da entrada n, obtendo-se um quadro geral do comportamento, em vez de se concentrar em detalhes gerais. Freqüentemente, basta saber apenas que o tempo de execução de um algoritmo do tipo arrayMax já apresentado cresce proporcionalmente a n, com o verdadeiro tempo de execução sendo n vezes algum pequeno fator constante que depende do ambiente de hardware e software e que vai varia numa faixa de valores, dependendo da entrada específica. A abordagem empregada para analisar estruturas de dados e algoritmos utilizará uma notação matemática para funções quer têm a vantagem de desconsiderar fatores constantes.

Análise de Algoritmos Avaliação da Abordagem de Operações Primitivas (4) Dessa forma, será caracterizado o tempo de execução, e outras medidas de aferição da qualidade, como por exemplo, a quantidade de memória usada, em algoritmos e estruturas de dados, usando-se funções que mapeiam números inteiros em números reais, de uma forma que concentra a atenção no comportamento geral do tempo de execução e da memória exigida, por exemplo, sem um elevado grau de detalhe.

Análise de Algoritmos Notação Assintótica (1) Meta: simplificar a análise dispensando as informações desnecessárias como “arredondamento”: 1.000.001  1.000.000 3n2  n2 A notação “Big-Oh” Dadas as funções f(n) e g(n), diz-se que f(n) é O(g(n)) se e somente se f(n) < c g(n) para n > n0 c e n0 são constantes, f(n) e g(n) são funções sobre inteiros não negativos Outras notações: W(f(n)): Big Omega - limite inferior Q(f(n)): Big Theta - igualdade

Análise de Algoritmos Notação Assintótica (2)

Análise de Algoritmos Notação Assintótica (3)

Análise de Algoritmos Notação Assintótica (4)

Análise de Algoritmos Notação Assintótica (5) Nota: embora 7n - 3 seja O(n5), é esperado que tal aproximação seja de tão baixa ordem quanto possível. Regra Simples: despreze os termos de mais baixa ordem e os fatores constantes. 7n - 3 é O(n) 8n2logn + 5n2 + n é O(n2logn) Classes especiais de algoritmos: logarítmico: O(log n) linear : O(n) quadrático: O(n2) polinomial: O(nk), k > 1 exponencial: O(an), n > 1

Análise de Algoritmos Notação Assintótica (6) Usa-se a notação O para expressar o número de operações primitivas executadas como uma função do tamanho da entrada. Por exemplo, pode-se dizer que o algoritmo arrayMax roda em O(n) unidades de tempo. Comparando o tempo de execução assintótico: um algoritmo que roda em O(n) é melhor do que um que roda em O(n2) semelhantemente, O(logn) é melhor O(n) hierarquia das funções: logn << n << nlogn << n2 << n3 << 2n << n! Cuidado! Tome cuidado ao encontrar fatores constantes muito grandes. Um algoritmo que roda no tempo 1.000.000n é ainda O(n) mas pode ser menos eficiente em seu conjunto de dados do que um algoritmo rodando no tempo 2n2, que é O(n2)

Análise de Algoritmos Notação Assintótica (7) Tipos de função f(n) input n 1 logn n nlogn n2 n3 2n 2 10 3,32 33 100 1000 1024 6,64 664 10000 1000000 1,268 X 1030 9,97 9970 109 1,072 X 10301 Comparação de grandeza para várias funções.

Medidas de Eficiência, assumindo velocidade de 1 microssegundo Análise de Algoritmos Notação Assintótica (8) EFICIÊNCIA Notação ´O´ INTERAÇÕES TEMPO ESTIMADO Logarítmica O(log(n)) 14 microssegundos Linear O(n) 10000 0,1 segundo Log. Linear O(n(log(n)) 14000 2 segundos Quadrática O(n2) 100002 15-20 minutos Polinomial O(nk) 10000k Horas Exponencial O(en) 210000 Intratável Fatorial O(n!) 10000! Medidas de Eficiência, assumindo velocidade de 1 microssegundo e 10 instruções num loop.

Gráfico Comparativo das Grandezas da Notação ´O´. Análise de Algoritmos Notação Assintótica (9) n log n n2 n3 n O(n) log n Gráfico Comparativo das Grandezas da Notação ´O´.