1

Programas, mquinas, computaes1

No mercado existem vrias tipos (arquiteturas) de computadores, bem como um numero razovel de linguagens de programao. Assim, os conceitos desse tpico no podem ser expressos em termos de um computador real ou uma linguagem de programao existente. O programa pode ser visto como um conjunto de operaes e testes sendo executados de acordo com uma determinada estrutura de controle. J uma mquina algo capaz de interpretar cada comando existente de acordo com os dados fornecidos. Uma mquina pode interpretar um programa desde que cada rotina ou teste do programa possa ser interpretada pela mquina. Uma computao simplesmente o histrico do funcionamento da mquina para um determinado programa, considerando um determinado valor inicial. Uma computao pode ser finita (a mquina verifica que no existem mais instrues a executar e para) ou infinita (a mquina no consegue parar aps iniciar).

1. Programas
Redefinio: Um programa um conjunto estruturado de instrues que capacitam uma mquina a aplicar sucessivamente certas operaes bsicas e testes sobre os dados de entrada fornecidos, com o objetivo de produzir uma sada desejvel. Um programa deve mostrar como se deve compor as diversas operaes e testes, ou seja deve possuir uma determinada estrutura de controle. Duas ou mais operaes ou testes podem ser compostos da seguinte forma: Composio sequencial: A operao subseqente s pode ser realizada aps o encerramento da operao ou teste anterior. Composio no-determinista: Uma das operaes ou testes da composio escolhida para ser executada (tambm denominada de escolha). Neste caso, se houver uma nica escolha entre as possveis que consiga solucionar o problema proposto, ento diz-se que o programa consegue resolver o problema. Composio concorrente: As operaes ou testes podem ser executados em qualquer ordem, inclusive ao mesmo tempo, portanto no se pode determinar a ordem de execuo das operaes ou testes. Existem vrias formas da estruturao do controle, sendo que as principais so: Estruturao monoltica: Se baseia em desvios condicionais (se .. ento) e incondicionais (v para ..). No possui mecanismos para iterao ou recurso nem subdiviso. Estruturao Iterativa: Se baseia em mecanismos de controles de iteraes de trechos de programas. No permite desvios incondicionais. Estruturao recursiva: Se baseia em mecanismos de estruturao em subrotinas recursivas. Tambm no podem haver desvios incondicionais.

Resumo do livro Teoria da Computao, dos profs Tiaraj Divrio e Paulo Blauth Menezes

2 Para se estudar os programas, no necessrio saber exatamente quais so os testes ou operaes executadas, bastando identific-los por seus respectivos nomes. Por exemplo: Operaes: F, G, H, J, K Testes: T1, T2, T33 Lembrar que um teste uma operao de tipo especial que produz um resultado booleano. Pode haver tambm a operao vazia, que no faz nada, representada por .

1.1. Progama Monoltico

Sua estruturao atravs de desvios (condicionais e incondicionais), no usando mecanismos que permitam melhor estruturao do cdigo, como iterao, subrotinas ou recurso. Portanto, a lgica do programa um bloco nico (monlito). Para se especificar um programa monoltico, um recurso utilizado o de fluxogramas, onde so indicados os pontos de partida e parada do programa, as operaes e os testes executados, conforme indicado:

partida parada
operao

teste

Um exemplo de fluxograma:

Alm do fluxograma, pode-se representar tambm por um texto, utilizando o que se chama instrues rotuladas, onde cada instruo identificada por um rtulo. Um rtulo (ou etiqueta, ou label) uma cadeia finita de caracteres, com dgitos e/ou letras. Uma instruo rotulada pode ser uma operao ou um teste, precedida por seu respectivo rtulo. No caso de operao, deve ser indicado um desvio incondicional para a prxima operao. No caso de teste, o desvio ser condicional, ou seja, depende do resultado do teste. Uma operao pode ser indicada da forma: r1: faa A v para r2 ou, se for operao vazia: r1: faa v para r3 Um teste pode ser indicado da forma: r1: se T v para r2 seno v para r3

