dynamics (Manual do Maxima)

## 49, dynamics ¶

### 49.1, Introdução a dynamics ¶

O pacote adicional `dynamics` inclui muitas funções para criar várias representações gráficas de sistemas dinâmicos discretos e fractais, e uma implementação deo método numérico de Runge-Kutta de quarta ordem para a resolução de sistemas de equações diferenciais.

Para usar as funções nesse pacote você deve primeiramente torná-lo disponível para uso com `load("dynamics")`.

Modificações introduzidas no Maxima 5.12

Iniciando no Maxima 5.12, o pacote dynamics agora utiliza a função `plot2d` para monar os gráficos. Os comandos que produzem gráficos (com exceção de `julia` e de `mandelbrot`) agora aceitam qualquer opção de `plot2d`, incluindo a opção que modificam o montante das várias interfaces gráficas, usando diferentes estilos de montagem de gráfico e cores, e representando um ou ambos os eixos em uma escala logarítmica. As antigas opções domain, pointsize, xcenter, xradius, ycenter, yradius, xaxislabel e yaxislabel não são aceitas nessa nova versão.

Todos os programas irão agora aceitar quaisquer nomes de variáveis, e não apenas x e y como nas antigas versões. Dois parâmetros requeridos tiveram modificações em dois desses programas: `evolution2d` agora requer uma lista nomeando explicitamente as duas variáveis independentes, e o intervalo horizontal para `orbits` não mais requer um tamanho de passo; o intervalo pode somente espcificar o nome da variável, e o menor e o maior valores; o número de passos pode agora ser modificado com a opção nticks.

### 49.2, Funções e Variáveis Definidas para dynamics ¶

Função: chaosgame (`[[`x1, y1`]`...`[`xm, ym`]]`, `[`x0, y0`]`, b, n, ...opções...); ¶

  Implementa o então chamado jogo do caos: o ponto inicial (x0, y0) é colocado no gráfico e então um dos m pontos `[`x1, y1`]`...`[`xm, ym`]` será selecionado de forma aleatória. O próximo ponto colocado no gráfico será sobre o segmento que vai do ponto anteriormente colocado no gráfico ao ponto escolhido aleatóriamente, à distância do ponto aleatório que será b vezes o comprimento daquele segmento. o procedimento é repetido n vezes.

Função: evolution (F, y0, n, ..., opções, ...); ¶

  Desenha n+1 pontos em gráfico bidimensional, onde as coordenadas horizontais dos pontos são os inteiros 0, 1, 2, ..., n, e as coordenadas verticais são os valores correspondentes y(n) da seqüência definida pela relação de recorrência

              y(n+1) = F(y(n))

  com valor inicial y(0) igual a y0. F deve ser uma expressão que depende somente de uma variável (no exemplo, essa variável dependente de y, mas qualquer outra variável pode ser usada em lugar de y), y0 deve ser um número real e n deve ser um inteiro positivo.

Função: evolution2d (`[`F, G`]`, `[`u, v`]`, `[`u0, y0`]`, n, ..., opções, ...); ¶

  Mostra, em um gráfico bidimensional, os primeiros n+1 pontos na seqüência de pontos definida por meio do sistema dinâmico discreto bidimensional com relações de recorrência

              u(n+1) = F(u(n), v(n))    v(n+1) = G(u(n), v(n))

  Com valores iniciais u0 e v0. F e G devem ser duas expressões que dependem somente de duas variáveis u e v, que devem ser nomeadas explicitamente em uma lista.

Função: ifs (`[`r1, ..., rm`]`, `[`A1, ..., Am`]`, `[[`x1, y1`]`, ..., `[`xm, ym`]]`, `[`x0, y0`]`, n, ..., opções, ...); ¶

  Implemanta o método de Sistemas de Funções iteradas. Esse método é similar ao método descrito na função `chaosgame`, mas em lugar de encolher o segmento do ponto corrente ao ponto escolhido aleatóriamente, as duas componentes daquele segmento irão ser multiplicadas pela matrix 2 por 2 Ai que corresponde ao ponto escolhido aleatóriamente.

  A escolha aleatória de um dos m pontos de atração pode ser feita com uma distribuição de probabilidade não uniforme definida por meio dos pesos r1,...,rm. Esses pesos são fornecidos de forma cumulativa; por exemplo se existem 3 pontos com probabilidades 0.2, 0.5 e 0.3, os pesos r1, r2 e r3 podem ser 2, 7 e 10.

Função: rk (EDO, var, inicio, domain) ¶
Função: rk ([EDO1,...,EDOm], [v1,...,vm], [inic1,...,inicm], domain) ¶

  A primeira forma resolve numericamente uma equação diferencial de primeira ordem, e a segunda formaresolve um sistema de m dessas equações, usando o método de Runge-Kutta de quarta ordem. `var` representa a variável dependente. EDO deve ser uma expressão que dependa somente da variável independente e da variável dependente e defina a derivada da variável dependente com relação à variável independente.

  A variável independente é especificada com `domain`, que deve ser uma lista dde quatro elementos como, por exemplo:

      [t, 0, 10, 0.1]

  O primeiro elemento da lista identifica a variável independente, o segundo e o terceiro elementos são os valores inicial e final para para aquela variável, e o último elemento escolhe o incremento que pode ser usado dentro daquele intervalo.

  Se m equações estão sendo resolvidas, podem existir m variáveis dependentes v1, v2, ..., vm. Os valores iniciais para aquelas variáveis serão inic1, inic2, ..., inicm. Ainda pode ser apenas uma variável independente definida por `domain`, como no caso anterior. EDO1, ..., EDOm são as expressões que definem as derivadas de cada variável dependente em termos da variável independente. As variáveis que podem aparecer naquelas expressões são a variável independente e quaisquer outras variáveis dependentes. É importante fornecer as derivadas EDO1, ..., EDOm na lista exatamente na mesma ordem usada para variáveis dependentes; por exemplo, o terceiro elemento na lista irá ser interpretado com a derivada da terceira variável dependente.

  O programa tentará integrar as equações a partir do valor inicial da variável independente até seu último valor, usando incrementos constantes. Se em algum passo uma das variáveis dependentes recebe um valor absoluto muito grande, a integração será interrompida naquele ponto. O resultado será uma lista com tamtos elementos quantos forem o número de iterações feitas. Cada elemento na lista de resultado é em si mesmo outra lista comh m+1 elementos: o valor da variável independente, seguido pelos valores das variáveis dependentes correspondentes àquele ponto.

