Funções matemáticas no Wolfram Mathematica

Combinando com o artigo "Tipografia no Wolfram Mathematica" (http://dan-scientia.blogspot.com/2012/03/tipografia-no-wolfram-mathematica.html), este artigo traz um resumo das funções matemáticas contidas no software Mathematica.
   
Para realizar um cálculo, digita-se a função desejada e pressiona-se Shift+Enter para processar o cálculo. Para cada expressão de entrada (in) é agrupada sua saída (out) em células, esta indicação fica visível na margem direita da página.

A estrutura de uma chamada à uma função segue o padrão nome_da_função[argumentos,separados,por,vírgulas]. Os argumentos (ou opções), sempre entre colchetes, podem ser valores, variáveis, expressões e até outras funções. Se os argumentos formarem uma lista, eles devem ficar entre chaves.

Avaliar numericamente a expressão: 

N[Pi, 100]                   Número Pi com 100 casas

N[E, 50]                     Número E com 50 casas

E // N                       Número E com o número de casas padrão


Funções básicas:

Sin[60 Degree]               Seno de 60 graus

Sin[60 Degree] // N          Seno de 60 graus na forma numérica

Sin[Pi/3]                    Seno de Pi/3 radianos

Cos[45 Degree]               Cosseno de 45 graus

Cos[Pi/6]                    Cosseno de Pi/6 radianos

Tan[30 Degree]               Tangente de 30 graus

Sqrt[16]                     Raiz quadrada de 16

Exp[x]                       Exponencial de x (e^x)

Power[2, 10]                 Potência de 2 elevado a 10

Log[2, 128]                  Logarítmo de 128 na base 2

Mod[5, 2]                    Resto da divisão de 5 por 2

Binomial[10, 3]              Coeficiente binomial de 10 na classe 3

Sum[i^2, {i, 2, 10}]         Somatório de i^2, com i de 2 a 10


Estatística:

Mean[{1.21, 3.4, 2.15, 4, 1.55}]                      Média

Variance[{1.21, 3.4, 2, 4.6, 1.5, 5.61, 7.2}]         Variância

StandardDeviation[{1.2, 3.4, 2, 4.6, 1.5, 5.6, 7.2}]  Desvio Padrão

Median[{1, 2, 3, 4, 5, 6, 7}]                         Mediana


Gera lista dos valores da expressão: 

Table[Prime[n], {n, 20}]            20 primeiros números primos

Table[Fibonacci[n], {n, 20}]        20 primeiros números de Fibonacci

Table[n!, {n, 10}]                  Fatorial de n, com n de 1 a 10

Column[Table[Binomial[n, k], {n, 0, 5}, {k, 0, n}], Center]  Triângulo de Pascal


Matriz:

Det[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}]        Determinante

Inverse[{{u, v}, {v, u}}]                     Matriz inversa

Transpose[{{a, b, c}, {x, y, z}}]             Matriz transposta


Soluções para as variáveis:

Solve[x^2 - 5 x + 6 == 0, x]

Solve[{2 x + 2 y + 3 z == 5, x + y + 2 z == 3, 3 x + 4 y + 2 z == 0}, {x, y, z}]

NSolve[{2^2 a + 2 b + c == 0, 4^2 a + 4 b + c == 3, 6^2 a + 6 b + c == 0}, {a, b, c}]

NSolve[2^2 a + 2 b + c == 0 && 4^2 a + 4 b + c == 3 && 6^2 a + 6 b + c == 0, {a, b, c}]


Expande expressão polinomial: 

Expand[(x - 3)^2]

Expand[(x + 2)^3]


Simplifica a expressão: 

Simplify[(x - 1) (x + 1) (x^2 + 1) + 1]

Simplify[(x^2 - 8x + 16)/(x^2 - 16)]


Fatora uma expressão: 

Factor[x^2 - 7x + 10]

Factor[x^2 - 2^2]

Factor[(x^3 - 3^3)]


Limite da expressão: 

Limit[x^2 + 16, x -> 2]

Limit[(1 + x/n)^n, n -> Infinity]

f[x] := 2 x + 1
Limit[(f[x + h] - f[x])/h, h -> 0]


Derivada e Integral em x: 

D[x^2 + 16, x]

D[x^4 - 4 x^3 + 2 x^2 - 9, x]

D[x^4 - 4 x^3 + 2 x^2 - 9, {x, 2}]

