Olá a todos, aqui é o Jonathan.
Hoje, mostrarei um exemplo de
como se deve proceder para fazer sua própria célula automata elementar
aqui referida como "ECA"
no NetLogo.
Este exercício, em particular, nos pede para
"homebrew" um assíncrono ECA
O qual você verá acontecer quase naturalmente neste programa
uma vez que o NetLogo, por definição, gosta de chamar agentes em ordem aleatória
Tudo bem... Então
como foi visto nesta unidade,
ECAS, sendo unidimensionais,
são simuladas linha por linha,
uma linha por vez.
O primeiro intervalo de tempo é simulado na linha do topo.
O segundo intervalo de tempo ocorre na segunda linha.
A terceira repetição na terceira linha,
etc, etc...
Logo, isto pode nos convir para configurar o sistema de coordenadas
de certa maneira a facilitar esta lógica.
Aqui Note que eu defini a origem no topo,
assim a primeira linha conta como coordenada "py" de zero
e faz a contagem regressiva menos um, menos dois, menos três,
e assim por diante.
Devido ao início no canto esquerdo do topo
os inteiros da coordenada "px" também podem ser (inaudível) contadas
a partir de zero, um, dois, três, etc
O que também pode ser legal caso mais tarde você decida
expandir a largura das linhas.
Agora, para as grandes questões
Você quer perguntar:
Quais são as funcionalidades essenciais do modelo ECA?
(?) ou automatas são feitas por células, é claro,
as quais nos códigos do NetLogo são os patches.
As principais propriedades dos patches nos ECAs
são os estados atuais, nos quais eles tem zero ou um,
e configurações da vizinhança,
usadas para determinar o subsequente estado das células
Outra importante funcionalidade do modelo são as regras,
as quais, como você sabe,
é simplesmente a lista dos estados revelando as células
quais vizinhanças produzem quais estados.
Como nós temos visto das diversas aulas Wolfram
diferentes regras podem produzir comportamentos radicalmente diferentes
em maior escala,
enquanto células individuais podem ter seus próprios estados,
e perceber diferentes vizinhanças.
O conjunto de regras em si não é específico para células individuais,
mas sim, o modelo como um todo.
Logo, eu listo-os como uma variável global.
Nós também não queremos esquecer os procedimentos obrigatórios "Setup" e "Go"
para fazer o modelo rodar e tal.
Então, estou colocando isto agora.
Para o "Setup", geralmente é bom praticar para escrever
"clear-all",
uma vez que queremos estar aptos a reiniciar estes modelos e
replicar os resultados independentemente,
sem interferência de rodadas anteriores.
Particularmente à forma que configurei esse modelo,
estou também redefinindo tais "ticks" de inicialização
já que os ticks podem ser úteis para manter o controle
de qual passo de tempo estamos
Finalmente, queremos que os patches se auto-ordenem
para uma configuração aleatória inicial
Então, vou pedir aos patches
embora com um qualificador específico,
patches com pycor igual a zero, iniciar com,
já que, como você sabe,
queremos as células na linha superior no começo.
Agora que estas células de patch parecem ter
estes estados aleatoriamente configurados
Relembre que cada célula pode estar em um dos dois estados: 0 ou 1
Então, para nossas intenções atuais
queremos uma variável de decisora aleatória
com igual chance de retornar
um estado zero ou um nas células
Eu vou chamar esse aqui de "draw" [virada]
Só porque gosto da analogia de virar cartas [draw cards]
Embora o nome não seja realmente importante aqui
Então, seja a variável temporária, "draw" ser um float aleatório 1
o qual é apenas qualquer quantidade aleatória entre 0 e 1
que o computador pode conceber
Então, para este "draw" aleatório
podemos dizer que, se um número escolhido entre 0 e 1
está abaixo de 0.5, que como você sabe, é uma chance de 50%
então coloque "estado" zero
você quer uma condição "else" ali também,
então se o número "draw" acaba sendo maior que .5,
o que ocorre nos outros 50% das vezes
então coloque "estado" em 1, ao invés
Mantenha em mente que "estado" é uma variável que é alocada dentro do patch,
que atualmente não é visível ao usuário humano
Então queremos marcar
por meio de uma nova função de procedimento chamada changeColor [mudeCor]
a qual é bastante direta.
Então, para mudar a cor,
pode ser conveniente usar outra sentença "if else"
se o estado da célula é zero
temos uma cor.
De outra forma, se é um estado diferente,
logo 1,
temos uma cor diferente
para distinguir estas células, uma da outra
Além disso, é óbvio pelo gosto pessoal
quais cores queremos usar
Eu vou dizer que células brancas são zeros,
que é, coloque pcolor em branco, se o estado do patch é zero.
Do contrário, se o estado é um, vamos fazer ficar verde, ao invés.
Eu pessoalmente gosto de usar estas cores mais claras para isso,
principalmente porque nos ajuda a separar as linhas das células que estão prontas
das mais escuras que não estão ainda.
Com isso, fechamos o procedimento, e checamos que nada está quebrado ainda.
Eu vou colocar uns botões, só para testar o modelo até então
e ver se estamos no caminho certo.
Temos um botão Setup para rodar nossos procedimentos de configuração
e um botão Go [Vai]
o botão Go não deve fazer nada, ainda
mas, eventualmente, vai precisar estar lá
Configurando o modelo agora.
Veja, então agora temos metade das células brancas e metade verde na linha inicial
refletindo nossa chance de 50% das células se tornarem brancas,
e 50% de chance de ser verde
em uma sequência aleatória.
Condições iniciais são reconfiguradas cada vez que usamos este procedimento,
que você vê,
são completamente aleatórias, cada vez,
mas, grosso modo, você terá 50-50 verdes e brancas
em média.
Go, surpresa, não faz nada ainda, porque eu não coloquei nada
como retorno no procedimento Go, ainda.
Próxima coisa
queremos que estas células interajam com e respondam as células ao redor
e mudar de acordo com regras específicas
em relação a configuração da vizinhança
Certo?
Até agora, eu ainda não decidi quais são os conjuntos de regras
Então só para rapidamente ver isso em ação,
eu vou inicializar o modelo por agoram
com um de meu conjunto de regras favorito
Esta é uma daquelas regras com propriedades interessantes com,
características de um comportamento que são, ordenados, ainda assim, caóticos de, você sabe
estruturas complexas.
Com este conjunto de regras,
como um place-holder temporário,
vamos especificar o procedimento Go,
quando as regras CA começam a agir,
Lembre-se, as regras ditam qual estado
as células mudam para cada configuração da vizinhança
o que requer que cada célula patch detecte o
estado de seus dois vizinhos imediatos
assim como seu próprio estado.
Indo para os patches superiores agora,
vamos ter cada atualização do patch
e gravar as configurações da vizinhança.
Isto é, os 3 estados de combinação que inclui o vizinho da esquerda da célula,
ela mesma e seu vizinho da direita.
Já que vizinhança é definida como uma
combinação de estados de célula,
queremos criar uma lista,
a qual é apenas outro vetor.
Neste vetor, você quer incluir como primeira entrada,
o estado binário da célula da esquerda.
Então um pouco de vocabulário NetLogo para vocês, pessoal.
"patch-at" se refere ao patch de célula
nuima posição relativa à celula atual que está a chamando.
O primeiro número na distância x
para esquerda, ou direita.
O segundo número, distância y,
para cima ou para baixo.
Então patch-at -1 0
se refere à celula imediatamente à esquerda da célula atual.
Agora, adicione um estado no patch atual
chamando este procedimento
o qual é um "state" por padrão
e, finalmente, o estado na célula da direita,
patch-at 1 0
porque agora estamos olhando para a direita.
Com isso, temos um bloco de comandos convincente
o qual eu vou fechar, por agora.
Whoops, falha minha.
Então, para recapitular,
cada célula está olhando para sua esquerda e direita
e para si mesma,
para o conjunto atual de estados
atualizando a cada passo de tempo
As células estão, portanto, apenas armazenando informação cada vez
não atualmente fazendo nada com isso,
e mudando seus estados de acordo.
Portanto, o comportamento aparente do modelo não mudou ainda.
Como você pode ver, clicando estes botões.
Obviamente, existem diversos fatores aqui que precisam ser feitos para
o modelo rodar apropriadamente.
Por exemplo, não podemos ver a manifestação
do novo estado da célula
sem um procedimento changeColor
Porém, mais fundamentalmente
Está faltando atualmente uma aplicação das regras no modelo
quando eles, supostamente, direcionam o comportamento da célula
De fato,
o vetor de regras inicial que eu escolhi
não está realmente fazendo nada atualmente.
Então precisamos de um jeito que as células se refiram a estas regras do vetor.
Agora, existem muitos, muitos jeitos de programar esta parte,
E, como tenho certeza que cientistas da computação entre vocês vão rapidamente perceber
o que eu vou mostrar é, em hipótese alguma, o mais eficiente.
Mas alguns de vocês vão, ao menos, por sorte, apreciar
a simplicidade sintática de minha abordagem aqui.