[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 47. dynamics

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 47.1 O pacote dynamics

O pacote adicional `dynamics` inclui várias funções para criar diversas representações gráficas de sistemas dinâmicos e fractais, para além duma implementaçõ do método numérico de Runge-Kutta de quarta ordem, para resolver sistemas de equações diferenciais.

Para usar as funções neste pacote será necessário primeiro que tudo carregá-lo com `load("dynamics")`; as funções que criam gráficos precisam que o Xmaxima esteja instalado.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 47.2 Análise gráfica de sistemas dinâmicos discretos

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

  Usa o método designado de jogo do caos, para produzir fractais: desenha-se um ponto inicial (x0, y0) e logo escolhe-se aleatoriamente um dos m pontos `[`x1, y1`]`...`[`xm, ym`]`. A seguir, desenha-se um novo ponto que estará no segmento entre o último ponto desenhado e o ponto que se acabou de seleccionar aleatoriamente, a uma distância do ponto seleccionado que será b vezes o comprimento do segmento. O processo repete-se n vezes.

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

  Desenha n+1 pontos num gráfico bidimensional (série de tempo), onde as coordenadas horizontais dos pontos são os números inteiros 0, 1, 2, ..., n, e as coordenadas verticais são os valores y(n) correspondentes, obtidos a partir da relação de recorrência

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

  Com valor inicial y(0) igual a y0. F deverá ser uma expressão que dependa unicamente da variável y (e não de n), y0 deverá ser um número real e n um número inteiro positivo.

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

  Mostra, num gráfico bidimensional, os primeiros n+1 pontos da sucessão definida a partir do sistema dinâmico discreto com relações de recorrência:

              x(n+1) = F(x(n), y(n))    y(n+1) = G(x(n), y(n))

  Com valores iniciais x0 e y0. F e G deverão ser duas expressões que dependam unicamente de x e y.

Função: ifs (`[`r1,...,rm`]`,`[`A1,...,Am`]`, `[[`x1,y1`]`...`[`xm, ym`]]`, `[`x0,y0`]`,

  n, ...opções...);

  Usa o método do Sistema de Funções Iteradas (IFS, em inglês Iterated Function System). Esse método é semelhante ao método descrito na função `chaosgame`, mas em vez de aproximar o último ponto para ponto seleccionado aleatoriamente, as duas coordenadas do último ponto multiplicam-se por uma matriz 2 por 2 Ai correspondente ao ponto que tenha sido escolhido aleatoriamente.

  A selecção aleatória de um dos m pontos atractivos pode se realizada com uma função de probabilidade não uniforme, definida com os pesos r1,...,rm. Pesos esses que deverão ser dados em forma acumulada; por exemplo, se quiser usar 3 pontos com probabilidades 0.2, 0.5 e 0.3, os pesos r1, r2 e r3 poderiam ser 2, 7 e 10, ou qualquer outro grupo de números que estejam na mesma proporção.

Função: orbits (F, y0, n1, n2, [x, x0, xf, xstep], ...opções...);

  Desenha o diagrama de órbitas duma família de sistemas dinâmicos discretos unidimensionais, com um parâmetro x; esse tipo de diagrama usa-se para mostrar as bifurcações dum sistema discreto unidimensional.

  A função F(y) define uma sequência que começa com um valor inicial y0, igual que no caso da função `evolution`, mas neste caso a função também dependerá do parâmetro x, o qual terá valores compreendidos no intervalo de x0 a xf, com incrementos xstep. Cada valor usado para o parâmetro x apresenta-se no eixo horizontal. No eixo vertical apresentam-se n2 valores da sucessão y(n1+1),..., y(n1+n2+1), obtidos após deixá-la evoluir durante n1 iterações iniciais.

Função: rk (EDO, var, inicial, dominio)
Função: rk ([EDO1,...,EDOm], [v1,...,vm], [inic1,...,inicm], domínio)

  A primeira forma usa-se para resolver numericamente uma equação diferencial ordinária de primeira ordem (EDO), e a segunda forma resolve numericamente um sistema de m dessas equações, usando o método de Runge-Kutta de quarta ordem. var representa a variável dependente. EDO deverá ser uma expressão que dependa unicamente das variáveis independente e dependente, e define a derivada da variável dependente em função da variável independente.

  A variável independente representa-se com domínio, que deverá ser uma lista com quatro elementos, como, por exemplo:

      [t, 0, 10, 0.1]

  o primeiro elemento da lista identifica a variável independente, os segundo e terceiro elementos são os valores inicial e final para essa variável, e o último elemento dá o valor dos incrementos que deverão ser usados dentro desse intervalo.

  Se se estiverem a resolver m equações, deverá haver m variáveis dependentes v1, v2, ..., vm. Os valores iniciais para essas variáveis serão inic1, inic2, ..., inicm. Continuará existindo apenas uma variável independente, definida pela lista domain, tal como no caso anterior. EDO1, ..., EDOm são as expressões que definem as derivadas de cada uma das variáveis dependentes, em função da variável independente. As únicas variáveis que podem aparecer em cada uma dessas expressões são a variável independente e qualquer uma das variáveis dependentes. É importante que as derivadas EDO1, ..., EDOm sejam colocadas na lista na mesma ordem em que forem agrupadas as variáveis dependentes; por exemplo, o terceiro elemento da lista será interpretado como a derivada da terceira variável dependente.

  O programa tenta integrar as equações desde o valor inicial da variável independente, até o valor final, usando incrementos fixos. Se em algum passo uma das variáveis dependentes atingir um valor absoluto muito elevado, a integração será interrompida nesse ponto. O resultado será uma lista com um número de elementos igual ao número de iterações realizadas. Cada elemento na lista de resultados é também uma lista com m+1 elementos: o valor da variável independente, seguido dos valores das variáveis dependentes nesse ponto.

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

  Desenha um diagrama de degraus (ou diagrama de teia de aranha) para a sucessão definida pela equação de recorrência

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

  A interpretação e valores permitidos dos parâmetros de entrada é igual que para a função `evolution`. Um diagrama de degraus consiste num gráfico da função F(y), junto com a recta G(y) `=` y. Começa-se por desenhar um segmento vertical desde o ponto (y0, y0) na recta, até o ponto de intersecção com a função F. A seguir, desde esse ponto desenha-se um segmento horizontal até o ponto de intersecção com a recta, (y1, y1); o processo repete-se n vezes até alcançar o ponto (yn, yn).

Opções

Cada opção é uma lista com dois ou mais elementos. O primeiro elemento na lista é o nome da opção e os restantes são os argumentos para essa opção.

As opções aceites pelas funções evolution, evolution2, staircase, orbits, ifs e chaosgame são as seguintes:

- domain especifica os valores mínimo y máximo da variável independente para o gráfico da função F representada por `staircase`.
- pointsize define o raio de cada ponto desenhado, em unidades de pontos. O valor por omissão é 1.
- xaxislabel é o nome que será dado ao eixo horizontal.
- xcenter é a coordenada x do ponto que deverá aparecer no centro do gráfico. Esta opção não é usada pela função `orbits`.
- xradius é metade do comprimento do intervalo de valores de x que serão representados. Esta opção não é usada pela função `orbits`.
- yaxislabel é o nome que será dado ao eixo vertical.
- ycenter é a coordenada y do ponto que deverá aparecer no centro do gráfico.
- yradius é metade do comprimento do intervalo de valores de y que serão representados.

As opções aceites pelos programas juli Exemplos

Representação gráfica e diagrama de degraus da sequência: 2, cos(2), cos(cos(2)),...

    (%i1) load("dynamics")$
    (%i2) evolution(cos(y), 2, 11, [yaxislabel, "y"], [xaxislabel,"n"]);
    (%i3) staircase(cos(y), 1, 11, [domain, 0, 1.2]);

Se o seu processador for lento, terá que reduzir o número de iterações usado nos exemplos seguintes. E o valor de pointsize que dá os melhores resultados dependerá do monitor e da resolução usada. Terá que experimentar com diferentes valores.

Diagrama de órbitas para o mapa quadrático

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

    (%i4) orbits(y^2+x, 0, 50, 200, [x, -2, 0.25, 0.01], [pointsize, 0.9]);

Para ampliar a região à volta da bifurcação na parte de baixo, perto de x `=` -1.25, use o comando:

    (%i5) orbits(x+y^2, 0, 100, 400, [x,-1,-1.53,-0.001], [pointsize,0.9],
                 [ycenter,-1.2], [yradius,0.4]);

Evolução dum sistema em duas dimensões, que conduz 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],[-0.5,0],50000,[pointsize,0.7]);

E uma ampliação de uma pequena região no fractal:

    (%i9) evolution2d([f,g],[-0.5,0],300000,[pointsize,0.7], [xcenter,-0.7],
                      [ycenter,-0.3],[xradius,0.1],[yradius,0.1]);

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, [pointsize,0.7]);

O feto de Barnsley, obtido com o 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,[pointsize,0.9]);

Para resolver numericamente a equação diferencial

              dx/dt = t - x^2

Com valor inicial x(t=0) = 1, no intervalo de t desde 0 até 8, e com incrementos de 0.1, usa-se:

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

os resultados ficarão armazenados na lista 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, com valores iniciais -1.25 e 0.75 para (x, 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])$

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 47.3 Visualização usando VTK

A função scene cria imagens a três dimensões e animações, usando o software Visualization ToolKit (VTK). Para poder usar essa função é necessário ter Xmaxima e VTK instalados no sistema (incluindo a libraria para utilizar VTK desde TCL, que pode vir num pacote separado em alguns sistemas).

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Setembro, 27 2018 using texi2html 1.76.