Integrate[1 + 3 x, {x, 0, 2}]

Integrate[x^3 + 3 x + 1, {x, 2, 3}]

Integrate[Integrate[((x^2)/2) + 1, y], x]


Gráficos de funções (representados na figura abaixo): 

Plot[3 x + 1, {x, -2, 2}]


Plot[3 x + 1, {x, -1, 1}, AspectRatio -> Full, AxesOrigin -> {0, 0}, PlotRange -> {{-4, 4}, {-4, 4}}, AxesLabel -> {x, y}, Ticks -> {{-4, -3, -2, -1, 0, 1, 2, 3, 4}, {-4, -3, -2, -1, 0, 1, 2, 3, 4}}, PlotStyle -> {Thickness[0.005]}]


Plot[x^2 - 2 x + 1, {x, -4, 4}, AspectRatio -> Full, AxesOrigin -> {0, 0}, PlotRange -> {{-4, 4}, {-4, 4}}, AxesLabel -> {x, y}, Ticks -> {{-4, -3, -2, -1, 0, 1, 2, 3, 4}, {-4, -3, -2, -1, 0, 1, 2, 3, 4}}, PlotStyle -> {Thickness[0.005]}]


Plot[Sin[x], {x, 0, 6 Pi}, PlotStyle -> {Thickness[0.005]}]


PolarPlot[x, {x, 0, 10 Pi}]


ContourPlot[x^2 + y^2 == 1, {x, -1, 1}, {y, -1, 1}]


ParametricPlot[{Cos[x], Sin[x]}, {x, 0, 2 Pi}]


RegionPlot[x^2 + y^2 <= 1, {x, -1, 1}, {y, -1, 1}]

Gráficos das funções acima.

Gráficos em três dimensões (representados na figura abaixo): 

ParametricPlot3D[{Cos[2 t], Sin[2 t], t}, {t, 0, 2 \[Pi]}]


ParametricPlot3D[{{4 + (3 + Cos[v]) Sin[u], 4 + (3 + Cos[v]) Cos[u], 4 + Sin[v]}, {8 + (3 + Cos[v]) Cos[u], 4 + Sin[v], 4 + (3 + Cos[v]) Sin[u]}}, {u, 0, 2 Pi}, {v, 0, 2 Pi}, PlotStyle -> {Red, Green}]


ParametricPlot3D[{v Cos[u], v Sin[u], 2 v}, {u, 0, 2 Pi}, {v, 0, 1}, Mesh -> 5, BoundaryStyle -> Black, PlotStyle -> FaceForm[Red, Yellow]]


RevolutionPlot3D[{Cos[t], Sin[t]}, {t, -Pi/2, Pi/2}]


Plot3D[(x^2 + y^2) Exp[-(x^2 + y^2)], {x, -2, 2}, {y, -2, 2}]

Gráficos das funções acima.

Áudio:

Play[Sin[440 2 Pi t], {t, 0, 1}]


Sound[{SoundNote["C"], SoundNote["G"]}]


O Mathematica é um software extremamente rico de funções e comandos. Praticamente todos os cálculos matemáticos são suportados neste software. Experimente testar estes comandos, teclando após a entrada de cada um deles a combinação Shift+Enter.

Definindo apelidos e funções para comandos no bashrc

O arquivo bashrc determina o comportamento do shell, neste caso o interpretador de comandos bash. Basicamente o arquivo bashrc permite criar atalhos, podendo ser apelidos (alias) ou programas interativos (funções), que são carregados na inicialização do bash. O arquivo bashrc permite criar atalhos para praticamente todos os comandos.

Por exemplo, é muito mais fácil digitar o atalho "l" do que um comando como "ls -laF --color=auto". E uma função é como um roteiro (script) para o shell colocado em um arquivo bashrc. É ideal para casos em que o atalho não será para apenas um simples comando ou necessita de uma lógica em alguma estrutura de programação.

Existem dois arquivos bashrc que o interpretador de comandos bash carrega em cada nova inicialização do shell, o /etc/bashrc é carregado para todos os usuários e o ~/.bashrc é carregado para o usuário que iniciou o shell, ou seja, cada usuário tem o seu arquivo ~/.bashrc.

Tanto para apelidos ou para funções é recomendável testar primeiro os comandos em uma execução direta no prompt antes de incluí-los no arquivo bashrc. Diferentemente de um script para o shell, a interpretação de uma função não gera um novo processo no sistema.

