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.