Vectors

A vector is a mathematical object that has both magnitude and direction. Here is an example of a mathematical object that only has magnitude:

• Number line visualization with draggable slider

Here is an example of a mathematical object that only has direction:

• Arrow pointing in a direction that can be moved

By combining these two, we can intuitively understand a vector as a "movement in space".

• Arrow pointing in a direction with a specific length along that direction

In linear algebra, vectors are typically represented as ordered lists of numbers, called components. These components describe the vector's position in a coordinate system.

Vector Representation

In an n-dimensional space, a vector can be written as:

Vector Operations

1. Addition: Adding vectors component-wise

2. Scalar Multiplication: Multiplying a vector by a scalar

3. Dot Product: The sum of component-wise products

Properties

• Magnitude: Length of a vector, denoted as
• Direction: The orientation of the vector in space
• Unit Vector: A vector with magnitude 1
• Zero Vector: A vector with all components equal to 0

Applications

Vectors are fundamental in many areas:

• Physics (force, velocity, acceleration)
• Computer Graphics (position, direction)
• Machine Learning (feature vectors)
• Data Science (data points in high-dimensional space)

Vector Spaces

A vector space is a collection of vectors that satisfy certain axioms under addition and scalar multiplication. The most common vector space is , which consists of all n-tuples of real numbers.

The most common way to think about vectors in software development is as an array of numbers, such as . Mathematically, a vector is represented as an ordered list of numbers, which are called the components of the vector. For example, a vector in three-dimensional space may be written as .

Vectors serve as the building blocks for more complex structures in linear algebra, like matrices and tensors. A vector is an element of a vector space, which is a collection of objects that can be added together and multiplied by scalars. In a geometric sense, vectors can be visualized as arrows in space, where the length of the arrow represents the vector's magnitude, and the direction of the arrow indicates the vector's direction.

The magnitude (or length) of a vector is given by the Euclidean norm, which is calculated as:

Here is a simple implementation of magnitude in JavaScript.

code.js
1const v = [3, 4];
2const mag = magnitude(v);
3console.log(mag);
4
5// Euclidean distance
6function magnitude(v) {
7  return Math.sqrt(v.reduce((sum, value) => sum + value ** 2, 0));
8}

Vectors are a cornerstone of linear algebra, providing a way to represent quantities that have both magnitude and direction. In mathematical terms, a vector is an element of a vector space, which is a set equipped with two operations: vector addition and scalar multiplication. These operations must satisfy certain axioms, such as associativity, commutativity, and distributivity.

Consider a vector in a two-dimensional space, represented as . The components and are real numbers that define the vector's position in the plane. The magnitude of this vector, also known as its Euclidean norm, is calculated using the formula:

This formula generalizes to an -dimensional vector as:

In JavaScript, vectors can be represented using arrays. Here is an example of how to define a vector and compute its magnitude:

Vector Addition

Vector addition is a fundamental operation in linear algebra, where two vectors of the same dimension are combined to produce a new vector. Mathematically, if we have two vectors and , their sum is given by:

In JavaScript, vector addition can be implemented using arrays. Here is a simple function to add two vectors:

code.js
1function addVectors(u, v) {
2  return u.map((value, index) => value + v[index]);
3}

This function takes two vectors (arrays) and returns a new vector (array) that is the sum of the two input vectors. For example:

code.js
1const u = [1, 2, 3];
2const v = [4, 5, 6];
3
4const w = addVectors(u, v);
5console.log(w); // Output: [5, 7, 9]

Scalar Multiplication

Scalar multiplication is another fundamental operation in linear algebra, where a vector is multiplied by a scalar (a real number). If is a scalar and is a vector, then the scalar multiplication is given by:

In JavaScript, scalar multiplication can be implemented using arrays. Here is a simple function to multiply a vector by a scalar:

code.js
1function scalarMultiply(c, v) {
2  return v.map(value => c * value);
3}

This function takes a scalar (a number) and a vector (an array) and returns a new vector (array) that is the result of multiplying each component of the input vector by the scalar. For example:

code.js
1const v = [1, 2, 3];
2const c = 2;
3
4const w = scalarMultiply(c, v);
5console.log(w); // Output: [2, 4, 6]

Vector Subtraction