Alguns exemplos de apelidos definidos no arquivo bashrc:

alias l="ls -laF --color=auto"
alias cds="cd /etc/rc.d/init.d && ls"
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
alias qag="rpm -qa | grep -i"
alias av="avast -a -c -t=A"
alias fd='mount /dev/fd0 /mnt/floppy; cd /mnt/floppy && ls'

Uma função pode ser definida com a estrutura apresentada abaixo:

function nome_da_função()
{
    comando 1;
    comando 2;
    comando 3;
    ...
}

A palavra "function" é opcional na declaração de uma função mas pode ser considerada uma boa prática. Veja um exemplo bastante interessante:

function extrair()
{
     if [ -f $1 ] ; then
         case $1 in
             *.tar.bz2)   tar xvjf $1     ;;
             *.tar.gz)    tar xvzf $1     ;;
             *.bz2)       bunzip2 $1      ;;
             *.rar)       unrar x $1      ;;
             *.gz)        gunzip $1       ;;
             *.tar)       tar xvf $1      ;;
             *.tbz2)      tar xvjf $1     ;;
             *.tgz)       tar xvzf $1     ;;
             *.zip)       unzip $1        ;;
             *.Z)         uncompress $1   ;;
             *.7z)        7z x $1         ;;
             *)           echo "'$1' não pode ser extraído via >extrair<" ;;
         esac
     else
         echo "'$1' não é um arquivo válido"
     fi
}

Para ativar uma definição imediatamente após a sua inclusão no arquivo bashrc, sem a necessidade de sair do interpretador de comandos e entrar novamente, basta digitar:

$ source ~/.bashrc

Para saber quais apelidos estão ativos no interpretador bash basta executar o comando alias no prompt. O shell irá imprimir a lista dos apelidos na saída padrão, normalmente na tela do monitor. As funções ativas podem ser vistas com a execução do comando set, sem opções, onde o nome e o valor de cada variável e função do shell serão mostrados na tela.

Criando funções no Excel com o Visual Basic for Aplications

Além das funções que acompanham o software Excel, nós podemos desenvolver e acrescentar mais funções utilizando o Editor do Visual Basic for Aplications. Uma função é uma seqüência de comandos armazenada em um módulo do VBA. Uma função programada no Editor do VBA pode ser usada diretamente em uma célula, bastando por exemplo digitar =NomeDaFunção(), semelhante a qualquer outra função existente no Excel.

Este artigo descreve os procedimentos para o Excel versão 2003, para as outras versões pode haver alguma diferença.

Para criar uma funcão entre no Editor do VBA em Ferramentas -> Macro -> Editor do Visual Basic. Insira um módulo pelo menu Inserir -> Módulo e insira uma função dentro desse módulo pelo menu Inserir -> Procedimento. Escolha um nome, selecione o tipo Função e o escopo Público, clique OK. Na janela do módulo digite todo o código da sua função dentro do espaço em branco entre o nome da função e seu delimitador final. Salve as mudanças para este módulo e, de volta ao Excel, digite a chamada à função na célula desejada.

Para retornar à edição do código da função, volte no Editor do Visual Basic e na janela "Project Explorer" (menu Exibir) expanda VBAProject e Módulos, clique com o botão direito sobre um módulo e clique "Exibir código" (ou duplo clique sobre o módulo). Faça as alterações que desejar e salve. Para cada vez que o código de uma função for alterado, será necessário executar novamente a função dentro da célula.

Não é possível neste artigo ensinar toda a linguagem VBA, mas é possível apresentar um resumo contendo os principais comandos da linguagem. Assim pelo menos alguma coisa já vai ser possível fazer. Como em diversas linguagens de programação, no VBA existem palavras reservadas que são os comandos da linguagem. Estas palavras devem ser digitadas respeitando as letras maiúsculas e minúsculas e não podem ser usadas como por exemplo para nomes de variáveis.

Um procedimento é um conjunto de instruções, ao qual é atribuído um nome e sua execução feita individualmente num módulo. Existem dois tipos de procedimentos: Sub e Function. A diferença entre estes dois tipos reside no fato de Function poder devolver um valor, o que não acontece com Sub. Este artigo está demonstrando o desenvolvimento e o uso de funções então segue apenas a estrutura de uma Function:

Function nome(arg1,arg2,...) As tipo
    Comando 1   
    Comando 2   
    ...   
    nome = valor   
End Function

