Vector functions
A collection of essential vector operations that provide foundational functionality for numerical computation, machine learning, and data analysis. These operations include distance measurements, similarity coefficients, and other basic and complex operations related to vectors. Through understanding and implementing these functions, we can perform a wide variety of tasks ranging from data processing to advanced statistical analyses.
Function  Description 

vector::add()

Performs elementwise addition of two vectors 
vector::angle()

Computes the angle between two vectors 
vector::cross()

Computes the cross product of two vectors 
vector::divide()

Performs elementwise division between two vectors 
vector::dot()

Computes the dot product of two vectors 
vector::magnitude()

Computes the magnitude (or length) of a vector 
vector::multiply()

Performs elementwise multiplication of two vectors 
vector::normalize()

Computes the normalization of a vector 
vector::project()

Computes the projection of one vector onto another 
vector::subtract()

Performs elementwise subtraction between two vectors 
vector::distance::chebyshev()

Computes the Chebyshev distance 
vector::distance::euclidean()

Computes the Euclidean distance between two vectors 
vector::distance::hamming()

Computes the Hamming distance between two vectors 
vector::distance::manhattan()

Computes the Manhattan distance between two vectors 
vector::distance::minkowski()

Computes the Minkowski distance between two vectors 
vector::similarity::cosine()

Computes the Cosine similarity between two vectors 
vector::similarity::jaccard()

Computes the Jaccard similarity between two vectors 
vector::similarity::pearson()

Computes the Pearson correlation coefficient between two vectors 
vector::add
The vector::add
function performs elementwise addition of two vectors, where each element in the first vector is added to the corresponding element in the second vector.
vector::add(array, array) > array
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::add([1, 2, 3], [1, 2, 3]);
[2, 4, 6]
vector::angle
The vector::angle
function computes the angle between two vectors, providing a measure of the orientation difference between them.
vector::angle(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::angle([5, 10, 15], [10, 5, 20]);
0.36774908225917935f
vector::cross
The vector::cross
function computes the cross product of two vectors, which results in a vector that is orthogonal (perpendicular) to the plane containing the original vectors.
vector::cross(array, array) > array
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::cross([1, 2, 3], [4, 5, 6]);
[3, 6, 3]
vector::divide
The vector::divide
function performs elementwise division between two vectors, where each element in the first vector is divided by the corresponding element in the second vector.
vector::divide(array, array) > array
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::divide([10, 20, 30, 0], [0, 1, 2, 3]);
[NaN, 20, 15, 0]
vector::dot
The vector::dot
function computes the dot product of two vectors, which is the sum of the products of the corresponding entries of the two sequences of numbers.
vector::dot(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::dot([1, 2, 3], [1, 2, 3]);
14
vector::magnitude
The vector::magnitude
function computes the magnitude (or length) of a vector, providing a measure of the size of the vector in multidimensional space.
vector::magnitude(array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::magnitude([ 1, 2, 3, 3, 3, 4, 5 ]);
8.54400374531753f
vector::multiply
The vector::multiply
function performs elementwise multiplication of two vectors, where each element in the first vector is multiplied by the corresponding element in the second vector.
vector::multiply(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::multiply([1, 2, 3], [1, 2, 3]);
[1, 4, 9]
vector::normalize
The vector::normalize
function computes the normalization of a vector, transforming it to a unit vector (a vector of length 1) that maintains the original direction.
vector::normalize(array) > array
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::normalize([ 4, 3 ]);
[0.8f, 0.6f]
vector::project
The vector::project
function computes the normalization of a vector, transforming it to a unit vector (a vector of length 1) that maintains the original direction.
vector::project(array) > array
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::project([1, 2, 3], [4, 5, 6]);
[1.6623376623376624f, 2.077922077922078f, 2.4935064935064934f]
vector::subtract
The vector::subtract
function performs elementwise subtraction between two vectors, where each element in the second vector is subtracted from the corresponding element in the first vector.
vector::subtract(array, array) > array
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::subtract([4, 5, 6], [3, 2, 1]);
[1, 3, 5]
vector::distance::chebyshev
The vector::distance::chebyshev
function computes the Chebyshev distance (also known as maximum value distance) between two vectors, which is the greatest of their differences along any coordinate dimension.
vector::distance::chebyshev(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::distance::chebyshev([2, 4, 5, 3, 8, 2], [3, 1, 5, 3, 7, 2]);
6f
vector::distance::euclidean
The vector::distance::euclidean
function computes the Euclidean distance between two vectors, providing a measure of the straightline distance between two points in a multidimensional space.
vector::distance::euclidean(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::distance::euclidean([10, 50, 200], [400, 100, 20]);
432.43496620879307f
vector::distance::hamming
The vector::distance::hamming
function computes the Hamming distance between two vectors, measuring the minimum number of substitutions required to change one vector into the other, useful for comparing strings or codes.
vector::distance::hamming(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::distance::hamming([1, 2, 2], [1, 2, 3]);
1
vector::distance::manhattan
The vector::distance::manhattan
function computes the Manhattan distance (also known as the L1 norm or Taxicab geometry) between two vectors,
which is the sum of the absolute differences of their corresponding elements.
vector::distance::manhattan(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::distance::manhattan([10, 20, 15, 10, 5], [12, 24, 18, 8, 7]);
13
vector::distance::minkowski
The vector::distance::minkowski
function computes the Minkowski distance between two vectors,
a generalization of other distance metrics such as Euclidean and Manhattan
when parameterized with different values of p.
vector::distance::minkowski(array, array, number) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::distance::minkowski([10, 20, 15, 10, 5], [12, 24, 18, 8, 7], 3);
4.862944131094279f
vector::similarity::cosine
The vector::similarity::cosine
function computes the Cosine similarity between two vectors, indicating the cosine of the angle between them,
which is a measure of how closely two vectors are oriented to each other.
vector::similarity::cosine(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::similarity::cosine([10, 50, 200], [400, 100, 20]);
0.15258215962441316f
vector::similarity::jaccard
The vector::similarity::jaccard
function computes the Jaccard similarity between two vectors,
measuring the intersection divided by the union of the datasets represented by the vectors.
vector::similarity::jaccard(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::similarity::jaccard([0,1,2,5,6], [0,2,3,4,5,7,9]);
0.3333333333333333f
vector::similarity::pearson
The vector::similarity::pearson
function Computes the Pearson correlation coefficient between two vectors,
reflecting the degree of linear relationship between them.
vector::similarity::pearson(array, array) > number
The following example shows this function, and its output, when used in a RETURN
statement:
RETURN vector::similarity::pearson([1,2,3], [1,5,7]);
0.9819805060619659f