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.