# Using Cellular Automata and Climate Data to Generate Visual Art

After the recording of the first demo with my band Mundo Kumo where we create music inspired on per reviewed papers about climate change, it was time to create some of the videos that we will be using on our live show. My initial idea was to use computer generated art combined with real climate data. I had experience with coding and complex artificial intelligence algorithms however not much experience using artificial intelligence (AI) to generate art.

The code used here was developed using the python language and it can be downloaded freely on my github repository called AlgorithmicArt. Although this was the initial idea about the videos,  the idea changed a lot after and we are not using all the videos explained here. However they are still a really good starting point.

When doing a little bit of research on the topic i found that Cellular automata was probably one of the easiest way to start. The concept of cellular automata was created by the mathematician Stephen Wolfram and some of the rules are very similar to the majority vote model used widely on statistical mechanics.

The first intuitive step is the use of the one-dimensional cellular automata (the easiest to implement and understand) . Thus picking a cellular automaton rule, it is possible to create a picture similarly to the pictures found on the internet. To make things a little bit more interesting, a video can be made showing the evolution of the cellular automata grouping sequential gifs. This can be done using different alternatives. For example using ubuntu and the imagemagick package:

``convert -delay 20 -loop 0 *.jpg myimage.gif``

The final video is a thing like this:

The second step is to add the climate information in the code and combine with the cellular automata. I used global temperature anomalies from NOAA. I maped the colors based on the range of temperature anomalies. Thus, the colors (global temperature anomalies) and the evolution of the cellular automata are connected:

Next post I will talk about two-dimensional cellular automata.

# Think Python AND R and not just PYTHON OR R: Creating vectors

In this post I will talk a little bit about how python and R work with vectors. I am using python 2.7.13 and R 3.4.3, both 64-bit on a Ubuntu 16.04 and I am also using the free book called A Hands-On Introduction to Using Python in the Atmospheric and Oceanic Sciences by prof. Johnny Lin as a guide.

## Creating vectors

The first thing about a vector is how to create one. There are several ways to create a vector in R. For example, if one needs to create a logical vector:

``````a = vector(mode = "logical", length = 5)
b = c(FALSE, FALSE, FALSE, FALSE, FALSE)
c = rep(FALSE,5)
``````
```##  FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE
##  FALSE FALSE FALSE FALSE FALSE
```

or a numerical vector:

``````a = vector(mode = "numeric", length = 5)
b = c(0, 0, 0, 0, 0)
c = rep(x=0, 5)
``````
```##  0 0 0 0 0
##  0 0 0 0 0
##  0 0 0 0 0
```

The `vector()` function produces a vector of the given length and mode, the `c()` function is a generic function which combines its arguments and `rep()` function replicates the values in `x` also returning a vector.

In python we can use the `numpy` package which has lots of methods to create and manipulate arrays/vectors. Thus importing the package `numpy` and generating the same vectors in python:

``````import numpy as np
a = np.array([False,False,False,False])
b = np.full(4, False, bool)
print a
print b
``````
```## [False False False False]
## [False False False False]
```

or a numerical vector:

``````import numpy as np
a = np.array([0,0,0,0])
b = np.full(4, 0, float)
print a
print b
``````
```## [0 0 0 0]
## [ 0.  0.  0.  0.]
```

Why are they different? Remember the dynamical typing? Vector `a` is a vector of integers and `b` is a vector of float. The attribute `dtype` gives the data-type of the array’s elements:

``````c = np.array([0.0,0.0,0.0,0.0])
print a.dtype
print b.dtype
print c
print c.dtype
``````
```## int64
## float64
## [ 0.  0.  0.  0.]
## float64
```

## Indexing Vectors

One major difference between python and R is how they address the element in the vector. In python the element addresses start with zero, so the first element of vector `a` is `a`, the second is `a`, etc.

``````import numpy as np
d = np.array(range(1,5))
print d
print d, d
``````
```## [1 2 3 4]
## 1 4
```

In R the element addresses follows the ordinal value thus starting from one. Consequently the first element of vector `a` is `a`, the second is `a`, etc.

``````d = seq(4)
print(d)
cat(d, d, sep=" ")
``````
```##  1 2 3 4
## 1 4
```

## Be careful!!!!

Python and R have the same method `range()` but they do different things. In python `range()` returns a list containing an arithmetic progression of integers. `range(i, j)` returns $([i, i+1, i+2,\ldots , j-1])$ and the default is `i=0`.

``````f = range(5)
g = range(2,5)
print f
print g
``````
```## [0, 1, 2, 3, 4]
## [2, 3, 4]
```