3 O fluxograma do exemplo pode ser representado utilizando instrues rotuladas da forma: 1: 2: 3: 4: faa F v para 2 se T1 v para 1 seno v para 3 faa G v para 4 se T2 v para 5 seno v para 1

Notar que a parada indicada por um desvio para a instruo de rtulo 5, que no existe. Utilizando-se o conceito de instrues rotuladas, pode-se definir um programa monoltico, da forma: Um programa monoltico um par ordenado P=(I, r) onde I o conjunto de instrues rotuladas existentes, que finito, e r o rtulo inicial de execuo. Com relao ao conjunto de instrues rotuladas I, tem-se que: 1) No existem 2 instrues com mesmo rtulo 2) Um rtulo que for referenciado por alguma instruo que no for associado a nenhuma instruo (portanto no existe) dito como um rtulo final. A definio de uma estrutura de programao por meio de instrues e rtulos a forma mais bsica de estrutura de controle. Normalmente, linguagens de baixo nvel (assembly) utilizam tal formato na estruturao de seu cdigo.

1.2. Programa Iterativo

A estruturao monoltica do programa faz com que, se ele for de tamanho razovel, seu entendimento e tambm sua manuteno se tornam bem difceis, pois como se pode ter vrios desvios incondicionais no cdigo, pode ocorrer o que conhecido como quebra de lgica. Assim, surgiram os programas com estruturas de controle iterativas. Nesse casso, substitui-se os desvios incondicionais existentes (instruo GO TO ou VA PARA) por estruturas de controle de ciclos ou repeties, obtendose uma melhor estruturao dos desvios . Isto deu origem chamada programao estruturada, sendo que esta abordagem, quando surgiu, inspirou uma nova gerao de linguagens (para a poca), como Pascal, Algol, Ada e outras que no mnimo obrigam ao programador estruturar melhor seu programa. Nesse caso, ao invs de se colocar todo o cdigo em um nico grande programa, cria-se vrios programas menores, que sero combinados ou compostos entre si para se obter o cdigo final. Esta composio entre programas pode ser: Sequencial: composio de dois ou mais programas, resultando num outro programa, onde o resultado obtido a execuo do primeiro programa, depois o segundo, e assim por diante. Condicional: composio de dois programas resultando num terceiro, onde se executa apenas um dos programas, de acordo com o resultado de um teste. Enquanto: composio de um programa dentro do outro, onde o programa interno ser repetido vrias vezes, enquanto o resultado de um teste for verdadeiro. At: semelhante composio enquanto, porm a execuo do programa interno se repetir enquanto o resultado do teste for falso.

4 Um programa iterativo definido indutivamente da seguinte forma: 1 A operao vazia () um programa iterativo. 2 Um identificador de operao constitui um programa iterativo. 3 - Se V e W so programas iterativos, ento a composio sequencial, indicada por: V; W resulta em um programa iterativo que ser a execuo de V e depois a execuo de W. Em fluxograma, tem-se a composio sequencial:

4 Se V e W so programas iterativos e T um teste a ser feito, ento a composio condicional, denotada como: (se T ento V seno W) resulta em um programa iterativo que tem como efeito a execuo de V se T for verdadeiro ou de W se T for falso. Em fluxogramas, a composio condicional fica:

5 Sendo V um programa iterativo e T um teste, ento a composio enquanto, indicada da forma: enquanto T faa (V) produz um programa iterativo que testar T e executar V diversas vezes at T ser falso. Entretanto, sendo T inicialmente falso, V nunca ser executado. Em fluxogramas, tem-se a composio enquanto da forma:

6 Sendo V um programa iterativo e T um teste, ento a composio at, indicada como: at T faa (V) ou faa (V) at T resulta num programa iterativo onde se testa T e V ser executado se T for falso. Em fluxograma, a composio at pode ser representada da forma:

v ou

V
f

