Introducedilhaão a 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.

Definicedilhaões para dynamics
==============================

 -- 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: julia (X, Y, ...OPÇÕES...)

     Cria um ficheiro gráfico com a representação do conjunto de Julia do número complexo (X + i Y). Os parâmetros X e Y deverão ser reais. O ficheiro é criado no directório actual ou no directório do utilizador, usando o formato gráfico XPM. O programa pode demorar vários segundos a ser executado e quando terminar imprime uma mensagem com o nome do ficheiro criado.

     Atribuem-se diferentes cores aos pontos que não pertencem ao conjunto de Julia, segundo o número de iterações que demorar a sequência que começa nesse ponto, a sair fora do círculo de convergência com raio 2. O número máximo de iterações define-se com a opção LEVELS; após concluído esse número de iterações, se a sequência estiver ainda dentro do círculo de convergência, o ponto será colorido com a cor definida pela opção COLOR.

     Todas as cores usadas para os pontos que não pertencerem ao conjunto de Julia terão os mesmos valores de saturação (SATURATION) e valor (VALUE), mas com diferentes ângulos de tonalidade, distribuídos uniformemente no intervalo entre HUE e (HUE + HUERANGE).

     Podem ser dadas à função uma sequência de opções. A lista de possíveis opções aparece numa secção mais para a frente.

 -- Função: mandelbrot (OPÇÕES)

     Cria um ficheiro gráfico com a representação do conjunto de Mandelbrot. O ficheiro é criado no directório actual ou no directório do utilizador, usando o formato gráfico XPM. O programa pode demorar vários segundos a ser executado e quando terminar imprime uma mensagem com o nome do ficheiro criado.

     Atribuem-se diferentes cores aos pontos que não pertencem ao conjunto de Mandelbrot, segundo o número de iterações que demorar a sequência gerada por esse ponto a sair fora do círculo de convergência com raio 2. O número máximo de iterações define-se com a opção LEVELS; após concluído esse número de iterações, se a sequência estiver ainda dentro do círculo de convergência, o ponto será colorido com a cor definida pela opção COLOR.

     Todas as cores usadas para os pontos que não pertencerem ao conjunto de Mandlebrot terão os mesmos valores de saturação (SATURATION) e valor (VALUE), mas com diferentes ângulos de tonalidade, distribuídos uniformemente no intervalo entre HUE e (HUE + HUERANGE).

     Podem ser dadas à função uma sequência de opções. A lista de possíveis opções aparece numa secção mais para a frente.

 -- 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 julia e mandelbrot são as seguintes:

  * size admite um ou dois argumentos. Se aparecer um só argumento, a largura e a altura do ficheiro gráfico criado serão iguais a esse valor em pixels. Se forem dados dois argumentos, esses dois valores serão usados para a largura e a altura. O valor por omissão é 400 pixels para a largura e para a altura. Se os dois valores não forem iguais, o conjunto aparecerá alongado.

  * levels define o número máximo de iterações, que é também o número de cores usado para os pontos que nõ pertencem ao conjunto. O valor por omissão é 12; valores mais elevados implicam tempos de processamento mais elevados.

  * huerange define o intervalo de ângulos usados para a tonalidade dos pontos que nõ pertençam ao conjunto. O valor por omissão é 360, que faz com que as cores usadas abranjam todas as tonalidades. Valores superiores a 360 implicam repetição de algumas tonalidades, e pode usar-se valores negativos para que o ângulo de tonalidade seja menor à medida que o número de iterações aumentar.

  * hue define a tonalidade, em graus, da primeira cor usada para representar os pontos que não pertencem ao conjunto.  O seu valor por omissão é 300 graus, que corresponde à cor magenta; a cor correspondente a outros valores padrão é vermelho 0, laranja 45, amarelo 60, verde 120, azul ciano 180 e azul 240. Consulte também a opção HUERANGE.

  * saturation define o nível de saturação das cores usadas para os pontos que não pertençam ao conjunto. Deverá ser um valor entre 0 e 1. O valor por omissão é 0.46.

  * value define o valor das cores usadas para pontos que não pertençam ao conjunto. Deverá ser um número entre 0 e 1; quanto maior for, mais intensas serão as cores. O seu valor por omissão é 0.96.

  * color deverá ter três parâmetros que definem a tonalidade, saturação e valor da cor que será usada para os pontos do conjunto. O valor por omissão é 0 para os três parâmetros, que corresponde à cor preta. Veja a explicação sobre os valores aceites nas opções HUE, SATURATION e VALUE.

  * center deberá ter dois parâmetros reais que definem as coordenadas, no plano complexo, do ponto no centro da região representada. O valor por omissão é 0 para as duas coordenadas (a origem).

  * radius é o raio do maior círculo que cabe dentro da região quadrada que será representada. O valor por omissão é 2.

  * nomeficheiro dá o nome do ficheiro onde será armazenado o gráfico produzido. A esse nome será acrescentada a terminação .xpm. Se o ficheiro já existir, será substituído pelo ficheiro produzido pela função. O valor por omissão é julia para o conjunto de Julia e mandelbrot para o conjunto de Mandelbrot.

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 criar um ficheiro dinamica9.xpm com a representação gráfica do conjunto de Mandelbrot, com 12 colores, use o comando:

     mandelbrot([nomeficheiro,"dinamica9"])$

e o conjunto de Julia do número (-0.55 + i 0.6) pode ser obtido com:

     julia(-0.55, 0.6, [levels, 36], [center, 0, 0.6], [radius, 0.3],
           [hue, 240], [huerange, -180], [nomeficheiro, "dinamica10"])$

o gráfico guardar-se-á no ficheiro dinamica10.xpm e apresentará a regiõ desde -0.3 até 0.3 na direcção x, e desde 0.3 até 0.9 na direcção y. Serão usadas 36 cores, començando com azul e terminando com amarelo.

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])$