In R the methods similar to `range()` are `seq()`, `seq_along()`, `seq_len()` (please check the R documentation to see the differences between them) which generates regular sequences. However the default starting value is `1`.

``````f = seq(5)
g = seq(2,5)
print(f)
print(g)
``````
```##  1 2 3 4 5
##  2 3 4 5
```

The method `range()` in R returns a vector containing the minimum and maximum of all the given arguments.

``````range(f)
range(5)
``````
```##  1 5
##  5 5
```

# Think Python AND R and not just PYTHON OR R: More about types

Last post I talked a little bit about the two most used programming languages for machine learning (python and R) and how they handle operators and types. In this post i will extend the talk about types in python and R. In particular logical operators and Boolean. Here I am using python 2.7.13 and R 3.3.3, both 64-bit on a Ubuntu 16.04 and I am using the free book called A Hands-On Introduction to Using Python in the Atmospheric and Oceanic Sciences by prof. Johnny Lin as a guide.

## Logical operators

The logical operators are <, <=, >, >=, == for exact equality and != for inequality (valid for both languages). However there are some differences between python and R when comparing logical expressions. In R if `test1` and `test2` are logical expressions, then `test1 & test2` is their intersection (“and”), `test1 | test2` is their union (“or”), and `!test1` is the negation of `test1`. Thus:

``````a = TRUE
b = FALSE
a & b
a | b
!a
``````
```##  FALSE
##  TRUE
##  FALSE
```

In python `test1 and test2` is their intersection (“and”), `test1 or test2` is their union (“or”), and `not test1` is the negation of `test1`.

``````a = True
b = False
print(a and b)
print(a or b)
print(not a)
``````
```## False
## True
## False
```

## Boolean variables

Python and R are case sensitive, so capitalization matters!!!! Therefore, `TRUE != True`. R also allows the use of `T` and `F` but it is not recommended. From the R documentation:

The elements of a logical vector can have the values `TRUE`, `FALSE`, and `NA` (for “not available”). The first two are often abbreviated as `T` and `F`, respectively. Note however that `T` and `F` are just variables which are set to `TRUE` and `FALSE` by default, but are not reserved words and hence can be overwritten by the user. Hence, you should always use TRUE and FALSE.

Thus doing a simple example in R:

``````c = T
a == c
``````
```##  FALSE
```

And this is why it is NOT recommended:

``````T = 10
a == T
``````
```##  FALSE
```

