Natively means no R and no Python is used. We only use Tableau's native functions to do all the necessary calculations, including iterations.
As I have recently been interested in rendering math functions in Tableau, I noticed a dramatic rendering in Tableau of Lorenz Attractor by
George Gorczynski. He used Python to generate the data set, with fixed parameters.
I tried to implement the attractor in Tableau alone but failed. The problem was that the iterative variables are referring to themselves and to each others. This created circular references that Tableau won't allow. So I let it sleep for a while.
Later on, I stumbled upon Zen Master Noah Salvaterra's scholarly
article on how he solved those iterative calculations in Tableau. What a living proof to "Seek and you will find"!
Inspired by Noah's article and my interest is rekindled in the dashboard design. Voila it worked! The dashboard is based on 2 rows of data, with parameters. No need of R or Python. It is natively made in Tableau.
The key is the iterative calculation. Basically, Noah's idea is to create a string that serves as the register of the transient states of an iterative process. All the coordinates and variables can be derived from the state register.
There are 3 state variables:
x, y and
z where
x, y are coordinates while
z is the depth. The format of the string register is
x,y;z (all converted in string type). Two different separation characters are used in order to simplify parsing.
The iterative string will update itself at every step.
x,y and
z are updated as is shown in George's code:
x=h*a*(y-x)+x;
//Note that x at the right is the previous value.
y=h*(x*(b-z)-y)+y;
//x refers to the new x value in current iteration.
z=h*(x*y-c*z)+z;
//x,y refers to the x,y values in current iteration.
where
h=0.008;
a=10;
b=28;
c=8/3;
The initial conditions are
So the initial string is '0,10;10'. This string is updated using Previous_Value('0,10;10').
Here is how
x is updated:
- STR(
- //x= h*a*y_prev+(1-h*a)*x_prev
- //h*a*y_prev
- [h delta]*[a]*FLOAT(MID(PREVIOUS_VALUE([IniString]),
- FIND(PREVIOUS_VALUE([IniString]),',')+1,
- FIND(PREVIOUS_VALUE([IniString]),';')-1-find(PREVIOUS_VALUE([IniString]),',')
- ))
- //+(1-h*a)*x_prev
- +(1-[h delta]*[a])*FLOAT(MID(PREVIOUS_VALUE([IniString]),1,
- FIND(PREVIOUS_VALUE([IniString]),',')-1))
- )
Then
y is updated based on the above
x and the previous
y. Last
z is updated based on
x,
y of this iteration and previous
z. A new tuple is formed in a string like
x,y;z. Believe it or not, This calculated field formula is the biggest one I have ever written.
Details can be found in the attached workbook. Click images to view
the workbook.
That's the key of the computation. It finally helped me understand how Previous_Value() works.
Here are a few renderings of the Lorenz Attractor. By the way, rendering math in Tableau is a great way to learn some new Tableau skills.
Add a comment