5 Conforme visto nas diversas formas de composio, no se utiliza rtulos nas linhas de cdigo. Um exemplo de programa iterativo mais complexo, usando a representao textual, poderia ser: (se T1 ento enquanto T2 faa (at T3 faa (V;W)) seno ) Exerccio: Fazer o fluxograma equivalente. Deve ser notado que traduzir a representao textual de um programa iterativo para fluxograma no apresenta maiores dificuldades, entretanto nem sempre possvel se traduzir um fluxograma para um programa iterativo equivalente. Dentro de uma composio, os diversos programas iterativos podem ser tambm denominados de subprogramas ou subrotinas.

1.3. Programa Recursivo

Esta estrutura de controle encontrada nas linguagens de alto nvel que admitem a definio de subprogramas ou subrotinas recursivas. Supondo-se os identificadores de subrotinas R1, R2, etc..., e uma expresso de subrotinas E, que pode ser: a) b) c) d) e) A operao vazia (); O identificador de uma operao; O identificador de uma subrotina; A composio sequencial de duas subrotinas; A composio condicional de duas subrotinas;

tem-se que um programa recursivo Pr ter a forma: Pr E0 onde R1 def E1, R2 def E2, ..., Rn def En onde E0 = Expresso de subrotinas inicial Ek = Expresso que define a subrotina identificada por R k (k = 1, 2, 3, ..., n) def = definida por Para cada identificador de subrotina existente ou referenciado em alguma expresso, dever haver uma expresso que o defina. Sua computao ser feita pela avaliao da expresso inicial, sendo substitudo cada identificador de subrotina pela expresso que o define, sendo avaliada a expresso correspondente, at que o identificador seja substitudo pela expresso vazia , indicando o fim da recurso. Exemplo de programa recursivo: P R;S onde R def F;(se T ento R seno G;S) S def (se T ento seno F;R) (F e G so subrotinas)

1.4. Consideraes
Nos 3 tipos de programas vistos (monoltico, iterativo, recursivo), os modelos descritos mostram apenas um conjunto de identificadores, mas no especificam exatamente o que cada operao ou teste faz, portanto no possvel descrever a computao obtida corretamente. A definio dos testes e operaes possveis ser feita na definio de mquina.

2. Mquinas
A mquina fornece todas as informaes necessrias para que se possa descrever a computao de um programa. Se nos programas existem os identificadores das operaes e testes, a mquina deve fornecer o significado de cada identificador e cada teste a ser executado. Cada identificador (operao ou teste) significa uma transformao na estrutura da memria da mquina e estar associado a uma funo verdade, e deve ser considerado que: - algumas operaes ou testes podem no ser definidas em uma mquina (operaes vlidas em uma mquina podem no o ser em outras). - a funo verdade associada nica para cada operao ou teste. Alm das operaes e testes, a mquina deve descrever a manipulao em sua memria (armazenamento ou recuperao de informaes).

2.1. Definio formal

Uma mquina M uma 7-upla da forma: M=(V, X, Y, X, Y, F, T) Onde V = conjunto dos valores de memria X = conjunto dos valores de entrada Y = conjunto dos valores de sada X = funo de entrada (X V) (valores de entrada geram valores na memria) Y = funo de sada (V Y) (valores na memria geram valores de sada) F = conjunto de interpretaes de operaes, onde a interpretao de uma operao F pela mquina M uma funo nica IF tal que IF = V V (valores de memria sero transformados em outros valores) T = conjunto de interpretaes de testes, onde a interpretao de um teste T pela mquina M uma funo IT nica de forma que IT = V {verdadeiro/falso} (um teste em um valor de memria retornar verdadeiro ou falso) Observar que as funes associadas mquina so totais, ou seja, nenhum elementos do domnio (entrada) ficar sem ter seu valor de sada da funo. Exemplo: Mquina de dois registradores