In some languages, the integer value zero is considered `FALSE` (or `False`) and the integer value one is considered `TRUE` (or `True)`. From the R documentation:

Logical vectors may be used in ordinary arithmetic, in which case they are coerced into numeric vectors, FALSE becoming 0 and TRUE becoming 1.

Doing a simple example in R:

``````a == TRUE
b == FALSE
10 + a
10 + b
``````
```##  TRUE
##  TRUE
##  11
##  10
```

The Python’s version I am using here (2.7.13) follows the same convention:

``````print(1 == a)
print(0 == b)
print(10 + a)
print(10 + b)
``````
```## True
## True
## 11
## 10
```

How about the operators? Lets use the same rule with R:

``````a & 1
a & 0
1 & a
2 & a
0 & a
``````
```##  TRUE
##  FALSE
##  TRUE
##  TRUE
##  FALSE
```

And using python:

``````print(a and 1)
print(a and 0)
print(1 and a)
print(2 and a)
print(0 and a)
``````
```## 1
## 0
## True
## True
## 0
```

Remember Python and R are dynamically typed but they sometimes handle variables in a different way? You can click here and see how python handles the truth value testing.

## Similarities not so similar

As a final remark I’d like to mention about the similarities not so similar of the operators `&` and `|` in R and python. Yes, python also has the same operators but they are the bitwise logical operators, which is slight different of what we are doing here. For example:

``````print(a & 1)
print(a & 0)
print(1 & a)
print(2 & a)
print(0 & a)
``````
```## 1
## 0
## 1
## 0
## 0
```

In R the bitwise operators are `bitwAnd()` and `bitwOr()`, but this is another post. Click here for more information about bitwise operators in python and R.

# Think Python AND R and not just PYTHON OR R: basic operators could generate different results

Nowadays, probably the two most used programming languages for machine learning are python and R. Both have advantages and disadvantages. With tools like rpy2 or Jupyter with the IRKernel, it is possible to integrate R and python into a single application and make them “talk” with each other. However, it is important to know how they work individually before the connection of these two programming languages. I will try to show some of the similarities and differences between the commands, functions and environment. For example, both languages could have very similar commands but these commands could lead to different results.

There are hundreds books about python and R with different flavours. Basic, advanced, applied, how to, free, paid, master, ninja, etc. Because I used a lot of programming applied to real world scenario I randomly biased decided to, use as a initial guide, a free book called A Hands-On Introduction to Using Python in the Atmospheric and Oceanic Sciences by prof. Johnny Lin (the main idea is to reproduce a machine learning portable code so i will change the reference later). Thus I will follow some examples of this book and give the insights about the python/R relation.

Nevertheless, It is imperative to know what version of the programming language one is using. Commands, types, syntax, can change over versions. Here I am using python 2.7.13 and R 3.2.2, both 64-bit on a Ubuntu 16.04.

## Basic operators

In R, the elementary arithmetic operators are the usual +, -, *, / and ^ for raising to a power. The only difference to python is the exponentiation operator which is **.

## Basic variables

Python and R are dynamically typed, meaning that variables take on the type of whatever they are set to when they are assigned. Additionally, the variable’s type can be changed (at run time) without changing the variable name. Lets start with two of the most important basic types: integer and float (called double in R). Here it is possible to see the first few differences between the languages. The integer type from the R documentation:

Integer vectors exist so that data can be passed to C or Fortran code which expects them, and so that (small) integer data can be represented exactly and compactly. Note that current implementations of R use 32-bit integers for integer vectors, so the range of representable integers is restricted to about +/-2*10^9: doubles can hold much larger integers exactly.

There are two integers types in python: plain and long.

Plain integers (also just called integers) are implemented using long in C, which gives them at least 32 bits of precision (sys.maxint is always set to the maximum plain integer value for the current platform, the minimum value is -sys.maxint – 1). Long integers have unlimited precision.

How about the float (or double) types? From both programming languages ultimately how double (or float) precision numbers are handled is down to the CPU/FPU and compiler (i.e. for the machine on which your program is running).

OK lets try a simple example. This example is the same as Example 4 on chapter 3 of our guide book. Lets say we have the following variables:

``````a = 3.5
b = -2.1
c = 3
d = 4
``````

If we run the operators described above in python we have:

``````print(a*b) #case 1
print(a*d) #case 2
print(b+c) #case 3
print(a/c) #case 4
print(c/d) #case 5
``````
```## -7.35
## 14.0
## 0.9
## 1.16666666667
## 0
```

Repeating the same steps for R we obtain:

```##  -7.35
##  14
##  0.9
##  1.166667
##  0.75
```

On cases 2, 4 and 5 we had different results. On case 4, the difference should be related to the float/double representation. Thus it is expected a difference on precision. However it does not mean that R has less precision than python in this example. It could be only the way R shows the variable to the user. Yes, unfortunately R can mislead you. For example, on case 2 the numbers are technically the but they are shown in a different way. The fact that R shows $14$ instead of $14.0$ does not mean that the value is integer and not double. Let’s use the functions `is.integer()` and `is.double()` to check the type of the variable of the result on case 2.

``````is.integer(a*d)
is.double(a*d)
``````
```##  FALSE
##  TRUE
```

Remember when the “dynamically typed”? The programming language automatically decides what type a variable is based on the value operation. Again from the python documentation:

Python fully supports mixed arithmetic: when a binary arithmetic operator has operands of different numeric types, the operand with the “narrower” type is widened to that of the other, where plain integer is narrower than long integer is narrower than floating point is narrower than complex. Comparisons between numbers of mixed type use the same rule.

That explains why in case 2 we have a float. You can check using the function `isinstance()`.

``````print(isinstance( a*c, ( int, long ) ))
print(isinstance( a*c, ( float ) ))
``````
```## False
## True
```

How about case 5? Case 5 is a little bit more interesting. For python we are dealing with 2 integers, thus the result should be integer. That is why we have $0$ because python does integer division and returns only the quotient.

``````print(isinstance( c/d, ( int, long ) ))
print(isinstance( c/d, ( float ) ))
``````
```## True
## False
```

How about R? Here is the reason (from the documentation):

For most purposes the user will not be concerned if the “numbers” in a numeric vector are integers, reals or even complex. Internally calculations are done as double precision real numbers, or double precision complex numbers if the input data are complex.

Thus, it is important to keep this in mind because you can have different results.

## Similarities not so similar

As a final remark I’d like to mention about the similarities not so similar of the operator `^` in and python. Yes, python also has the same operator but it is the bitwise XOR  operator, which is different of exponentiation. Click here for more information about bitwise operators in python.