Name: What are Cellular Automata?
Uploaded: 2020-03-28T16:54:21.000Z
Duration: 14 min 14 s
Description: Thousands of YouTube videos with English-Chinese subtitles! Now you can learn to understand native speakers, expand your vocabulary, and improve your pronunciation...

This week I created artificial life of the command.

Just look at how complicated and sophisticated this life is.

I've got clusters of individuals forming families and groups, fighting for resources and competing for space, that breeding and multiplying.

And occasionally you'll see them sending out a member of the family to go and interact with other clusters.

I am, of course, talking about the British mathematician John Conway's Game of Life, which is a class of cellular automatic.

Now you might think that a really complicated behavior like this would take several thousands of lines of code to implement.

And this is why cellular automatic really cool.

Spread it across a hugely parallel processing substrate, and the resulting emergent behavior can exhibit all sorts of really complicated phenomena.

This video will use Theo well, see consul game engine, and you can click the little link above to see more details about that.

But essentially all it does is wrap up the command prompt in a display buffer so I can draw to it easily.

To use the console game engine, you need to create a class that inherits from it and over right to methods which are our music.

I've called this class the game of life and in our in main function.

Now all we need to do is create an instance of the class the game of life class on Tell it what dimensions of the console we want.

So to start with, I'm going to use 1 60 characters across by 100.

Down on each character is going to be eight by eight pixels and then call the start function, which will then repeatedly call the unusual update function.

This album holds a particular special place in my heart.

There have been people programming John Conway's game of life for them now for a number of years.

I worked in academia, and I worked in a field where we developed a technology called cellular process for a raise.

These were highly parallel processing devices, and to test them, we would always run game of life because if we saw that it could ruin life, it could probably do all the other complicated things.

I'm not going to go into the history of game of life.

There's an excellent Wikipedia article that will do just that and we'll be using This article is a source of inspiration to try out different patterns.

The sheer amount of research into game of life is vast.

Mathematicians, Lovett computer scientists love it on people have proven that it's got all sorts of fantastic properties.

For example, it's quite possible to set up a pattern where the little critters will move around, implements a fully functional computer, a member of the patterns which could emulate circuits.

And people are using it for generating music and all sorts of interesting sequences.

But fundamentally, the whole phenomena stems from very simple rules, and I mean very simple rules.

And this is why it's such an interesting algorithm.

We call it emergent behavior out of such a simple rule set.

Well, the first thing you're going to need is a grid, and in this case I'm using a two dimensional grid off squares where a cell is directly connected to its immediate neighbors.

Every cell in the grid executes a program, and all of these programs are identical, but they operate on local data.

Each cell contains a memory which can be used to store its current state and for game of life.

It's simply on off, but it could be much more complicated.

Each cell has the ability to interact on, communicate with its neighbors.

And finally, But this is the most important part.

All of the cells run a program, but they all run the same program and they all run the same program synchronized with each other.

This gives way to the S I m d paradigm single instruction, multiple data where a single instruction is broadcast across the whole processing array, but it uses its local data to operate on.

Communication gives rise to cellular water matter.

The program for game of life is very simple.

So let's assume I am this cell in the middle here on.

When I was going to be indicated by red dots.

We can only talk to the neighbors in our immediate vicinity, so this gives us a three by three square around the active cell, and we can count how many red dots are in this square.

This is where we introduce some very simple rules.

When the style is alive, I'II its output.

It's set toe one, so it's got blue dot or it's a red daughter.

If the cell is alive and has less than two neighbors, it dies from loneliness.

If it has greater than three neighbors, it dies from overcrowding.

Otherwise, the cell has a good number of neighbors, and it's happy we'll put a smiley face on and it stays alive.

It's not out putting anything, but in the weird world of John Conway, if a cell has three neighbors and it's dead, those three neighbors get together and produce a living cell.

And so, in this instance, this cell now becomes active.

In fact, so does this one, because it to also has three active neighbors.

And that's it really is how simple the rules set is, but there is one more important thing to do.

We have to do everything at the same time, we cannot scroll through the cells one by one and update them is necessary.

Instead, we have to treat all of the cells as if they're in one hee park of time.

As we carry on schooling through the cells, we can't count the ones that have already been set on this sea park, or else this one would also become alive.

And then this one would also become a life on these air incorrect results.

Having seen how simple the rule set is, it's time to do this in code.

And I'm going to do this by creating to two dimensional arrays one that represents the output on one that represents the current state of the cell.

So the output is what basically will see on the screen on DTH.

E state is the current memory within the cell.

In the unused create function, I'm going to know allocate the memory for my 22 dimensional race on.

I'm going to use the screen wait thin screen heights.

So that's 360 by the 100 characters that we set before, and this means I can choose.

A council of any size on life should function appropriately just for good practice on, then going to set both of these rays two zeros.

It's often needed to work with two dimensional coordinates, so I'm going to create a little lambda function here.

Thio make it a little bit easier for me to access the array, and in this case, I want this lambda function to return the value off the output array.

Depending on my accent y coordinates I'm using the screen went Fear to multiply.

By the way, we're going to treat the our news update function as if it's a single iPAQ.

So every time this function is called, we're going to do a full update of the entire array.

But before we start to modify the state of the ray, we need to store it in the output.

So now we're free to interrogate the output on dhe change the state of the cell.

I'm going to use two nested four loops to iterated through all of the cells, and you'll notice I'm starting them from the coordinates one on.

I'm going to the screen with minus one on the screen.

I'm doing this to avoid reading memory, which isn't there.

They're actually several approaches in cellular autumn art about what to do with the boundaries.

But some people do actually prefer to happen.