7 A mquina exemplificada possui dois registradores como posies de memria, a e b, que podem receber nmeros naturais (), com os valores de entrada sendo armazenados em a (b fica zerado) e sua sada retorna o valor de b, e possui 2 operaes e um teste: - somar 1 em b - subtrair 1 em a (quando a > 0) - testar se a = 0 Como so dois registradores em , o conjunto dos valores possveis ser dado pelo produto cartesiano , ou , sendo os valores de a representados pelo primeiro elemento do par ordenado e os de b pelo segundo elemento. Assim, a especificao desta mquina fica: Dois_reg = (, , , armazena_a, retorna_b, { adiciona_b, subtrai_a}, {a_zero}) Onde: - , , so os conjuntos dos valores de memria, entrada e sada - Armazena_a: funo de entrada tal que n , armazena_a(n) = (n, 0) - Retorna_b: funo de sada tal que (n, m) , retorna_b(n, m) = m - Adiciona_b: interpretado pela funo tal que (n, m) , adiciona_b(n, m) = (n, m+1) - Subtrai_a: interpretado pela funo tal que (n, m) , subtrai_a(n, m) = (n-1, m) se n0; subtrai_a(0, m) = (0, m) - A_zero: interpretado pela funo tal que (n, m) , a_zero(0, m) = verdadeiro; a_zero (n, m) = falso (n > 0)

2.2. Programas para uma mquina

Um programa P ser vlido para a mquina M se cada identificador de operao e de teste em P estiver associado correspondente funo de operao ou de teste em M, embora a mquina M possa ter operaes ou testes que no constem em P. Entretanto, a operao vazia ( ) pode ser interpretada em qualquer mquina. Exemplos: Programas para a mquina de dois registradores 1 Programa monoltico L1 faa armazena_a(4) v para L2 L2 se a_zero ento v para L5 seno v para L3 L3 faa subtrai_a v para L4 L4 faa adiciona_b v para L2 L5 faa retorna_b v para L6 2 Programa iterativo armazena_a(3) at a_zero faa (subtrai_a, adiciona_b) retorna_b

8 3- Programa recursivo rec_b a rec_b a R onde R def (se a_zero ento seno S;R) S def (subtrai_a; adiciona_b)

3. Computaes
Como visto, uma computao o resumo do funcionamento da mquina ao executar um programa, considerando um valor inicial.

3.1. Computao em programas monolticos

Sendo ento a computao o histrico do funcionamento, para programas monolticos lista-se cada rtulo de instruo executada e o correspondente valor de memria, sendo esta listagem na forma de cadeia de pares onde: cada par mostra um estado da mquina ao executar uma instruo, com os correspondentes valores de memria a listagem ir mostra uma sequencia de estados possveis a partir do estado inicial (instruo inicial e valores de memria iniciais). Definio formal: Sendo a mquina M = (V, X, Y, X, Y, F, T) e o programa monoltico P = (I, r) que executa em M, e L = {L0, L1, L2, ..., Ln} o conjunto dos rtulos de P, uma computao do programa monoltico P na mquina M ser uma cadeia de pares em (L V) (que pode ser finita ou infinita): (L0, V0)(L1, V1), (L2, V2), (L3, V3) ..... onde L0 o rtulo inicial do programa e V 0 o estado inicial da memria, sendo que, para cada par (L k, Vk), sendo F um identificador de uma operao, T um identificador de teste e r e r rtulos em L: 1) Se Lk o rtulo de uma operao da forma : Lk: faa F v_para r Ento (Lk+1, Vk+1) = (r, F(Vk)) o par seguinte a (Lk, Vk). 2) Se Lk o rtulo de uma operao da forma : Lk: faa v_para r Ento (Lk+1, Vk+1) = (r, Vk) o par seguinte a (Lk, Vk). 3) Se Lk o rtulo de um teste da forma : Lk: se T ento v_para r seno v_para r Ento (Lk+1, Vk) o par seguinte a (Lk, Vk) e Lk+1 = r se T(Vk) for verdadeiro Lk+1 = r se T(Vk) for falso Observar ento que: A computao ser finita se a cadeia de pares gerada for finita, caso contrrio ser infinita. Um teste ou a operao vazia no modificam os valores da memria. Em uma computao infinita, nenhum rtulo ser final. Exemplos: a) computao finita para o programa monoltico da mquina de 2 registradores: (L1, (0, 0)) // inicio de execuo, registradores vazios (L2, (4, 0)) // executou primeira instruo, a=10

