Q: My "Paint Splatter" project keeps on producing a splatter plot with the same exact colors and spots every restart it, which raises some questions. I'm not sure what my issue is. I can't find any information on this Random object, is it a Khan Academy thing? My code is below: ```var generator = new Random(1); var stdDev = 200/3; var mean = 200; var numDrops = 1000; //number of paint drops var colorStdDev = 200; var randomColor = function(){ var rColor = colorStdDev * generator.nextGaussian() + 255/2; var gColor = colorStdDev * generator.nextGaussian() + 255/2; var bColor = colorStdDev * generator.nextGaussian() + 255/2; var randColor = (rColor , gColor, bColor); return randColor; }; for(var i = 1; i < numDrops ; i++){ var xPos = mean + generator.nextGaussian()*stdDev; //random gaussian x-position var yPos = mean + generator.nextGaussian()*stdDev; //random gaussian y-position noStroke(); fill( randomColor() ); //color is from randomColor ellipse( xPos, yPos, 10, 10); }```

The `1` as the argument to the `Random` constructor guarantees that it will reproduce exactly the same number sequence every time. If you want different results, then randomize the seed, e.g. ```var generator = new Random(random(0, 2000000000));```

Q: what number 1 in var generator=new Random( 1 ); means?

It's called a seed. The Random class doesn't really generate random numbers. Computers aren't capable of generating truly random numbers. They can only generate numbers that _seem_ random to us: pseudo random numbers. The Random class generates the same sequence of numbers every time. That's not very random at all. You can try that with a program. ```var generator = Random(1); var mouseClicked = function() { println(generator.nextGaussian()); };``` You'll see a different number every time you click. But Restart the program and you'll see the same list of numbers again. Now try it again, but change the seed. ```var generator = Random(2); var mouseClicked = function() { println(generator.nextGaussian()); };``` Restart the program and click the mouse. You'll get a different sequence of numbers. Ideally you would want a different seed every time the program starts up. The best way to do that is to use time. ```var generator = Random(hour() + minute() + second() + millis()); var mouseClicked = function() { println(generator.nextGaussian()); };```

