[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40. Fluxo de Programa


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.1 Introdução a Fluxo de Programa

Maxima fornece um do para ciclos iterativos, também contruções mais primitivas tais como go.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

40.2 Funções e Variáveis Definidas para Fluxo de Programa

Função: backtrace ()
Função: backtrace (n)

Imprime a pilha de chamadas, que é, a lista de funções que foram chamadas pela função correntemente ativa.

backtrace() imprime toda a pilha de chamadas.

backtrace (n) imprime as n mais recentes chamadas a funções, incluindo a função correntemente ativa.

backtrace pode ser chamada por um script, uma função, ou a partir da linha de comando interativa (não somente em um contexto de depuração).

Exemplos:

Operador especial: do

A declaração do é usada para executar iteração. Devido à sua grande generalidade a declaração do será descrita em duas partes. Primeiro a forma usual será dada que é análoga à forma que é usada em muitas outras linguagens de programação (Fortran, Algol, PL/I, etc.); em segundo lugar os outros recursos serão mencionados.

Existem três variantes do operador especial do que diferem somente por suas condições de encerramento. São elas:

(Alternativamente, o step pode ser dado após a condição de encerramento ou limite.)

valor_inicial, incremento, limite, e corpo podem ser quaisquer expressões. Se o incremento for 1 então "step 1" pode ser omitido.

A execução da declaração do processa-se primeiro atribuindo o valor_inicial para a variável (daqui em diante chamada a variável de controle). Então: (1) Se a variável de controle excede o limite de uma especificação thru, ou se a condição de unless for true, ou se a condição de while for false então o do será encerrado. (2) O corpo é avaliado. (3) O incremento é adicionado à variável de controle. O processo de (1) a (3) é executado repetidamente até que a condição de encerramento seja satisfeita. Pode-se também dar muitas condições de encerramento e nesse caso o do termina quando qualquer delas for satisfeita.

Em geral o teste thru é satisfeito quando a variável de controle for maior que o limite se o incremento for não negativo, ou quando a variável de controle for menor que o limite se o incremento for negativo. O incremento e o limite podem ser expressões não numéricas enquanto essa desigualdade puder ser determinada. Todavia, a menos que o incremento seja sintaticamente negativo (e.g. for um número negativo) na hora em que a declaração do for iniciada, Maxima assume que o incremento e o limite serão positivos quando o do for executado. Se o limite e o incremento não forem positivos, então o do pode não terminar propriamente.

Note que o limite, incremento, e condição de encerramento são avaliados cada vez que ocorre um ciclo. Dessa forma se qualquer desses for responsável por muitos cálculos, e retornar um resultado que não muda durante todas as execuções do corpo, então é mais eficiente escolher uma variável para seu valor prévio para o do e usar essa variável na forma do.

O valor normalmente retornado por uma declaração do é o átomo done. Todavia, a função return pode ser usada dentro do corpo para sair da delcaração do prematuramente e dar a isso qualquer valor desejado. Note todavia que um return dentro de um do que ocorre em um block encerrará somente o do e não o block. Note também que a função go não pode ser usada para sair de dentro de um do dentro de um block que o envolve.

A variável de controle é sempre local para o do e dessa forma qualquer variável pode ser usada sem afetar o valor de uma variável com o mesmo nome fora da declaração do. A variável de controle é liberada após o encerramento da declaração do.

(%i1) for a:-3 thru 26 step 7 do display(a)$
                             a = - 3

                              a = 4

                             a = 11

                             a = 18

                             a = 25
(%i1) s: 0$
(%i2) for i: 1 while i <= 10 do s: s+i;
(%o2)                         done
(%i3) s;
(%o3)                          55

Note que a condição while i <= 10 é equivalente a unless i > 10 e também thru 10.

(%i1) series: 1$
(%i2) term: exp (sin (x))$
(%i3) for p: 1 unless p > 7 do
          (term: diff (term, x)/p, 
           series: series + subst (x=0, term)*x^p)$
(%i4) series;
                  7    6     5    4    2
                 x    x     x    x    x
(%o4)            -- - --- - -- - -- + -- + x + 1
                 90   240   15   8    2

que fornece 8 termos da série de Taylor para e^sin(x).

(%i1) poly: 0$
(%i2) for i: 1 thru 5 do
          for j: i step -1 thru 1 do
              poly: poly + i*x^j$
(%i3) poly;
                  5      4       3       2
(%o3)          5 x  + 9 x  + 12 x  + 14 x  + 15 x
(%i4) guess: -3.0$
(%i5) for i: 1 thru 10 do
          (guess: subst (guess, x, 0.5*(x + 10/x)),
           if abs (guess^2 - 10) < 0.00005 then return (guess));
(%o5)                  - 3.162280701754386

Esse exemplo calcula a raíz quadrada negativa de 10 usando a iteração de Newton- Raphson um maximum de 10 vezes. Caso o critério de convergêcia não tenha sido encontrado o valor retornado pode ser done. Em lugar de sempre adicionar uma quantidade à variável de controle pode-se algumas vezes desejar alterar isso de alguma outra forma para cada iteração. Nesse caso pode-se usar next expressão em lugar de step incremento. Isso fará com que a variável de controle seja escolhida para o resultado de avaliação da expressão cada vez que o ciclo de repetição for executado.

(%i6) for count: 2 next 3*count thru 20 do display (count)$
                            count = 2

                            count = 6

                           count = 18

Como uma alternativa para for Variável: valor ...do... a sintaxe for Variável from valor ...do... pode ser usada. Isso permite o from valor ser colocado após o step ou após o next valor ou após a condição de encerramento. Se from valor for omitido então 1 é usado como o valor inicial.

Algumas vezes se pode estar interessado em executar uma iteração onde a variável de controle nunca seja usada. Isso é permissível para dar somente as condições de encerramento omitindo a inicialização e a informação de atualização como no exemplo seguinte para para calcular a raíz quadrada de 5 usando uma fraca suposição inicial.

(%i1) x: 1000$
(%i2) thru 20 do x: 0.5*(x + 5.0/x)$
(%i3) x;
(%o3)                   2.23606797749979
(%i4) sqrt(5), numer;
(%o4)                   2.23606797749979

Se isso for desejado pode-se sempre omitir as condições de encerramento inteiramente e apenas dar o do corpo que o corpo continuará a ser avaliado indefinidamente. Nesse caso a função return será usada para encerrar a execução da declaração do.

(%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
          do (y: ev(df), x: x - f(x)/y, 
              if abs (f (x)) < 5e-6 then return (x)))$
(%i2) sqr (x) := x^2 - 5.0$
(%i3) newton (sqr, 1000);
(%o3)                   2.236068027062195

(Note que return, quando executado, faz com que o valor corrente de x seja retornado como o valor da declaração do. O block é encerrado e esse valor da declaração do é retornado como o valor do block porque o do é a última declaração do block.)

Uma outra forma de do é disponível no Maxima. A sintaxe é:

for Variável in list end_tests do corpo

Os elementos de list são quaisquer expressões que irão sucessivamente ser atribuídas para a variável a cada iteração do corpo. O teste opcional end_tests pode ser usado para encerrar a execução da declaração do; de outra forma o do terminará quando a lista for exaurida ou quando um return for executado no corpo. (De fato, a lista pode ser qualquer expressão não atômica, e partes sucessivas são usadas.)

(%i1)  for f in [log, rho, atan] do ldisp(f(1))$
(%t1)                                  0
(%t2)                                rho(1)
                                     %pi
(%t3)                                 ---
                                      4
(%i4) ev(%t3,numer);
(%o4)                             0.78539816
Função: errcatch (expr_1, ..., expr_n)

Avalia expr_1, ..., expr_n uma por uma e retorna [expr_n] (uma lista) se nenhum erro ocorrer. Se um erro ocorrer na avaliação de qualquer argumento, errcatch evita que o erro se propague e retorna a lista vazia [] sem avaliar quaisquer mais argumentos.

errcatch é útil em arquivos batch onde se suspeita que um erro possa estar ocorrendo o errcatch terminará o batch se o erro não for detectado.

Função: error (expr_1, ..., expr_n)
Variável de sistema: error

Avalia e imprime expr_1, ..., expr_n, e então causa um retorno de erro para o nível mais alto do Maxima ou para o mais próximo contendo errcatch.

A variável error é escolhida para uma lista descrevendo o erro. O primeiro elemento de error é uma seqüência de caracteres de formato, que junta todas as seqüências de caracteres entre os argumentos expr_1, ..., expr_n, e os elementos restantes são os valores de quaisquer argumentos que não são seqüências de caracteres.

errormsg() formata e imprime error. Isso efetivamente reimprime a mais recente mensagem de erro.

Função: errormsg ()

Reimprime a mais recente mensagem de erro. A variável error recebe a mensagem, e errormsg formata e imprime essa mensagem.

Operador especial: for

Usado em iterações. Veja do para uma descrição das facilidades de iteração do Maxima.

Função: go (tag)

é usada dentro de um block para transferir o controle para a declaração do bloco que for identificada com o argumento para go. Para identificar uma declaração, coloque antes dessa declaração um argumento atômico como outra declaração no block. Por exemplo:

block ([x], x:1, loop, x+1, ..., go(loop), ...)

O argumento para go deve ser o nome de um identificardor aparecendo no mesmo block. Não se pode usar go para transferir para um identificador em um outro block que não seja o próprio contendo o go.

Operador especial: if

Representa avaliação condicional. Várias formas de expressões if são reconhecidas. if cond_1 then expr_1 else expr_0 avalia para expr_1 se cond_1 avaliar para true, de outra forma a expressão avalia para expr_0.

if cond_1 then expr_1 elseif cond_2 then expr_2 elseif ... else expr_0 avalia para expr_k se cond_k for true e todas as condições precedentes forem false. Se nenhuma das condições forem true, a expressão avalia para expr_0.

O comportamento else false é assumido se else for omitido. Isso é, if cond_1 then expr_1 é equivalente a if cond_1 then expr_1 else false, e if cond_1 then expr_1 elseif ... elseif cond_n then expr_n é equivalente a if cond_1 then expr_1 elseif ... elseif cond_n then expr_n else false.

As alternativas expr_0, ..., expr_n podem ser quaisquer expressões do Maxima, incluíndo expressões if aninhadas ( if dentro de if). As alternativas não são nem simplificadas nem avaliadas a menos que a correspondente condição seja true.

As condições cond_1, ..., cond_n são expressões as quais potencialmente ou atualmente avaliem para true ou para false. Quando uma condição não avalia atualmente para para true ou para false, o comportamento de if é governado pelo sinalizador global prederror. Quando prederror for true, isso é um erro se qualquer condição avaliada não avaliar para true ou false. De outra forma, condições que não avaliem para true ou false são aceitas, e o resultado é uma expressão condicional.

Entre outros elementos, condições podem compreender operadores lógicos e relacionais como segue.

Operação             Símbolo      Tipo
 
menor que            <           infixo relacional
menor que            <=
  ou igual a                     infixo relacional
igualdade            =
  (sintática)                    infixo relacional
negação de =         #           infixo relacional
igualdade (valor)    equal       função relacional
negação de           notequal
  igualdade                      função relacional
maior que            >=
  ou igual a                     infixo relacional
maior que            >           infixo relacional
e                    and         infixo lógico
ou                   or          infixo lógico
não                  not         prefixo lógico
Função: map (f, expr_1, ..., expr_n)

Retorna uma expressão cujo operador principal é o mesmo que o das expressões expr_1, ..., expr_n mas cujas subpartes são os resultados da aplicação de f nas correspondentes subpartes das expressões. f é ainda o nome de uma função de n argumentos ou é uma forma lambda de n argumentos.

maperror - se false fará com que todas as funções mapeadas (1) parem quando elas terminarem retornando a menor exp_i se não forem todas as exp_i do mesmo comprimento e (2) aplique fn a [exp1, exp2,...] se exp_i não forem todas do mesmo tipo de objeto. Se maperror for true então uma mensagem de erro será dada nas duas instâncias acima.

Um dos usos dessa função é para mapear (map) uma função (e.g. partfrac) sobre cada termo de uma expressão muito larga onde isso comumente não poderia ser possível usar a função sobre a expressão inteira devido a uma exaustão de espaço da lista de armazenamento no decorrer da computação.

(%i1) map(f,x+a*y+b*z);
(%o1)                        f(b z) + f(a y) + f(x)
(%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
                           1       1        1
(%o2)                     ----- - ----- + -------- + x
                         x + 2   x + 1          2
                                         (x + 1)
(%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
                                      1
(%o3)                            y + ----- + 1
                                    x + 1
(%i4) map("=",[a,b],[-0.5,3]);
(%o4)                          [a = - 0.5, b = 3]


Função: mapatom (expr)

Retorna true se e somente se expr for tratada pelas rotinas de mapeamento como um átomo. "Mapatoms" são átomos, números (incluíndo números racioanais), e variáveis subscritas.

Variável de opção: maperror

Valor padrão: true

Quando maperror é false, faz com que todas as funções mapeadas, por exemplo

map (f, expr_1, expr_2, ...)

para (1) parar quando elas terminarem retornando a menor exp_i se não forem todas as exp_i do mesmo comprimento e (2) aplique f a [expr_1, expr_2, ...] se expr_i não forem todas do mesmo tipo de objeto.

Se maperror for true então uma ,mensagem de erro é mostrada nas duas instâncias acima.

Função: maplist (f, expr_1, ..., expr_n)

Retorna uma lista de aplicações de f em todas as partes das expressões expr_1, ..., expr_n. f é o nome de uma função, ou uma expressão lambda.

maplist difere de map (f, expr_1, ..., expr_n) que retorna uma expressão com o mesmo operador principal que expr_i tem (exceto para simplificações e o caso onde map faz um apply).

Variável de opção: prederror

Valor padrão: true

Quando prederror for true, uma mensagem de erro é mostrada sempre que o predicado de uma declaração if ou uma função is falha em avaliar ou para true ou para false.

Se false, unknown é retornado no lugar nesse caso. O modo prederror: false não é suportado no código traduzido; todavia, maybe é suportado no código traduzido.

Veja também is e maybe.

Função: return (valor)

Pode ser usada para sair explicitamente de um bloco, levando seu argumento. Veja block para mais informação.

Função: scanmap (f, expr)
Função: scanmap (f, expr, bottomup)

Recursivamente aplica f a expr, de cima para baixo. Isso é muito útil quando uma fatoração completa é desejada, por exemplo:

(%i1) exp:(a^2+2*a+1)*y + x^2$
(%i2) scanmap(factor,exp);
                                    2      2
(%o2)                         (a + 1)  y + x

Note o caminho através do qual scanmap aplica a dada função factor para as subexpressões constituintes de expr; se outra forma de expr é apresentada para scanmap então o resultado pode ser diferente. Dessa forma, %o2 não é recuperada quando scanmap é aplicada para a forma expandida de exp:

(%i3) scanmap(factor,expand(exp));
                           2                  2
(%o3)                      a  y + 2 a y + y + x

Aqui está um outro exemplo do caminho no qual scanmap aplica recursivamente uma função dada para todas as subexpressões, incluindo expoentes:

(%i4) expr : u*v^(a*x+b) + c$
(%i5) scanmap('f, expr);
                    f(f(f(a) f(x)) + f(b))
(%o5) f(f(f(u) f(f(v)                      )) + f(c))

scanmap (f, expr, bottomup) aplica f a expr de baixo para cima. E.g., para f indefinida,

scanmap(f,a*x+b) ->
   f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
    -> f(f(a)*f(x))+f(b) ->
     f(f(f(a)*f(x))+f(b))

Nesse caso, você pega a mesma resposta em ambos os caminhos.

Função: throw (expr)

Avalia expr e descarta o valor retornado para o mais recente catch. throw é usada com catch como um mecanismo de retorno não local.

Operador especial: while

Veja do.

Função: outermap (f, a_1, ..., a_n)

Aplica a função f para cada um dos elementos do produto externo a_1 vezes a_2 ... vezes a_n.

f é o nome de uma função de n argumentos ou uma expressão lambda de n argumentos. Cada argumento a_k pode ser uma lista simples ou lista aninhada ( lista contendo listas como elementos ), ou uma matrz, ou qualquer outro tip de expressão.

O valor de retorno de outermap é uma estrutura aninhada. Tomemos x como sendo o valor de retorno. Então x tem a mesma estrutura da primeira lista, lista aninhada, ou argumento matriz, x[i_1]...[i_m] tem a mesma estrutura que a segunda lista, lista aninhada, ou argumento matriz, x[i_1]...[i_m][j_1]...[j_n] tem a mesma estrutura que a terceira lista, lista aninhada, ou argumento matriz, e assim por diante, onde m, n, ... são os números dos índices requeridos para acessar os elementos de cada argumento (um para uma lista, dois para uma matriz, um ou mais para uma lista aninhada). Argumentos que não forem listas ou matrizes não afetam a estrutura do valor de retorno.

Note que o efeito de outermap é diferente daquele de aplicar f a cada um dos elementos do produto externo retornado por cartesian_product. outermap preserva a estrutura dos argumentos no valor de retorno, enquanto cartesian_product não reserva essa mesma estrutura.

outermap avalia seus argumentos.

Veja também map, maplist, e apply.

Exemplos: Exemplos elementares de outermap. Para mostrar a a combinação de argumentos mais claramente, F está indefinida à esquerda.

(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 
                                     [F(c, 1), F(c, 2), F(c, 3)]]
(%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
         [ [ F(a, 1)  F(a, 2) ]  [ F(b, 1)  F(b, 2) ] ]
         [ [                  ]  [                  ] ]
         [ [ F(a, 3)  F(a, 4) ]  [ F(b, 3)  F(b, 4) ] ]
(%o2)    [                                            ]
         [ [ F(c, 1)  F(c, 2) ]  [ F(d, 1)  F(d, 2) ] ]
         [ [                  ]  [                  ] ]
         [ [ F(c, 3)  F(c, 4) ]  [ F(d, 3)  F(d, 4) ] ]
(%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
       [ F(a, x, 1)  F(a, x, 2) ]  [ F(b, x, 1)  F(b, x, 2) ]
(%o3) [[                        ], [                        ]]
       [ F(a, x, 3)  F(a, x, 4) ]  [ F(b, x, 3)  F(b, x, 4) ]
(%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
       [ [ F(a, 1, x) ]  [ F(a, 2, x) ] ]
(%o4) [[ [            ]  [            ] ], 
       [ [ F(a, 1, y) ]  [ F(a, 2, y) ] ]
                              [ [ F(b, 1, x) ]  [ F(b, 2, x) ] ]
                              [ [            ]  [            ] ]]
                              [ [ F(b, 1, y) ]  [ F(b, 2, y) ] ]
(%i5) outermap ("+", [a, b, c], [1, 2, 3]);
(%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3], 
                                           [c + 1, c + 2, c + 3]]

Uma explanação final do valor de retorno de outermap. Os argumentos primeiro, segundo, e terceiro são matriz, lista, e matriz, respectivamente. O valor de retorno é uma matriz. Cada elementos daquela matriz é uma lista, e cada elemento de cada lista é uma matriz.

(%i1) arg_1 :  matrix ([a, b], [c, d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) arg_2 : [11, 22];
(%o2)                       [11, 22]
(%i3) arg_3 : matrix ([xx, yy]);
(%o3)                      [ xx  yy ]
(%i4) xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1, arg_2, arg_3);
               [  [      a        a  ]  [      a        a  ]  ]
               [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
               [  [      11       11 ]  [      22       22 ]  ]
(%o4)  Col 1 = [                                              ]
               [  [      c        c  ]  [      c        c  ]  ]
               [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
               [  [      11       11 ]  [      22       22 ]  ]
                 [  [      b        b  ]  [      b        b  ]  ]
                 [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                 [  [      11       11 ]  [      22       22 ]  ]
         Col 2 = [                                              ]
                 [  [      d        d  ]  [      d        d  ]  ]
                 [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                 [  [      11       11 ]  [      22       22 ]  ]
(%i5) xx_1 : xx_0 [1][1];
           [      a        a  ]  [      a        a  ]
(%o5)     [[ xx + --  yy + -- ], [ xx + --  yy + -- ]]
           [      11       11 ]  [      22       22 ]
(%i6) xx_2 : xx_0 [1][1] [1];
                      [      a        a  ]
(%o6)                 [ xx + --  yy + -- ]
                      [      11       11 ]
(%i7) xx_3 : xx_0 [1][1] [1] [1][1];
                                  a
(%o7)                        xx + --
                                  11
(%i8) [op (arg_1), op (arg_2), op (arg_3)];
(%o8)                  [matrix, [, matrix]
(%i9) [op (xx_0), op (xx_1), op (xx_2)];
(%o9)                  [matrix, [, matrix]

outermap preserves the structure of the arguments in the return value, while cartesian_product does not.

(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 
                                     [F(c, 1), F(c, 2), F(c, 3)]]
(%i2) setify (flatten (%));
(%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 
                                       F(c, 1), F(c, 2), F(c, 3)}
(%i3) map (lambda ([L], apply (F, L)), cartesian_product ({a, b, c}, {1, 2, 3}));
(%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 
                                       F(c, 1), F(c, 2), F(c, 3)}
(%i4) is (equal (%, %th (2)));
(%o4)                         true

[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by Jaime Villate on Outubro, 14 2014 using texi2html 1.76.