9 (L3, (4, 0)) (L4, (3, 0)) (L2, (3, 1)) (L3, (3, 1)) (L4, (2, 1)) (L2, (2, 2)) (L3, (2, 2)) (L4, (1, 2)) (L2, (1, 3)) (L3, (1, 3)) (L4, (0, 3)) (L2, (0, 4)) (L5, (0, 4)) (L6, (0, 4)) // testou se a = 0, resultado falso (foi para L3) // subtraiu 1 de a // somou 1 a b, foi para L2 // testou se a = 0, resultado falso (foi para L3) // subtraiu 1 de a // somou 1 a b, foi para L2 // testou se a = 0, resultado falso (foi para L3) // subtraiu 1 de a // somou 1 a b, foi para L2 // testou se a = 0, resultado falso (foi para L3) // subtraiu 1 de a // somou 1 a b, foi para L2 // testou se a = 0, verdadeiro, vai para L5 // mostrou o valor 4 e terminou

b) computao infinita para programa monoltico para mquina de 2 registradores: Sendo o programa 1 faa adiciona_b v para 1 Sua computao fica: (1, (0, 0)) // inicio, memria zerada (1, (0, 1)) // somou 1 a b, permanece em 1 (1, (0, 2)) // somou 1 a b, permanece em 1 ................

3.2. Computao em programas recursivos

Tal computao semelhante aos programas monolticos. O histrico ser tambm uma cadeia de pares, sendo cada para a expresso de subrotina a ser executada e o valor atual da memria, sendo que a cadeia reflete os estados possveis a partir do estado inicial. Definio formal: Sendo a mquina M = (V, X, Y, X, Y, F, T) e o programa recursivo P que executa em M, tal que P E 0 onde R1 def E1, R2 def E2, ..., Rn def En, uma computao do programa recursivo P na mquina M ser uma cadeia (finita ou infinita) de pares da forma: (D0, V0) (D1, V1) (D2, V2) .... Onde (D0, V0) tal que D0 = E0; e V0 o valor inicial da memria e para cada par (D k, Vk), sendo F um identificador de operao, T um teste, e C, C1, C2, etc expresses de subrotinas: 1) rotina vazia inicial: Se Dk uma expresso de subrotinas da forma Dk = ;C, ento (C, Vk) par subseqente a (Dk, Vk) na cadeia (no se modifica valores). 2) rotina no inicio da lista: Se Dk uma expresso de subrotinas da forma D k = F;C, ento (C, F(Vk)) par subseqente a (Dk, Vk) na cadeia (valor da memria ser alterado de acordo com a funo associada a F). 3) expresso de subrotinas definida no programa no incio: Se Dk uma expresso de subrotinas da forma Dk = Ri;C, ento (Ei;C, Vk) par subseqente a (Dk, Vk) na cadeia (no se modifica valores). 4) composio sequencial de rotinas: Se Dk uma expresso de subrotinas da forma D k = (C1; C2); C, ento (C1;(C2;C), Vk) par subseqente a (Dk, Vk) na cadeia (no se modifica valores). 5) expresso de teste no inicio da lista: Se Dk uma expresso de subrotinas da forma D k = Ek = (se T ento C1 seno C2); C ento (C1;C, Vk) ser par subseqente a (Dk, Vk), se T(Vk) = verdadeiro;

10 (C2;C, Vk) ser par subseqente a (Dk, Vk), se T(Vk) = falso. (no se modifica valores, rotina no inicio da lista depende do resultado do teste) Exemplo: computao do programa recursivo para a mquina de 2 registradores, considerando 2 como valor inicial em a: rec_b a R onde R def (se a_zero ento seno (S;R)) S def (subtrai_a; adiciona_b)

(R;, (2, 0))

//situao inicial, expresso definida (caso 3), decompor R.