Uma função pode receber valores para sua execução, valores vindos de outras células por exemplo, e estes valores entram como argumentos para o nome da função. No invocamento da função na célula usa-se a mesma sintaxe separando os argumentos com ponto-e-vírgula. E para que uma função possa devolver um determinado valor é necessário que uma de suas instruções faça a atribuição ao seu nome.

Todos os valores, numéricos ou não, são armazenados em variáveis. Antes de utilizar uma variável no código é necessário declará-la primeiro, seguindo o modelo:

Dim nome As tipo
Dim nome(1 To n) As tipo

Os tipos podem ser:

Boolean         True ou False
Byte            inteiro de 0 até 255
Integer         inteiro de -32.768 até 32.767
Long            inteiro de -2.147.483.648 até 2.147.483.647
Single          ponto flutuante de -3,4E38 e -1,4E-45 até 3,4E38 e 1,4E-45
Double          ponto flutuante de -1,798E308 e -4,94E-324 até 1,798E308 e 4,94E-324
Currency        ponto flutuante de -923.337.203.685.447,5808 até 922.337.203.685.447,5807
Date            01/01/100 até 31/12/9999 e horas de 0:00:00 até 23:59:59
String          até 2 bilhões de caracteres
Error           número de erro
Variant         suporta todos os tipos

Observação: Uma variável declarada sem tipo, é do tipo Variant e pode conter qualquer valor.

Exemplos de declarações de variáveis:

Dim nome As String
Dim nota1,nota2 As Integer
Dim vetor(1 To 4) As Double
Dim matriz(1 To 5, 1 To 6) As Integer

Para uma variável receber um valor utiliza-se o operador de atribuição. Um operador de atribuição é o que atribui um valor à uma variável e é representado pelo sinal de igual "=". a = b significa a toma o valor de b, exemplos:

x = y
x = a + b
vetor(2) = 7
matriz(1,3) = x*y

Os operadores aritméticos fazem as operações aritméticas entre variáveis e ou valores, eles são:

Adição                 +
Subtração              -
Multiplicação          *
Divisão                /
Inteiro da Divisão     \
Potência               ^
Resto da Divisão       Mod

Exemplos: x/y    a^2    a Mod b

No caso de Strings, que são conjunto de caracteres, existe o operador de concatenação & ou +. Então "bom" & "dia" ou "bom" + "dia" retorna "bomdia".

Também é possível comparar os conteúdos das variáveis utilizando os operadores de comparação, os quais retornam como resposta verdadeiro ou falso:

Igualdade               =
Diferença               <>
Maior que               >
Menor que               <
Maior ou igual a        >=
Menor ou igual a        <=

Exemplos: a = b        x >= 6

E diversas comparações podem ser agrupadas por operadores lógicos:

E               And
Ou              Or
Ou Exclusivo    Xor
Não             Not

Exemplos: a = b And a > c            x >= 3 Or y <> 7

Existem algumas estruturas de comandos que são para seleção e para repetição de partes do código. Uma estrutura de seleção atende a um retorno de um operador lógico e executa o código referente à resposta. Uma estrutura de repetição pode executar novamente o código, quantas vezes a condição for verdadeira.

Estruturas de Seleção:

If x>y Then            If x>y Or a<>b Then            If (x>y Or a=b) And i>=j Then
    Comando 1              Comando 1                      Comando 1
    Comando 2              Comando 2                      Comando 2
    ...                    ...                            ...
End If                 Else                           ElseIf x=y Then
                           Comando 1                      Comando 1
                           Comando 2                      Comando 2
                           ...                            ...
                       End If                         Else
                                                          Comando 1
                                                          Comando 2
                                                          ...
                                                      End If


Select Case x                Select Case x
    Case 2                       Case Is < 2
        Comando 1                    Comando 1
        Comando 2                    Comando 2
        ...                          ...
    Case 4                       Case Is = 1, 3 To 5
        Comando 1                    Comando 1
        Comando 2                    Comando 2
        ...                          ...
    Case 6                       Case 6 To 8, 10
        Comando 1                    Comando 1
        Comando 2                    Comando 2
        ...                          ...
    Case Else                    Case Else
        Comando 1                    Comando 1
        Comando 2                    Comando 2
        ...                          ...
    End Select                   End Select

Estruturas de Repetição:

For i=1 To 10            For i=1 To 10 Step 2            For Each valor In matriz
    Comando 1                Comando 1                       Comando 1
    Comando 2                Comando 2                       Comando 2
    ...                      ...                             ...