Função: staircase (F, y0, n, ...opções...); ¶

  Desenha um diagrama em escada para a seqüência definida pela relação de recorrência

              y(n+1) = F(y(n))

  A interpretação e os valores permitidos dos parâmetros de entrada são os mesmos que para a função `evolution`. Um diagrama em escada consiste de um gráfico da função F(y), juntamente com a linha G(y) `=` y. Um segmento vertical é desenhado a partir das point (y0, y0) on that line until the point where it intersecções com a função F. A partir daquele ponto um segmento horizontal é desenhado até encontrar o ponto (y1, y1) sobre a linha, e o procedimento é repetido n vezes até que o ponto (yn, yn) é encontrado.

opções

Cada opção é uma lista de dois ou mais itens. O primeiro item é o nome da opção, e os restantes compreendem os argumentos para a opção.

As opções aceitas pelas funções `evolution`, `evolution2d`, `staircase`, `orbits`, `ifs` e `chaosgame` são as mesmas opções para `plot2d`. Adicionalmente para aquelas opções, `orbits` aceita a opção extra pixels que escolhe o número máximo de pontos diferentes que irão ser representados na direção vertical.

Exemplos

Representação gráfica e diagrama em escada para a seqüência: 2, cos(2), cos(cos(2)),...

    (%i1) load("dynamics")$

    (%i2) evolution(cos(y), 2, 11);

    (%i3) staircase(cos(y), 1, 11, [y, 0, 1.2]);

Se seu sistema for lento, você deverá reduzir o número de iterações nos seguintes exemplos. E se os pontos parecerem muito pequenos no seu monitor, você pode querer tentar um estilo diferente, tal como `[`style,`[`points,0.8`]]`.

Diagrama de órbitas para o mapa quadrático, com um parâmetro a.

            x(n+1) = a + x(n)^2

    (%i4) orbits(x^2+a, 0, 50, 200, [a, -2, 0.25], [style, dots]);

Para ampliar a região em torno da bifurcação menor perto de x `=` -1.25 use:

    (%i5) orbits(x+y^2, 0, 100, 400, [a,-1,-1.53], [x,-1.6,-0.8],
                 [nticks, 400], [style,dots]);

Evolução de um sistemma bidimensional que leva a um fractal:

    (%i6) f: 0.6*x*(1+2*x)+0.8*y*(x-1)-y^2-0.9$

    (%i7) g: 0.1*x*(1-6*x+4*y)+0.1*y*(1+9*y)-0.4$

    (%i8) evolution2d([f,g], [x,y], [-0.5,0], 50000, [style,dots]);

E uma ampliação de uma pequena regial naquele fractal:

    (%i9) evolution2d([f,g], [x,y], [-0.5,0], 300000, [x,-0.8,-0.6],
                      [y,-0.4,-0.2], [style, dots]);

Um gráfico do triângulo de Sierpinsky, obtido com o jogo do caos:

    (%i9) chaosgame([[0, 0], [1, 0], [0.5, sqrt(3)/2]], [0.1, 0.1], 1/2,
                     30000, [style, dots]);

A samambaia de Barnsley, obtida com um Sistema de Funções Iteradas:

    (%i10) a1: matrix([0.85,0.04],[-0.04,0.85])$

    (%i11) a2: matrix([0.2,-0.26],[0.23,0.22])$

    (%i12) a3: matrix([-0.15,0.28],[0.26,0.24])$

    (%i13) a4: matrix([0,0],[0,0.16])$

    (%i14) p1: [0,1.6]$

    (%i15) p2: [0,1.6]$

    (%i16) p3: [0,0.44]$

    (%i17) p4: [0,0]$

    (%i18) w: [85,92,99,100]$

    (%i19) ifs(w, [a1,a2,a3,a4], [p1,p2,p3,p4], [5,0], 50000, [style,dots]);

Para resolver numericamente a equação diferencial

              dx/dt = t - x^2

Com valor inicial x(t=0) = 1, no intervalo de `t` de 0 a 8 e com incrementos de 0.1 para `t`, use:

    (%i20) results: rk(t-x^2,x,1,[t,0,8,0.1])$

os resultados serão salvos na lista de resultados.

Para resolver numericamente o sistema:

            dx/dt = 4-x^2-4*y^2     dy/dt = y^2-x^2+1

para `t` entre 0 e 4, e com valores de -1.25 e 0.75 para x e y em t=0:

    (%i21) sol: rk([4-x^2-4*y^2,y^2-x^2+1],[x,y],[-1.25,0.75],[t,0,4,0.02])$