Caos em Sistemas dinâmicos: Diagrama de Bifurgação do Mapa Logístico

Edward Lorenz, em 1963, estudando a previsão do tempo por um modelo dinâmico definido por poucas e simples equações diferenciais, fez uma descoberta que surpreendeu o mundo. Seu modelo seguia um padrão, que não se encaixava nas categorias possíveis de sistemas dinâmicos da época, exibindo um comportamento bastante complexo. Sistemas como o de Lorenz são denominados “caótico-determinísticos” ou seja, embora apresentem um comportamento aperiódico e imprevisível, a sua dinâmica é governada por equações diferenciais ou equações diferenças determinísticas simples.

Um bom exemplo de um sistema que pode gerar padrões complexos apesar de ter uma representação simples é o chamado mapa logístico, considerado como sistema dinâmico exemplar, por sua importância histórica e por sua natureza didática, e que não é mais do que um sistema unidimensional definido por,

x(n+1)=μ.x(n).[1-x(n)],

onde à medida que se vai mudando o valor da constante μ, também se vai mudando o comportamento do sistema. A seguir vamos analisar alguns casos, para diferentes valores de μ, dada a condição inicial Xo=0.55, sendo os espaços de fase apresentados, aqueles que fazem corresponder x(n+1) a x(n).

Nesta postagem, o nosso objetivo, além de apresentar este importante tema da Física, é o de fornecer exemplos da interatividade entre as linguagem de programação C/C++ e o aplicativo gnuplot, que juntos minimizam as tarefas de uma pesquisa. 

Informações sobre o Código Fonte em C/C++ para gerar o mapa logístico

O código fonte em C/C++ gera o arquivo de dados de nome "mapa_logistico.txt" e o arquivo-script do gnuplot de nome "mapa_logistico.plt", e em seguida chama o script do gnuplot através da função system( ), e o resultado é o gráfico gerado em formato .jpg no seu diretório corrente.

/*  MAPA LOGISTICO */

#include <stdio.h>
#include <stdlib.h>

FILE *fp;

static char nome[]="mapa_logistico.txt";

void scrip_gnuplot(char str[25], float m)
{
    fp=fopen("mapa_logistico.plt", "w");
   
    fprintf(fp, "reset\n");
    fprintf(fp, "set title \"Mapa Logístico para mi=%.2f\" \n", m);
    fprintf(fp, "set xlabel \"Numero de Iteracoes (N)\" \n");
    fprintf(fp, "set ylabel \"Valor das Iteracoes (X)\" \n");
    fprintf(fp, "set term jpeg \n" );
    fprintf(fp, "set output \"Mapa_Logistico.jpg\" \n");
    fprintf(fp, "plot \'%s\' t \"mapa x versus n\" w lp ls 7 lc 3 lw 2\n", str);
    fprintf(fp, "set output; set term wxt\" \n");
    fprintf(fp, "replot \n");
    fprintf(fp, "pause -1 \"Continuar?\" ");
    fclose(fp);
}

int main(void)
{
int k;
float n, mi;
double x;

    fp=fopen(nome,"w");
    // definindo os valores iniciais de mi, x e n
    mi = 4.0;  
    x = 0.8;
    n = 1.0;
    for(k=1; k<=100; k++)
    {
        n=n+1.0;
        x = mi*x*(1.0-x);
        fprintf(fp,"%.1f \t %lf\n", n, x);
    }
    fclose(fp);

    scrip_gnuplot(nome, mi);
   
    system("gnuplot mapa_logistico.plt");
    return 0;
}

RESULTADOS OBTIDOS

Parte (I): Iteração do mapa logístico com o código fonte acima no intuito de observar o atrator para diferentes valores de μ. 

 

 

 

 

Informações do Código Fonte em C/C++ para gerar o diagrama de bifurgação para o mapa logístico

Este código fonte em C/C++ gera o arquivo de dados de nome "diagrama.txt" e o arquivo-script do gnuplot de nome "diagrama.plt", e em seguida chama o script do gnuplot através da função system( ), e o resultado é o gráfico gerado em formato .jpg no seu diretório corrente.

/*  DIAGRAMA DE BIFURGAÇÃO DO MAPA LOGISTICO */

#include <stdio.h>
#include <stdlib.h>

FILE *fp;
static char nome[]="diagrama.txt";
void scrip_gnuplot(char str[25])
{
    fp=fopen("diagrama.plt", "w");
   
    fprintf(fp, "reset\n");
    fprintf(fp, "set samples 500\n");
    fprintf(fp, "set xr[1.9:4.1]\n");
    fprintf(fp, "set yr[0:1.1]\n");
    fprintf(fp, "set title \"Diagrama do Mapa Logistico\" \n");
    fprintf(fp, "set xlabel \"Coeficiente mi\" \n");
    fprintf(fp, "set ylabel \"Atrator X\" \n");
    fprintf(fp, "set term jpeg \n" );
    fprintf(fp, "set output \"Diagrama.jpg\" \n");
    fprintf(fp, "plot \'%s\' notitle w p ls 1 lw 0\n", str);
    fprintf(fp, "set output; set term wxt\" \n");
    fprintf(fp, "replot \n");
    fprintf(fp, "pause -1 \"Continuar?\" ");
    fclose(fp);
}

int main(void)
{
int k, n;
float mi;
double x;

    fp=fopen(nome,"w");
    // definindo o valoar inicial de mi
    mi =  2.0;
    for(k=1; k<=500; k++)
    {
        mi = mi + 0.004;
        x = 0.8;
        for(n=1; n<=1000; n++)
        {
            x = mi*x*(1-x);
            if (n>500)
            {
                fprintf(fp,"%f \t %lf\n", mi, x);
            }
        }
    }   
    fclose(fp);
    scrip_gnuplot(nome);
    system("gnuplot diagrama.plt");
    return 0;
}
Parte (II):  Construção do diagrama do mapa logístico a partir do código acima para observar a rota de duplicação de período.