Next                     Next                            Next


Do While x<=y            Do                      Do
    Comando 1                Comando 1               If x>y Then
    Comando 2                Comando 2                   Comandos
    ...                      ...                     Else
Loop                     Loop While x<=y                 Exit Do
                                                 Loop

Do Until x=y             Do
    Comando 1                Comando 1
    Comando 2                Comando 2
    ...                      ...
Loop                     Loop Until x=y

Exemplo de código de uma função:

Public Function PRIMO(escolhido As Integer) As Long

Dim pos As Integer
Dim num, divisor, nprimo As Long

num = 2
pos = 0

If escolhido < 1 Then
    PRIMO = 0
Else
    Do While pos < escolhido
        divisor = 2
        Do While divisor <= num
            If divisor = num Then
                nprimo = num
                pos = pos + 1
                Exit Do
            ElseIf num Mod divisor = 0 Then
                Exit Do
            Else
                divisor = divisor + 1
            End If
        Loop
        num = num + 1
    Loop
    PRIMO = nprimo
End If

End Function

A função demonstrada neste exemplo pode ser invocada em uma célula da planilha com o comando =PRIMO(B3), por exemplo. A função receberá o valor contido na célula B3 e a célula que invoca esta função receberá o valor de retorno da função.

O Visual Basic for Aplications proporciona aos usuários uma rica ferramenta para adaptar o Excel às suas necessidades. Assim o usuário não fica limitado aos recursos de fábrica do Excel. Experimente criar algumas funções e se houver interesse aprenda à fundo a linguagem VBA.

Funções Recursivas e Funções Iterativas

Em programação de softwares de computadores existem dois procedimentos que permitem que um código seja executado repetidamente, um é a função recursiva, onde em um dos passos do procedimento a função invoca-se à si própria, e o outro é a função iterativa, onde ocorre a repetição de um ou mais passos controlados por um laço de repetição.

Os dois procedimentos tem suas vantagens e desvantagens, que envolvem o consumo de memória, de processamento, tamanho e clareza do código etc. Não vou entrar aqui em detalhes quanto à análise da eficiência dos algoritmos, apenas quero apresentar as diferenças estruturais destes dois procedimentos.

Em ambos os casos, por serem procedimentos que realizam uma repetição de passos, é necessário que se tenha uma condição de parada, senão a repetição corre o risco de ser infinita.

A função iterativa utiliza comandos chamados laços de repetição para o controle do fluxo de execução, como o comando for ou while por exemplo, que dependem de uma condição ser verdadeira ou falsa para iniciar ou interromper a repetição.

A função recursiva realiza a repetição dos seus passos invocando à si própria, executando todos os seus passos novamente em uma chamada completamente independente da mesma função. Nesta segunda chamada a função pode invocar-se novamente e assim várias vezes até que uma estrutura de controle encerre esta ação, e então cada retorno é recebido pelas funções anteriores de forma cumulativa.

Segue abaixo versões iterativas e recursivas das soluções de alguns problemas mais conhecidos:

Fatorial de um número, versão iterativa, em VBA:

Public Function FATO(numero As Integer) As Integer

Dim fatorial As Integer
fatorial = 1
For i = 1 To numero
    fatorial = fatorial * i
Next
FATO = fatorial

End Function

Fatorial de um número, versão recursiva, em VBA:

Public Function FATO(numero As Integer) As Integer

If numero <= 1 Then
    FATO = 1
Else
    FATO = numero * FATO(numero - 1)
End If

End Function

Número de Fibonacci, versão iterativa, em VBA:

Public Function FIBONACCI(posicao As Integer) As Long

Dim anterior, atual, proximo As Long
Dim contador As Integer

If posicao = 1 Or posicao = 2 Then
    FIBONACCI = 1
ElseIf posicao >= 3 Then
    anterior = 1
    atual = 1
    For contador = 3 To posicao
        proximo = anterior + atual
        anterior = atual
        atual = proximo
    Next
    FIBONACCI = atual
Else
    FIBONACCI = 0
End If

End Function

Número de Fibonacci, versão recursiva, em VBA:

Public Function FIBONACCI(posicao As Integer) As Long

If posicao >= 3 Then
    FIBONACCI = FIBONACCI(posicao - 1) + FIBONACCI(posicao - 2)
Else
    FIBONACCI = 1
