Next: Macros, Previous: Introdução a Definição de Função, Up: Definição de Função [Contents][Index]

### 39.2 Função

#### 39.2.1 Ordinary functions

Para definir uma função no Maxima você usa o operador `:=`. E.g.

    f(x) := sin(x)

define uma função `f`. Funções anônimas podem também serem criadas usando `lambda`. Por exemplo

    lambda ([i, j], ...)

pode ser usada em lugar de `f` onde

    f(i,j) := block ([], ...);
    map (lambda ([i], i+1), l)

retornará uma lista com 1 adicionado a cada termo.

Você pode também definir uma função com um número variável de argumentos, teno um argumento final que é atribuído para uma lista de argumentos extras:

    (%i1) f ([u]) := u;
    (%o1)                      f([u]) := u
    (%i2) f (1, 2, 3, 4);
    (%o2)                     [1, 2, 3, 4]
    (%i3) f (a, b, [u]) := [a, b, u];
    (%o3)               f(a, b, [u]) := [a, b, u]
    (%i4) f (1, 2, 3, 4, 5, 6);
    (%o4)                 [1, 2, [3, 4, 5, 6]]

O lado direito de uma função é uma expressão. Desse modo Se você quer uma seqüência de expressões, você faz

    f(x) := (expr1, expr2, ...., exprn);

e o valor de exprn é que é retornado pela função.

Se você deseja fazer um `return` de alguma expressão dentro da função então você deve usar `block` e `return`.

    block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)

é em si mesma uma expressão, e então poderá ocupar o lugar do lado direito de uma definição de função. Aqui pode acontecer que o retorno aconteça mais facilmente que no exemplo anterior a essa última expressão.

O primeiro `[]` no bloco, pode conter uma lista de variáveis e atribuições de variáveis, tais como `[a: 3, b, c: []]`, que farão com que as três variáveis `a`,`b`,e `c` não se refiram a seus valores globais, mas ao contrário tenham esses valores especiais enquanto o código estiver executando a parte dentro do bloco `block`, ou dentro da funções chamadas de dentro do bloco `block`. Isso é chamado associação dynamic, uma vez que as variáveis permanecem do início do bloco pelo tempo que ele existir. Uma vez que você retorna do `block`, ou descarta-o, os valores antigos (quaisquer que sejam) das variáveis serão restaurados. É certamente uma boa idéia para proteger suas variáveis nesse caminho. Note que as atribuições em variáveis do bloco, são concluídas em paralelo. Isso significa, que se tiver usado `c: a` acima, o valor de `c` será o valor de `a` a partir do momento em que vocêntrou no bloco, mas antes `a` foi associado. Dessa forma fazendo alguma coisa como

    block ([a: a], expr1, ...  a: a+3, ..., exprn)

protegerá o valor externo de `a` de ser alterado, mas impedirá você acessar o valor antigo. Dessa forma o lado direito de atribuições, é avaliado no contexto inserido, antes que qualquer avaliação ocorra. Usando apenas `block ([x], ...` faremos com que o `x` tenha a si mesmo como valor, apenas como x teria se você tivesse entrado numa breve sessão do Maxima.

Os atuais argumentos para uma função são tratados exatamente da mesma que as variáveis em um bloco. Dessa forma em

    f(x) := (expr1, ..., exprn);

e

    f(1);

teremos um contexto similar para avaliação de expressões como se tivéssemos concluído

    block ([x: 1], expr1, ..., exprn)

Dentro de funções, quando o lado direito de uma definição, pode ser calculado em tempo de execução, isso é úti para usar `define` e possivelmente `buildq`.

#### 39.2.2 Função de Array

Uma função de Array armazena o valor da função na primeira vez que ela for chamada com um argumento dado, e retorna o valor armazenado, sem recalcular esse valor, quando o mesmo argumento for fornecido. De modo que uma função é muitas vezes chamada uma função de memorização.

Nomes de funções de Array são anexados ao final da lista global `arrays` (não na lista global `functions`). O comando `arrayinfo` retorna a lista de argumentos para os quais exite valores armazenados, e `listarray` retorna os valores armazenados. Os comandos `dispfun` e `fundef` retornam a definição da função de array.

O comando `arraymake` contrói uma chamada de função de array, análogamente a `funmake` para funções comuns. O comando `arrayapply` aplica uma função de array a seus argmentos, análogamente a `apply` para funções comuns. Não existe nada exatamente análogo a `map` para funções de array, embora `map(lambda([x], a[x]), L)` ou `makelist(a[x], x, L)`, onde L é uma lista, não estejam tão longe disso.

O comando `remarray` remove uma definição de função de array (incluindo qualquer valor armazenado pela função removida), análogo a `remfunction` para funções comuns.

o comando `kill(a[x])` remove o valor da função de array a armazenado para o argumento x; a próxima vez que a foor chamada com o argumento x, o valor da função é recomputado. Todavia, não exite caminho para remover todos os valores armazenados de uma vez, exceto para `kill(a)` ou `remarray(a)`, o qual remove também remove a definição da função de array.

Next: Macros, Previous: Introdução a Definição de Função, Up: Definição de Função [Contents][Index]