Vector subtraction is the inverse operation of vector addition. It involves subtracting corresponding components of two vectors to produce a new vector. For example, given two vectors and , their difference is given by:

In JavaScript, vector subtraction can be implemented using arrays. Here is a simple function to subtract one vector from another:

code.js
1function subtractVectors(u, v) {
2  return u.map((value, index) => value - v[index]);
3}

This function takes two vectors (arrays) and returns a new vector (array) that is the difference between the two input vectors. For example:

code.js
1const u = [1, 2, 3];
2const v = [4, 5, 6];
3
4const w = subtractVectors(u, v);
5console.log(w); // Output: [-3, -3, -3]

Vector Magnitude

The magnitude of a vector is a measure of its length or size. In linear algebra, the magnitude of a vector is given by the Euclidean norm, which is calculated as:

In JavaScript, the magnitude of a vector can be computed using the magnitude function:

code.js
1function magnitude(v) {
2  return Math.sqrt(v.reduce((sum, value) => sum + value * value, 0));
3}

This function takes a vector (an array) and returns its magnitude as a number. For example:

code.js
1const v = [3, 4];
2const mag = magnitude(v);
3console.log(mag); // Output: 5

Vector Cross Product

The cross product of two vectors in three-dimensional space is a vector that is perpendicular to both input vectors. If and are two vectors, their cross product is given by:

In JavaScript, the cross product can be computed using the crossProduct function:

code.js
1function crossProduct(u, v) {
2  return [
3    u[1] * v[2] - u[2] * v[1],
4    u[2] * v[0] - u[0] * v[2],
5    u[0] * v[1] - u[1] * v[0]
6  ];
7}

This function takes two vectors (arrays) and returns their cross product as a new vector (array). For example:

code.js
1const u = [1, 2, 3];
2const v = [4, 5, 6];
3
4const crossProd = crossProduct(u, v);
5console.log(crossProd); // Output: [-3, 6, -3]

Vector Projection

The projection of a vector onto another vector is a vector that represents the component of that is parallel to . If and are two vectors, their projection is given by:

In JavaScript, the projection can be computed using the projection function:

code.js
1function projection(u, v) {
2  const dotProd = dotProduct(u, v);
3  const magV = magnitude(v);
4  const magV2 = magV * magV;
5  return scalarMultiply(dotProd / magV2, v);
6}

This function takes two vectors (arrays) and returns their projection as a new vector (array). For example:

code.js
1const u = [1, 2, 3];
2const v = [4, 5, 6];
3
4const proj = projection(u, v);
5console.log(proj); // Output: [0.96, 1.2, 1.44]

Vector Normalization

Normalizing a vector involves scaling it to have a magnitude of 1 while preserving its direction. If is a vector, its normalized form is given by:

In JavaScript, the normalization can be computed using the normalize function:

code.js
1function normalize(v) {
2  const mag = magnitude(v);
3  return scalarMultiply(1 / mag, v);
4}

This function takes a vector (an array) and returns its normalized form as a new vector (array). For example:

code.js
1const v = [3, 4];
2const norm = normalize(v);
3console.log(norm); // Output: [0.6, 0.8]

Vector Angle

The angle between two vectors can be computed using the dot product. If and are two vectors, their angle is given by:

In JavaScript, we can implement a simple angle function to compute the angle between two vectors.

code.js
1function angle(u, v) {
2  const dotProd = dotProduct(u, v);
3  const magU = magnitude(u);
4  const magV = magnitude(v);
5  if (magU === 0 || magV === 0) {
6    throw new Error("Cannot compute angle with zero magnitude vector.");
7  }
8  
9  const cosTheta = dotProd / (magU * magV);
10  
11  // Ensure the value is within the valid range for acos
12  if (cosTheta < -1 || cosTheta > 1) {
13    throw new Error("Numerical error: cosine value out of range.");
14  }
15  
16  return Math.acos(cosTheta);
17}
18
19function magnitude(v) {
20  return Math.sqrt(v.reduce((sum, e) => sum + e ** 2, 0));
21}
22
23function dotProduct(u, v) {
24  return u.reduce((sum, value, index) => sum + value * v[index], 0);
25}
26
27const u = [1, 2, 3];
28const v = [4, 5, 6];
29
30const theta = angle(u, v);
31console.log(theta);