End If

End Function

Pesquisa binária, versão iterativa, em Java:

public static int pesqbinite(int[] vetor, int valor) {

int esq = 0;
int dir = vetor.length - 1;
int meio;

while ( esq <= dir ) {
     meio = (esq + dir) / 2;
     if ( vetor[meio] < valor ) {
          esq = meio + 1;
     } else if( vetor[meio] > valor ) {
          dir = meio - 1;
     } else {
          return meio;
     }
}
return -1;
}

Pesquisa binária, versão recursiva, em Java:

public static int pesqbinrec(int[] vetor, int pi, int pf, int valor){

int meio = ((pf - pi) / 2) + pi;

if (vetor[meio] == valor) {
     return meio;
} else if ((vetor[meio] < valor) && (valor <= vetor[pf])) {
     pi = meio + 1;
     return pesqbinrec(vetor,pi,pf,valor);
} else if ((vetor[meio] > valor) && (valor >= vetor[pi])) {
     pf = meio;
     return pesqbinrec(vetor,pi,pf,valor);
} else {
     return -1;
}
}

Função Ackermann

Uma das mais importantes funções na ciência da computação. Sua maior propriedade é que ela cresce surpreendentemente rápido pois esta função eleva seu retorno rapidamente para números muito grandes, denominados números Ackermann e que normalmente são representados em uma notação inventada por Donald Knuth, a notação "up-arrow" ou notação de Knuth.

A função Ackermann foi descoberta e estudada por Wilhelm Ackermann em 1928. A função que ele descobriu, que então recebeu seu nome, é um simples exemplo de uma função total e bem definida que pode ser computável mas não é uma recursão primitiva. "Total e bem definida" significa que a função é internamente consistente e não quebra as regras das instruções que a define. "Computável" significa que ela pode, em princípio, ser avaliada por todos os valores possíveis em suas variáveis. "Recursão primitiva" significa que pode ser computada usando somente laços for, repetindo a operação em um número de vezes predeterminado. A função Ackermann somente pode ser calculada usando o laço de repetição while, que repete a ação até que o teste da condição retorne falso.

A função Ackermann é definida recursivamente para números inteiros não negativos, m e n, como:

          n + 1                  se m = 0
A(m, n) = A(m - 1, 1)            se m > 0 e n = 0
          A(m - 1, A(m, n - 1))  se m > 0 e n > 0

Dois inteiros positivos, m e n, são a entrada e A(m ,n) é a saída sendo outro inteiro positivo. A função pode ser programada facilmente em apenas poucas linhas de código. O problema não é a complexidade da função mas sua terrível taxa de crescimento. Por exemplo uma inocente entrada A(4,2) retorna um número de 19.729 dígitos:

A(0, n) = n + 1
A(1, n) = 2 + (n + 3) - 3
A(2, n) = 2 × (n + 3) - 3
A(3, n) = 2^(n + 3) - 3
A(4, n) = 2^(2^(...^2)) - 3 (n + 3 números dois)
A(5, n) = 2^(2^(...^2))^(2^(2^(...^2)))^(...^(2^(2^(...^2)))) - 3

Por isso o uso de uma grafia especial para números grandes como a notação de Knuth é indispensável, como mostra o exemplo abaixo:

A(4, n) = 2^^(n + 3) - 3
A(5, n) = 2^^^(n + 3) - 3

Como podem perceber, a função Ackermann estabelece adições iterativas e multiplicações iterativas, efetuando potências dentro de potências, recursivamente (potências iterativas). Alguns resultados da função Ackermann para as entradas m e n são mostrados abaixo:

                             n
          0      1           2             3    4    5
   0      1      2           3             4    5    6
m  1      2      3           4             5    6    7
   2      3      5           7             9   11   13
   3      5     13          29            61  125  253
   4     13  65533  2^65536 -3  2^2^65536 -3  ...
   5  65533  ...

O código para a função Ackermann é bastante simples, abaixo dois exemplos em java que aplicam a função:

public static long acker(long m, long n) {
  if(m == 0) {
        return n + 1;
  } else if(n == 0) {
        return acker(m-1, 1);
  } else {
        return acker(m-1, acker(m, n-1));
  }
}

Ou:

public static long acker(long m, long n) {
  return (m == 0) ? (n + 1) : ((n == 0) ? acker(m-1, 1) : acker(m-1, acker(m, n-1)));
}