Neste diagrama estão representados apenas os pontos referentes aos atratores dos mapas logísticos, para diferentes valores de μ. Não estão representados os pontos do transiente!
Vemos que o atrator foi ficando cada vez mais complicado: para os valores de μ entre 2,0 e aproximadamente 2,9 é do tipo ponto fixo, na primeira bifurcação, acima de 3,0, é duplo ciclo até aproximadamente 3,4, onde já passam a ser 4 pontos de repetição, depois 8 e assim por diante... A cada bifurcação ocorre uma duplicação de período até o sistema entrar em regime caótico. Por isso essa rota para o Caos ficou conhecida como rota de duplicação de período.

Para maiores informações sobre a teoria dos caos, o link a seguir é uma ótima fonte de pesquisa: http://www.geocities.ws/projeto_caos_ufg/

Interação entre a Linguagem C e o Aplicativo gnuplot: O Mapa de Hénon

         O mapa de Hénon, proposto em 1976 pelo astrônomo francês Michel Hénon como um modelo para descrever a seção de Poincaré do sistema de Lorentz a tempo contínuo, é governado por três equações diferenciais ordinárias não lineares de primeira ordem.

         O mapa de Hénon é definido pelo seguinte conjunto de equações:



                       x(t+1) = a - x(t)² + b.y(t)          e            y(t+1)=x(t).

onde a é o parâmetro de não-linearidade, b o parâmetro de dissipação do sistema, x(t) e y(t) são variáveis dinâmicas, e t = 0, 1, 2, ...., é o tempo discreto. É um dos exemplos mais estudados de sistemas dinâmicos pois, apesar de ser descrito por um conjunto de equações bastante simples, o mapa de Hénon apresenta uma dinâmica extremamente rica.  Por exemplo, para os valores dos parâmetros a=1.4 e b=0.3, que foram os valores utilizados por M. Hénon em seu trabalho, o mapa apresenta um comportamento caótico. No entanto, para outros conjuntos de valores de parâmetros, o mapa de Hénon pode convergir para uma órbita periódica, caótica ou mesmo divergir. 

Neste post, temos dois objetivos, o primeiro é o de apresentar o mapa de Hénon para três conjuntos de valores para os parâmetros a e b, conforme as figuras abaixo, e o segundo é o de apresentar a interação entre a linguagem de programação C/C++ com o aplicativo gnuplot, que juntos otimizam bastante as tarefas do pesquisador. 

O código fonte em C gera o arquivo de dados de nome "mapa.txt" e o arquivo-script do gnuplot de nome "mapa.plt", e em seguida chama o script do gnuplot através da função system( ), e o resultado é o gráfico gerado em formato .jpeg no seu diretório corrente automáticamente. 

Código fonte em C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define a 1.4         // Parâmetros do Mapa de Hénon
#define b 0.3          // (a, b) = (1.2,0.2); (1.3,0.3) e (1.4,0.3)
#define T 1000        // Tempo total discreto

double x[T], y[T];
FILE *fp;

static char nome[]="mapa.txt";

void scrip_gnuplot(char str[20])
{
    fp=fopen("mapa.plt", "w");
   
    fprintf(fp, "reset\n");
    fprintf(fp, "set title \"Mapa de Hénon para a=%.2f, b=%.2f \" \n", a, b);
    fprintf(fp, "set xl \"Xt+1\" \n");
    fprintf(fp, "set yl \"Yt+1\" \n");
    fprintf(fp, "set term jpeg \n" );
    fprintf(fp, "set output \"Mapa_Henon.jpg\" \n");
    fprintf(fp, "plot \'%s\' u ($1):($2) t \'%s\' w p ls 7 lc 3 \n", str,str);
    fprintf(fp, "set output; set term wxt\" \n");
    fprintf(fp, "replot \n");
    fprintf(fp, "pause -1 \"Continuar?\" ");
    fclose(fp);
}

int main()
{
int t;

    fp=fopen(nome,"w");

    x[0]=1;
    y[0]=1;
    for(t=0;t<=T;t++)
    {
        x[t+1]=a-pow(x[t],2)+b*y[t];
        y[t+1]=x[t];
        fprintf(fp,"%lf %15lf \n",x[t+1],y[t+1]);
    }
    fclose(fp);

    scrip_gnuplot(nome);
    system("gnuplot mapa.plt");
    return 0;
}
// --------------------------------------------------------------------

Mapa de Hénon

Animação com gnuplot: Satélite em órbita

Satélite em órbita em torno da Terra

Caros leitores, o problema do satélite em órbita é aqui construído segundo os comandos básicos do aplicativo gnuplot.  Os objetos presentes na animação (circle, arrow, e label) são implementados facilmente. As equações físicas utilizadas são as equações trabalhadas nas aulas de Física.

Animação com gnuplot: Pêndulo Simples

Pêndulo Simples


Caros leitores, o problema do pêndulo simples é aqui construído segundo os comandos básicos do aplicativo gnuplot.  Os objetos presentes (circle, arrow e label) na animação são implementados facilmente.

Animação com gnuplot: Problema do Plano Inclinado

Plano Inclinado

Caros leitores, o problema do plano inclinado é aqui construído segundo os comandos básicos do aplicativo gnuplot.  A dificuldade maior está na construção do polígono que desce o plano inclinado. Os demais objetos (arrow, polygon, circle, label) são bastante simples.