Q: I cannot find any documentation for the Random object in the processing.js reference page. (http://processingjs.org/reference/) The random() function is documented, but the Random type is not. This article states that the Random object is part of processingJS. Is this a mistake?

KA has modified processing.js library to change, add and remove certain functions. The function in the non-KA library is called randomGaussian(), accepts no arguments and uses the internal random generator to return values. The Random() object type in KA must be assigned as a new instance to a variable and requires a random seed value. Because of this, you can have several Random objects and each generates its own values. Also, the random seed you supply ensures that the exact same sequences of values is returned, just like randomSeed() does with random(): ` var r1 = new Random( 1 ); // value is required var r2 = new Random( 2 ); println( r1.nextGaussian() ); println( r2.nextGaussian() ); `

Question 1

During step 2 of challenge the Gaussain Walk, i didn't know whether to make a new variable or if i was just doing the stepsize equation wrong. I need help with the equation and whether or not to make a new variable.

Accepted Answer

A year late but hopefully it helps. Yes you do create a new variable. Like this:

Walker.prototype.walk = function() {
     var num1 = generator.nextGaussian();
     var xStepSize = standardDeviation * num1 + mean;
     var num2 = generator.nextGaussian();
     var yStepSize = standardDeviation * num2 + mean;
  
     this.x += xStepSize;
     this.y += yStepSize;
};

Question 2

Hi guys can anyone explain to me why you have to use `new Random`? I understand that its making the `generator` a object, but why does random have to be capitalized and is there something I'm missing because I don't remember learning to make objects like that - with just the `new` key. Thanks.

Accepted Answer

Have you gone through the object-oriented JS lessons in the intro? The Random() is an object that you have to initialize to use, and once you do, you can then call methods on it like nextGaussian(). It's like:
```
var winston = new Winston();
winston.eat();```

Question 3

why do you have the parameter set to one? i tried playing with the number, but it didn't seem to change that much on the canvas.

Accepted Answer

The parameter of Random() is called a seed and it allows for reproducability. To fix a bug found in a program, it is necessary to have the code do the same thing every time, which is the purpose of a seed: by using a constant, such as 1, as the seed, the program will do the same thing every time you press reset; the same random numbers will be produced in the same order every time. If you switch to a different constant, such as pi, a different set of random numbers will be chosen, but the same new numbers will be chosen, in the same order, every time you restart the program. To get the code to choose different numbers every time the program is run, you must pass a number that changes every time the program is run. A common method, as AwesOmeMaster suggests in a comment above, is to call a function to get the time in seconds and use that as the seed.

Question 4

Isn't the standard normal curve - standard deviation rule 68-95-99.7, you have listed 68 then 98? then 99.7? (I think it should be 95 instead of 98

Accepted Answer

Excellent catch. Mistakes such as these can be reported using the "Report a mistake in the article" button at the top-right of the discussion section. I have done so.

Question 5

I don't understand what they want me to do for the Gaussian walk. I used the method shown here but it doesn't work. Could you give a hint that points me in the right direction. Here's my code:
```var Walker = function() {
    this.x = width/2;
    this.y = height/2;
};

Walker.prototype.display = function() {
    strokeWeight(3);
    stroke(0, 0, 0);
    point(this.x, this.y);
};

var generator = new Random(1);
var num = generator.nextGaussian();
var standardDeviation = 2;
var mean =  0;

// Randomly move up, down, left, right, or stay in one place
Walker.prototype.walk = function() {
    var xStepSize = standardDeviation * num + mean;
    var yStepSize = standardDeviation * num + mean;
  
    this.x += xStepSize;
    this.y += yStepSize;
};

var w = new Walker();

var draw = function() {
    w.walk();
    w.display();
};```

Accepted Answer

Okay, I don't think it wants you to make a new var named num. my walk function looks like this, and it seems more random.

Yours seems to go in a straight line, pretty much.

I had what you have at first, probably, because I expect whatever was recently done to be done again for the challenge, but it didn't work.

Anyways,

```
Walker.prototype.walk = function() {
    
    var xStepSize = standardDeviation * generator.nextGaussian() + mean;
    var yStepSize = standardDeviation * generator.nextGaussian() + mean;
    
    this.x += xStepSize;
    this.y += yStepSize;
};
```

Granted, I already had _this_ farther at the top outside of my functions.

```
var generator = new Random(1);
var standardDeviation = 2;
var mean = 0;
```

To be honest, mine isn't passing me either, and I don't know why. 
Perhaps I have some weird mistake somewhere i'm just not seeing, but mine is going in random directions and all so I personally don't see what's wrong, but anyways perhaps my example can help you figure yours out. *shrug*

Question 6

My "Paint Splatter" project keeps on producing a splatter plot with the same exact colors and spots every restart it, which raises some questions. I'm not sure what my issue is. I can't find any information on this Random object, is it a Khan Academy thing?

My code is below:

```var generator = new Random(1);
var stdDev = 200/3; 
var mean = 200; 
var numDrops = 1000;  //number of paint drops
var  colorStdDev = 200;

var randomColor = function(){
    
    var rColor = colorStdDev * generator.nextGaussian() + 255/2;
    var gColor = colorStdDev * generator.nextGaussian() + 255/2;
    var bColor = colorStdDev * generator.nextGaussian() + 255/2;
    var randColor = (rColor , gColor, bColor);
    return randColor;
};

for(var i = 1; i < numDrops ; i++){
    
    var xPos = mean + generator.nextGaussian()*stdDev; //random gaussian x-position
    var yPos = mean + generator.nextGaussian()*stdDev; //random gaussian y-position
    noStroke();
    fill( randomColor() ); //color is from randomColor
    ellipse( xPos, yPos, 10, 10);

}```

Accepted Answer

The `1` as the argument to the `Random` constructor guarantees that it will reproduce exactly the same number  sequence every time.  If you want different results, then randomize the seed, e.g. ```var generator = new Random(random(0, 2000000000));```

Question 7

what number 1 in 
var generator=new Random( 1 );
 means?

Accepted Answer

It's called a seed.
The Random class doesn't really generate random numbers. Computers aren't capable of generating truly random numbers. They can only generate numbers that _seem_ random to us: pseudo random numbers.

The Random class generates the same sequence of numbers every time. That's not very random at all. You can try that with a program.
```var generator = Random(1);
var mouseClicked = function() {
    println(generator.nextGaussian());
};```
You'll see a different number every time you click. But Restart the program and you'll see the same list of numbers again.

Now try it again, but change the seed.
```var generator = Random(2);
var mouseClicked = function() {
    println(generator.nextGaussian());
};```
Restart the program and click the mouse. You'll get a different sequence of numbers.

Ideally you would want a different seed every time the program starts up. The best way to do that is to use time.
```var generator = Random(hour() + minute() + second() + millis());
var mouseClicked = function() {
    println(generator.nextGaussian());
};```

Question 8

I cannot find any documentation for the Random object in the processing.js reference page. (http://processingjs.org/reference/) The random() function is documented, but the Random type is not. This article states that the Random object is part of processingJS. Is this a mistake?

Accepted Answer

KA has modified processing.js library to change, add and remove certain functions.
The function in the non-KA library is called randomGaussian(), accepts no arguments and uses the internal random generator to return values. The Random() object type in KA must be assigned as a new instance to a variable and requires a random seed value. Because of this, you can have several Random objects and each generates its own values. Also, the random seed you supply ensures that the exact same sequences of values is returned, just like randomSeed() does with random():
`
var r1 = new Random( 1 ); // value is required
var r2 = new Random( 2 );
println( r1.nextGaussian() );
println( r2.nextGaussian() );
`

Score		Deviation		Squared deviation
$85$ ‍	$85 - 81.3 =$ ‍	$3.7$ ‍	$(3.7)^{2} =$ ‍	$13.69$ ‍
$82$ ‍	$82 - 81.3 =$ ‍	$0.7$ ‍	$(0.7)^{2} =$ ‍	$0.49$ ‍
$88$ ‍	$88 - 81.3 =$ ‍	$6.7$ ‍	$(6.7)^{2} =$ ‍	$44.89$ ‍
$86$ ‍	$86 - 81.3 =$ ‍	$4.7$ ‍	$(4.7)^{2} =$ ‍	$22.09$ ‍
$85$ ‍	$85 - 81.3 =$ ‍	$3.7$ ‍	$(3.7)^{2} =$ ‍	$13.69$ ‍
$93$ ‍	$93 - 81.3 =$ ‍	$11.7$ ‍	$(11.7)^{2} =$ ‍	$136.89$ ‍
$98$ ‍	$98 - 81.3 =$ ‍	$16.7$ ‍	$(16.7)^{2} =$ ‍	$278.89$ ‍
$40$ ‍	$40 - 81.3 =$ ‍	$- 41.3$ ‍	$(- 41.3)^{2} =$ ‍	$1705.69$ ‍
$73$ ‍	$73 - 81.3 =$ ‍	$- 8.3$ ‍	$(- 8.3)^{2} =$ ‍	$68.89$ ‍
$83$ ‍	$83 - 81.3 =$ ‍	$1.7$ ‍	$(1.7)^{2} =$ ‍	$2.89$ ‍

Course: Computer programming - JavaScript and the web > Unit 5

Normal distribution of random numbers

Want to join the conversation?