A função Ackermann devido a sua característica de recursão extremamente profunda pode ser usada como teste de medida da capacidade de um compilador otimizar a recursão.

Veja mais em:

http://mathworld.wolfram.com/AckermannFunction.html
http://rosettacode.org/wiki/Ackermann_Function
http://planetmath.org/encyclopedia/AckermannFunction.html
http://kosara.net/thoughts/ackermann.html

Gráficos das funções do 1º e 2º graus

Função do 1º Grau:

Para uma função representada pela fórmula y = ax + b ou f(x)= ax + b, o gráfico será uma reta, onde a é o coeficiente angular da reta e b é a interseção da reta com o eixo y. O zero ou raiz da função é o valor de x que anula a função, torna f(x) = 0, e é o ponto de interseção da reta com o eixo x.

Com a = 1 a inclinação será 45° e com b = 1 a reta passa pelo ponto 1 no eixo y. A seguir o gráfico da função y = x + 1:


Com a > 1 a inclinação da reta tem ângulo maior que 45°. Quanto mais alto o valor de a mais próximo o ângulo da inclinação fica de 90°, porém esta angulação nunca chegará, mesmo com a tendendo ao infinito. A seguir o gráfico com as funções y = 2x, y = 4x e y = 100x:


Para valores de a no intervalo entre 0 e 1 a inclinação da reta tem ângulo menor que 45°. Quanto mais próximo de a = 0 a reta tende para horizontal. A seguir o gráfico com as funções y = 0,5x ou y = x/2, y = 0,2x e y = 0,01x:


Com a = 0 a reta é horizontal, sendo uma função constante, e então com a < 0 a reta começa a ficar com uma inclinação negativa pois é uma função decrescente. A seguir o gráfico das funções y = 0x + 1 ou y = 1 e y = -4x + 1:



Função do 2º Grau:

Para uma função representada pela fórmula y = ax² + bx + c ou f(x)= ax² + bx + c, o gráfico será uma parábola, onde a indica a concavidade da parábola, b indica o deslocamento da parábola para direita ou esquerda e c o ponto em y onde corta a parábola. Os zeros ou raízes da função são os valores de x que anulam a função, tornam f(x) = 0, e indicam os pontos no eixo x onde cortam a parábola. Se Delta¹ > 0 existem duas raízes, se Delta = 0 existe apenas uma raiz e se Delta < 0 não existem raízes. O vértice é dado pelo ponto V(-b/2a,-Delta/4a).

Com o valor de a sendo positivo a parábola tem concavidade voltada para cima, com o valor de b positivo a parábola desloca-se para a esquerda e com c = 1 a parábola passa pelo ponto 1 no eixo y. A seguir o gráfico da função y = x² + x + 1:


Agora alterando o valor de b a parábola faz um deslocamento a partir de seu vértice pelo ponto c no eixo y. Para b com valor positivo a parábola desloca-se para esquerda. Com b = 0 o vértice da parábola fica sobre o ponto onde corta o eixo y. Para b com valor negativo a parábola desloca-se para direita. A seguir o gráfico das funções y = x² + 3x - 2, y = x² - 2 e y = x² - 3x - 2:


Passamos então para o valor de a, que indica a concavidade da parábola. Com a > 0 a parábola tem concavidade voltada para cima e quanto maior o seu valor mais fechada será a concavidade. A seguir o gráfico com as funções y = 2x² + x - 2, y = 4x² + x - 2 e y = 8x² + x - 2:


Mas com o valor de a aproximando-se de 0 mais aberta será a concavidade. Obviamente com a = 0 a função torna-se uma equação de 1° grau então o gráfico é uma reta. A seguir o gráfico com as funções y = 0.5x² + x + 1, y = 0.2x² + x + 1, y = 0.1x² + x + 1 e y = x + 1:


Com a < 0 a parábola tem concavidade voltada para baixo e quanto menor o seu valor mais fechada será a concavidade. A seguir o gráfico com as funções y = -0.2x² + x + 1, y = -x² + x + 1 e y = -2x² + x + 1:


Agora um fato interessante é que alterando somente b para valores desde negativos até positivos, o vértice da parábola desenha exatamente a mesma parábola da função com a negativo e b igual a zero. A seguir o gráfico da função y = x² + x + 1, com b nos valores (-3,-2,-1,1,2,3) e o percurso do vértice sobre o gráfico da função y = -x² + 1:




¹ Delta = b²-4ac