As you can see, we are extracting only the fractional part of a sine wave. We have done this in the past. We can apreciate and understand how the ```sin()``` function that returns values between ```-1``` and ```1``` have been braked only and forced to be all positive values. We are going to use this effect for our purposes of achinving some random values by "breaking" this sine wave in smaller and smaller pieces. Why? by multiplying the ```sin(x)``` for bigger numbers. Go a head and click on the function and start adding some zeros.
Above we are extracting the fractional content of a sine wave. The [```sin()```](../glossary/?search=sin) values that fluctuate between ```-1.0``` and ```1.0``` have been chopted behind the floating returning all positive values between ```0.0``` and ```1.0```. We can use this effect to get some pseudo-random values by "breaking" this sine wave in smaller pieces. Why? by multiplying the resultant of [```sin(x)```](../glossary/?search=sin) by bigger numbers. Go a head and click on the function and start adding some zeros.
By the time you get to 100000 ( and the equation looks like this: ```y = fract(sin(x)*100000.0)``` ) you probably are not hable to distinguish the sine wave any more. The granulary of the fractions have corrupt the flow of the sine in random chaos.
By the time you get to ```100000.0``` ( and the equation looks like this: ```y = fract(sin(x)*100000.0)``` ) you probably are not hable to distinguish the sine wave any more. The granulary of the fractions have corrupt the flow of the sine in psudo-random chaos.
## Controling chaos
Using random could be hard, is both too chaotic and, sometimes, not random enought. Take a look to the following graph. Inside it, we are using a ```rand()``` fuction implemented exactly like we describe above.
Taking a closer look, you can se the ```sin()``` wave crest and though at -1s.5707 and 1.5707. I bet you know understand why. Also, if you see the distribution of it seem to be more likely to get values between 0.5 than on the edges.
Taking a closer look, you can se the [```sin()```](../glossary/?search=sin) wave crest and though at ```-1s.5707``` and ```1.5707```. I bet you now understand why. Is where the crest and buttom of the sin wave happend.
If look closely the random distribution, you will note that the there is some concentration arround the middle compared to the edges.
<divclass="simpleFunction"data="y=rand(x);
//y = rand(x)*rand(x);
//y = sqrt(rand(x));
//y = pow(rand(x),5.);"></div>
A while ago [Pixelero](pixelero.wordpress.com) made an [interersting article about random distribution](https://pixelero.wordpress.com/2008/04/24/various-functions-and-various-distributions-with-mathrandom/). I add some of the function he use in the following lines of the previus graph for you to play and observe how the distribution changes. Un comment them and see how the distribution change.
A while ago [Pixelero](pixelero.wordpress.com) made an [interersting article about random distribution](https://pixelero.wordpress.com/2008/04/24/various-functions-and-various-distributions-with-mathrandom/). I add some of the function he use in the following lines of the previus graph for you to play and observe how the distribution can be changed. Uncomment them and see what happen.
If you read [Pixelero's article](https://pixelero.wordpress.com/2008/04/24/various-functions-and-various-distributions-with-mathrandom/) , is important to have in mind that our ```rand()``` function is a deterministic random or also known as pseudo-random. Which means, for example ```rand(1.)``` is going to return always the same value. [Pixelero](https://pixelero.wordpress.com/2008/04/24/various-functions-and-various-distributions-with-mathrandom/) makes reference to the ActionScript function ```Math.random()``` which is non-deterministic, every call will return a different value.
## 2D Random
Now we understand better randomness, is time to apply it on both *x* and *y* axis. For that we need a way to transform a two dimensional vector into a one dimensional float point value. There are different ways to do this, but the ```dot()``` function can be very particulary helpfull in this case, becuse of it avility to return a float values between 0 and 1 depending if two vectors are align.
Now that we have a better understanding of randomness, is time to apply it on two dimension, for both ```x``` and ```y``` axis. For that we need a way to transform a two dimensional vector into a one dimensional float point value. There are different ways to do this, but the [```dot()```](../glossary/?search=dot) function can be particulary helpfull in this case. It's avility to returning a single float values between ```0.0``` and ```1.0``` depending on the aligniation of two vectos is key to this process.
Take a look to line 11 and 12 and how we are comparing the ```in vec2 _st``` with a ___ vector ( ```vec2(12.9898,78.233)```).
Take a look to line 13 to 15 and how we are comparing the ```vec2 st``` with a another two dimentional vector ( ```vec2(12.9898,78.233)```).
* Try changing the values on lines 12 and 13. See how the random pattern change and what we can learn from it.
* Try changing the values on lines 14 and 15. See how the random pattern change and what we can learn from it.
* Hook this random function to the mouse interaction (```u_mouse```) and time (```u_time```) to understand better how it works.
## Using the chaos
Random in two dimensions looks a lot like TV noise. Right? Which is a hard raw material to use to compose images. Let's learn how to make use of it.
Our first step is going to apply it on a grid. Take a look to the following code. Specially on lines 20 and 21.
Our first step is going to apply it on a grid to it using the [```floor()```](../glossary/?search=floor) function we will generate a integer table of cells. Take a look to the following code. Specially on lines 22 and 23.
After scaling the space ten times more (line 10), we separate the integers of the coordenates from the fractions. We are familiar with this last operation because we have been usign it to subdevide a space in smaller cells that consistantly go from 0 to 1. By obtaining the integer of the coordinate we isolate a common value for all the threads inside a cell, to then use that integer to obtain a random value. Because the random is deterministic will be constant for all the pixels on that cell as long the random function is the same for all the threads.
After scaling the space ten times more (on line 20), we separate the integers of the coordenates from the fractional part. We are familiar with this last operation because we have been usign it to subdevide a space in smaller cells that consistantly go from ```0.0``` to ```1.0```. By obtaining the integer of the coordinate we isolate a common value for all that region of pixels. Which will look like a single cell. Then we can use that common integer to obtain a same random value for all that area. Because the random is deterministic will be constant for all the pixels on that cell.
Uncommenting the line 29 we can still se how we preserve the floating part of it, and how we can use that as a coordinate system to draw things inside.
Combining this two values will allow you to mix variation and order.
@ -55,8 +63,30 @@ Take a look to this GLSL port of the famouse ```10 PRINT CHR$(205.5+RND(1)); : G
You can get an interesting variation by uncommenting the block of lines from 48 to 51. In case you want to animate it you can uncoment lines 33 and 34.
On it I'm using the random values of the cells to draw a line in one direction or the other using the ```trouchetPattern()``` function of the previus chapter (lines 41 to 47).
You can get another interesting patterns by uncommenting the block of lines between 50 to 53, or animated by uncommenting lines 35 and 36.
## Master Random
[Ryoji Ikeda](http://www.ryojiikeda.com/), Japanese electronic composer and visual artist, have master the use of random in such a way is hard not to be touch and mesmerize by his work. Random in audio and visual mediums is forge in such a way is not longer anoying chaos but a mirror of the complexity our over-technological culture.
Take a look to [Ikeda](http://www.ryojiikeda.com/)'s work and try the following excersices:
* Make to rows of moving cells (in opposite directions) with random values. Only display the cells with brigter values. Make the velocity of the rows fluctuate over time.
Using random aesthetically can be problematic. It's simply too chaotic and not really to many things looks ```random()``` in real life. Usually estocastic values are some how related to the previus one. If you look to a rain pattern, or the wallstreet chart (which both quite random), they are nothing like the random pattern we made at the begining of this chapter. The reason? Well random values have no correlation between them what so ever.
Using random aesthetically could be also problematic, specially if you want to natural-looking simulations. Random is simply too chaotic and not really to many things looks ```random()``` in real life. Usually estocastic values are some how related to the previus one. If you look to a rain pattern, or the wallstreet chart (which both quite random), they are nothing like the random pattern we made at the begining of this chapter. The reason? Well random values have no correlation between them what so ever.
On the *Next* chapter we will learn about noise, the smooth and *natural looking* way of computational chaos.
Patricio Gonzalez Vivo
9 years ago