((se a_zero ento seno (S; R)); , (2, 0)) //composio sequencial (caso 4). (se a_zero ento seno (S; R); ) , (2, 0)) //executar teste ((S; R); ) , (2, 0)) (S; (R; ) , (2, 0)) //composio sequencial (caso 4) //expresso definida (caso 3), decompor S

((subtrai_a; adiciona_b); (R; ) , (2, 0)) // composio sequencial (caso 4) (subtrai_a; (adiciona_b; R; ) , (2, 0)) ((adiciona_b; R; ) , (1, 0)) (adiciona_b; (R; ) , (1, 0)) (R;, (1, 1)) //subtrair em a

//composio sequencial (caso 4) //adicionar em b //expresso definida (caso 3), decompor R //executar teste

(se a_zero ento seno (S; R); , (1, 1)) ((S; R); ) , (1, 1)) (S; (R; )) , (1, 1))

//composio sequencial (caso 4) //expresso definida (caso 3), decompor S //composio sequencial (caso 4) //subtrair em a

((subtrai_a; adiciona_b); (R; ) , (1, 1)) (subtrai_a; (adiciona_b; R; ) , (1, 1)) ((adiciona_b; R; ) , (0, 1)) (adiciona_b; (R; ) , (0, 2)) (R;, (0, 2))

//composio sequencial (caso 4) //adicionar em b

//expresso definida (caso 3), decompor R //executar teste

((se a_zero ento seno (S; R)); , (0, 2)) (; ) , (0, 2)) (, (0, 2))

//duas rotinas vazias correspondem a uma s // fim da recurso

3.3. Computao em Programas Iterativos

Seja M uma mquina e P um programa iterativo para a mquina M. Uma computao para o programa P em M uma cadeia de pares, finita ou infinita, do tipo: (I0,V0)(I1,V1)(I2,V2) , onde I0 o programa iterativo inicial

11 V0 o valor inicial da memria. Para cada (Ik,Vk), onde k={0,1,2,.}, F sendo uma operao, T um teste e C, C1, C2 programas iterativos, temos: Caso 1: Ik = F;C Ento: (Ik+1,Vk+1) = (C, F(Vk)) (operao no incio da lista) Caso 2: Ik = C;C1 (composio seqencial) Ento (Ik+1,Vk+1) = (C;C1,Vk) (no so modificados os valores) Caso 3: Ik = (se T ento C seno C1);C2 (Condicional) Ento: se T(Vk) = verdadeiro: (Ik+1,Vk+1) = (C;C2,Vk) = se T (Vk) = falso: (Ik+1,Vk+1) = (C1;C2,Vk) Caso 4: Ik = (enquanto T faa C);C1 Ento se T (Vk) = verdadeiro: (Ik+1,Vk+1) = (C;(enquanto T faa C);C1,Vk) se T (Vk) = falso: (Ik+1,Vk+1) = (C1;enquanto T faa C;C1,Vk) Exemplo: computao do programa da mquina de 2 registradores, considerando 3 o valor inicial de a: Enquanto a_zero = falso faa (subtrai_a, adiciona_b) (enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (3, 0) ((subtrai_a, adiciona_b); (enquanto a_zero = falso faa (subtrai_a, adiciona_b), (3, 0) (subtrai_a; (adiciona_b;(enquanto a_zero = falso faa (subtrai_a, adiciona_b)),( 3, 0) (adiciona_b;(enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (2,0) (enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (2, 1) ((subtrai_a, adiciona_b); (enquanto a_zero = falso faa (subtrai_a, adiciona_b), (2, 1) (subtrai_a; (adiciona_b;(enquanto a_zero = falso faa (subtrai_a, adiciona_b)),( 2,1) (adiciona_b;(enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (1,1) (enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (1, 2) ((subtrai_a, adiciona_b); (enquanto a_zero = falso faa (subtrai_a, adiciona_b), (1,2) (subtrai_a; (adiciona_b;(enquanto a_zero = falso faa (subtrai_a, adiciona_b)),( 1,2) (adiciona_b;(enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (0,2) (enquanto a_zero = falso faa (subtrai_a, adiciona_b)), (0, 3)