Manual do Maxima 5.46.0: Função

Próximo: Macros, Previous: Introdução a Definição de Função, Acima: Definição de Função [Conteúdo][Índice]

### 39.2 Função

#### 39.2.1 Ordinary functions

Para definir uma função no Maxima usa-se o operador :=. Por exemplo,

    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.

Pode também definir uma função com um número variável de argumentos, usando um argumento final que seja uma lista, na qual serão inseridos todos os argumentos adicionais:

    (%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 na definição de uma função é uma expressão. Assim, quando quiser que a definição seja uma sequência de expressões, poderá usar a forma

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

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

Se quiser introduzir um ponto de `retorno` em alguma expressão dentro da função, deverá 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. Quando regressar do bloco `block`, ou o descartar, os valores antigos (quaisquer que sejam) das variáveis serão restaurados. É certamente uma boa idéia para proteger as suas variáveis nesse caminho. Note que as atribuições em variáveis do bloco, são realizadas em paralelo. Isso significa, que se tivesse usado `c: a` acima, o valor de `c` seria o valor que `a` tinha antes do bloco, antes de ter obtido o seu novo valor atribuído no bloco. 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á aceder ao valor antigo. Assim, 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` tenho como valor a si próprio; esse é o mesmo valor que teria no início de uma sessão do Maxima.

Os actuais argumentos para uma função são tratados exactamente 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 exactamente 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, excepto para `kill(a)` ou `remarray(a)`, o qual remove também remove a definição da função de array.

Próximo: Macros, Previous: Introdução a Definição de Função, Acima: Definição de Função [Conteúdo][Índice]