So this is another video on working with vectors in p5.js.

And in this video, I really just want

to talk about what it means to make random vector, which

seems like, why is there even a whole video about that?

But I have a point to this, which I will get to.

It also is, I think, useful, because it's

kind of opening up this can of worms, this vector of worms,

which I want to open up, because I'm

going to end up looking at some other math functions

that I need.

And it's going to lead me to something

about static functions.

But that'll be in the next video.

Right now, I just want to look at this example that I have.

And what I have here is, first of all,

notice I'm translating the coordinate space

to the center of the canvas.

This is very important because I want to treat--

just for this visual demonstration--

I want to treat 0, 0 as the center of this canvas.

Then I'm making a vector with an x component of 100

and a y component of 0.

And I'm representing the vector as a line from 0,

0 to the x and y.

So it would be nice if I could draw a little hat on the end,

so it looks like an arrow.

But that's going to be too much work.

I could change these numbers, you know, negative 150.

And you can see there's my line.

So let's just think about, first,

what would it mean to pick a random vector?

Well, your first instinct might be

this, which is a very reasonable instinct,

let's make a vector that has between negative 100

and 100 as it's x.

And this is going to start getting very long.

I'm going to have to drag this way off over.

Negative 100 as it's y, that's like the range of stuff

that I'm picking.

And if I run the sketch, you know, at every single frame,

it is picking a new value for x and y,

and I'm seeing that line point off in a direction.

So this is a random vector generator, in a way.

But I want to show you something a little bit odd, which

is that if I take back ground 0 and put it into Setup,

what do you expect to see?

I'm going to see collect over time every single vector that

points from anywhere from 0, 0 to what?

Something with an x and y, minimum maximum

between negative 100 and 100.

Let's run this.

I'm going to let this play out for a little bit.

[MUSIC PLAYING]

Look at that result. I am seeing all of the vectors

fill up a square--

the worst drawn square ever.

Any vector, this vector, this vector, this vector,

this vector, right?

Because minimum, maximum.

This is, you know--

In many cases when working with vectors,

however, it's quite common that you

want to pick a vector with a random direction, but a fixed

magnitude.

What do I mean by that?

Here, the direction and the magnitude, it's all random.

And the magnitude even has kind of this arbitrary range,

because this is the longest vector possible,

but if I go to extend to here.

This one is actually shorter.

What would it mean for me to pick

vectors that fill out a circle?

There is something called a unit vector.

And a unit vector is a vector of length 1--

that's the unit-- with any direction.

So it's a kind of vector that you

use when you only really want to talk about the direction.

Ah, the magnitude doesn't matter.

Let's just pick 1 as a standard, and let's now pick a direction.

So what if I wanted to pick any unit

vector, any vector of length 1, but in any direction?

Oops.

So I could start to look into some trigonometry math

to do this.

And I will come to that soon enough.

But one of the benefits of working with vectors in p5.js

is there's a function that'll pick a random unit

vector for you.

And that function is just called random 2D,

because I want a random 2D vector.

v equals p5.vector.2D.

Now, there's something really odd about this,

which is I'm calling this function random 2D,

p5.vector.radom2D.

What is all that?

So this is veering off into this other topic

about static functions.

And I'm going to talk about that and cover

that in the next video.

But for right now, let's just understand

this as a function that returns a random unit vector.

So now, if I were to run this, look at all those random unit

vectors.

They're all of length 1.

Well, I can't really visually see

what's going on, because 1 pixel isn't very much.

I could use scale.

I could try using the scale function to kind of blow things

up.

But this is a really nice opportunity for me

to talk about another vector math function-- multiply.

Remember, when I had vectors a and b?

And I said a plus b is add the x's together, add the y's

together, and I'll get 8, 3.

Those are the numbers I used before,

but I think this math is correct.

And the function in P5 to do this was add.

Now, what if I wanted to use the idea of multiplication

with vectors?

Oh, my goodness, could I say a times b?

Well, I kind of can, but vector multiplication--

the vector product is a whole other topic

that I'll cover eventually.

But you might have heard of things like the dot

product or the cross product or even something called

the Hadamard product.

But I'm not covering those now.

When I'm referring to this function in P5, called

mult for multiply, I'm talking about scaling the vector,

multiplying the vector by a scalar quantity.

So, in other words, I'm talking about saying a times, not

another vector, but like the number 2.

And what do I mean when I say that?

If I have a vector that's pointing

in a given direction with a given magnitude, like 3--

well, let's actually make it 5, because I'm going

to use the 3, 4, 5 triangle.

If I multiply it by 2, now I have that same vector--

no, sorry, I have a different vector,

but it's the same direction with length twice as much.

So the length of this vector is 10.

And the way that this works is if it's in 3, 4, 5--

if the components are 3 and 4 because it's in 3,

4, 5 triangle, then all I have to do

is multiply each component.

So if I want to take a and multiply it by 2,

the vector I get is 6, 8.

3 times 2, 4 times 2.

So in this case, after I pick this random unit vector, which

has length 1, I can scale it to any quantity

by saying v multiply 100.

And think about what's going to happen now.

I'm going to run this sketch.

And I get any vector, always of length 100,

pointing in any direction.

This opens up, incidentally, a lot of possible,

just like visual possibilities, just from this alone.

And certainly, I could change this and say, oh,

any vector between 50 and 100-- and I should probably give this

some alpha to sort of see.

And we can see now I have any vector,

it's at a minimum length 50, maximum length 100.

And just from that I'm getting this sort

of like nice visualization.

That would be harder to do without these

built in functions in vectors.

Before I move on, let's just quickly move back

to this walker example and see that I could now

say this top velocity equals p5.vector.random2D.

And this would now be a way of taking a walker

and every time I run the sketch, it's

going to go in a random direction.

The speed, the magnitude of the velocity

is always going to be 1.

So I could also randomize that to some value

between like 0 and 3.

Oops.

This dot velocity dot multiply.

And now you're seeing just another way

of thinking about how you might initialize something

with randomness.

And maybe Perlin noise could play a role here.

Is there some way you can create an array

of all these walkers with initial velocities

according to Perlin noise?

If you go back and look at my Perlin noise videos,

that might create some interesting trails

you could consider.

But I'm going to stop here and let

you do some variations of this now

that you see about how random 2D works and multiply works.

There is another aspect to this, though, that I want to unpack,

which is what does it mean to call a function like .multiply,

which is on a vector v, versus a function like random 2D,

which is not on a specific vector,

but on the type of thing itself, p5.vector.

So I'm going to come back and that's

called a static function.

I'm going to cover that in a separate video.

And then after that, we'll be ready to start

looking at acceleration and all the other good stuff, magnitude

and normalize and all that sort of stuff, OK?

So thanks for watching this one.

And I'll see you in the next, one maybe.

I don't know.

Good bye.

[RINGS BELL]

[MUSIC PLAYING]