Classes
class	DGEMM
	Class for performing matrix multiplication on double type arrays. More...

class	IGEMM
	Class for performing matrix multiplication on int type arrays. More...

class	SGEMM
	Class for performing matrix multiplication on float type arrays. More...

class	Eigen
	Class for computing eigenvalues of a matrix. More...

class	LinSys
	Class for solving linear systems and performing matrix operations. More...

class	Mtx
	Mtx class offers matrix arithmetic operations. Some methods are element-wise while others make use of grouping and unrolling. More...

class	Matrix
	Matrix and Scalar operations. More...

struct	mtx
	Matrix struct. More...

class	SVD

class	Tensor
	Represents a 3D tensor with basic operations. More...

Functions
template<typename T >
void	vector_add_i8 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector addition for signed 8-bit integers. More...

template<typename T >
void	vector_add_i16 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector addition for signed 16-bit integers. More...

template<typename T >
void	vector_add_i32 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector addition for signed 32-bit integers. More...

template<typename T >
void	vector_add_i64 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector addition for signed 64-bit integers. More...

void	vector_add (const std::vector< int8_t > &vec1, const std::vector< int8_t > &vec2, std::vector< int8_t > &result)
	Performs vector addition for vectors of signed 8-bit integers. More...

void	vector_add (const std::vector< uint8_t > &vec1, const std::vector< uint8_t > &vec2, std::vector< uint8_t > &result)
	Performs vector addition for vectors of unsigned 8-bit integers. More...

void	vector_add (const std::vector< int16_t > &vec1, const std::vector< int16_t > &vec2, std::vector< int16_t > &result)
	Performs vector addition for vectors of signed 16-bit integers. More...

void	vector_add (const std::vector< uint16_t > &vec1, const std::vector< uint16_t > &vec2, std::vector< uint16_t > &result)
	Performs vector addition for vectors of unsigned 16-bit integers. More...

void	vector_add (const std::vector< int32_t > &vec1, const std::vector< int32_t > &vec2, std::vector< int32_t > &result)
	Performs vector addition for vectors of signed 32-bit integers. More...

void	vector_add (const std::vector< uint32_t > &vec1, const std::vector< uint32_t > &vec2, std::vector< uint32_t > &result)
	Performs vector addition for vectors of unsigned 32-bit integers. More...

void	vector_add (const std::vector< int64_t > &vec1, const std::vector< int64_t > &vec2, std::vector< int64_t > &result)
	Performs vector addition for vectors of signed 64-bit integers. More...

void	vector_add (const std::vector< uint64_t > &vec1, const std::vector< uint64_t > &vec2, std::vector< uint64_t > &result)
	Performs vector addition for vectors of unsigned 64-bit integers. More...

template<typename T >
void	vector_sub_i8 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector subtraction for signed 8-bit integers. More...

template<typename T >
void	vector_sub_i16 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector subtraction for signed 16-bit integers. More...

template<typename T >
void	vector_sub_i32 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector subtraction for signed 32-bit integers. More...

template<typename T >
void	vector_sub_i64 (const T data1, const T data2, T *result_data, size_t size)
	Performs vector subtraction for signed 64-bit integers. More...

void	vector_sub (const std::vector< int8_t > &vec1, const std::vector< int8_t > &vec2, std::vector< int8_t > &result)
	Performs vector subtraction for vectors of signed 8-bit integers. More...

void	vector_sub (const std::vector< uint8_t > &vec1, const std::vector< uint8_t > &vec2, std::vector< uint8_t > &result)
	Performs vector subtraction for vectors of unsigned 8-bit integers. More...

void	vector_sub (const std::vector< int16_t > &vec1, const std::vector< int16_t > &vec2, std::vector< int16_t > &result)
	Performs vector subtraction for vectors of signed 16-bit integers. More...

void	vector_sub (const std::vector< uint16_t > &vec1, const std::vector< uint16_t > &vec2, std::vector< uint16_t > &result)
	Performs vector subtraction for vectors of unsigned 16-bit integers. More...

void	vector_sub (const std::vector< int32_t > &vec1, const std::vector< int32_t > &vec2, std::vector< int32_t > &result)
	Performs vector subtraction for vectors of signed 32-bit integers. More...

void	vector_sub (const std::vector< uint32_t > &vec1, const std::vector< uint32_t > &vec2, std::vector< uint32_t > &result)
	Performs vector subtraction for vectors of unsigned 32-bit integers. More...

void	vector_sub (const std::vector< int64_t > &vec1, const std::vector< int64_t > &vec2, std::vector< int64_t > &result)
	Performs vector subtraction for vectors of signed 64-bit integers. More...

void	vector_sub (const std::vector< uint64_t > &vec1, const std::vector< uint64_t > &vec2, std::vector< uint64_t > &result)
	Performs vector subtraction for vectors of unsigned 64-bit integers. More...

template<typename T >
void	scalar_mult_i8 (const T data, int scalar, T result_data, size_t size)
	Performs scalar multiplication for signed 8-bit integers. More...

template<typename T >
void	scalar_mult_i16 (const T data, int scalar, T result_data, size_t size)
	Performs scalar multiplication for signed 16-bit integers. More...

template<typename T >
void	scalar_mult_i32 (const T data, int scalar, T result_data, size_t size)
	Performs scalar multiplication for signed 32-bit integers. More...

template<typename T >
void	scalar_mult_i64 (const T data, int scalar, T result_data, size_t size)
	Performs scalar multiplication for signed 64-bit integers. More...

void	scalar_mult (const std::vector< int8_t > &vec1, int scalar, std::vector< int8_t > &result)
	Performs scalar multiplication for vectors of signed 8-bit integers. More...

void	scalar_mult (const std::vector< uint8_t > &vec1, int scalar, std::vector< uint8_t > &result)
	Performs scalar multiplication for vectors of unsigned 8-bit integers. More...

void	scalar_mult (const std::vector< int16_t > &vec1, int scalar, std::vector< int16_t > &result)
	Performs scalar multiplication for vectors of signed 16-bit integers. More...

void	scalar_mult (const std::vector< uint16_t > &vec1, int scalar, std::vector< uint16_t > &result)
	Performs scalar multiplication for vectors of unsigned 16-bit integers. More...

void	scalar_mult (const std::vector< int32_t > &vec1, int scalar, std::vector< int32_t > &result)
	Performs scalar multiplication for vectors of signed 32-bit integers. More...

void	scalar_mult (const std::vector< uint32_t > &vec1, int scalar, std::vector< uint32_t > &result)
	Performs scalar multiplication for vectors of unsigned 32-bit integers. More...

void	scalar_mult (const std::vector< int64_t > &vec1, int scalar, std::vector< int64_t > &result)
	Performs scalar multiplication for vectors of signed 64-bit integers. More...

void	scalar_mult (const std::vector< uint64_t > &vec1, int scalar, std::vector< uint64_t > &result)
	Performs scalar multiplication for vectors of unsigned 64-bit integers. More...

template<typename T >
T	dot_product_i8 (const T vec1, const T vec2, size_t size)
	Computes the dot product for signed 8-bit integer vectors. More...

template<typename T >
T	dot_product_i16 (const T vec1, const T vec2, size_t size)
	Computes the dot product for signed 16-bit integer vectors. More...

template<typename T >
T	dot_product_i32 (const T vec1, const T vec2, size_t size)
	Computes the dot product for signed 32-bit integer vectors. More...

template<typename T >
T	dot_product_i64 (const T vec1, const T vec2, size_t size)
	Computes the dot product for signed 64-bit integer vectors. More...

int	dot_product (const std::vector< int8_t > &vec1, const std::vector< int8_t > &vec2)
	Computes the dot product for vectors of signed 8-bit integers. More...

int	dot_product (const std::vector< uint8_t > &vec1, const std::vector< uint8_t > &vec2)
	Computes the dot product for vectors of unsigned 8-bit integers. More...

int	dot_product (const std::vector< int16_t > &vec1, const std::vector< int16_t > &vec2)
	Computes the dot product for vectors of signed 16-bit integers. More...

int	dot_product (const std::vector< uint16_t > &vec1, const std::vector< uint16_t > &vec2)
	Computes the dot product for vectors of unsigned 16-bit integers. More...

int	dot_product (const std::vector< int32_t > &vec1, const std::vector< int32_t > &vec2)
	Computes the dot product for vectors of signed 32-bit integers. More...

int	dot_product (const std::vector< uint32_t > &vec1, const std::vector< uint32_t > &vec2)
	Computes the dot product for vectors of unsigned 32-bit integers. More...

int	dot_product (const std::vector< int64_t > &vec1, const std::vector< int64_t > &vec2)
	Computes the dot product for vectors of signed 64-bit integers. More...

int	dot_product (const std::vector< uint64_t > &vec1, const std::vector< uint64_t > &vec2)
	Computes the dot product for vectors of unsigned 64-bit integers. More...

void	vector_add (const std::vector< double > &vec1, const std::vector< double > &vec2, std::vector< double > &result)
	Performs vector addition for double vectors. More...

void	vector_sub (const std::vector< double > &vec1, const std::vector< double > &vec2, std::vector< double > &result)
	Performs vector subtraction for double vectors. More...

void	scalar_mult (const std::vector< double > &vec, double scalar, std::vector< double > &result)
	Performs scalar multiplication for double vectors. More...

double	dot_product (const std::vector< double > &vec1, const std::vector< double > &vec2)
	Computes the dot product of two double vectors. More...

template<typename T >
void	std_vector_add (const std::vector< T > &vec1, const std::vector< T > &vec2, std::vector< T > &result)
	Add two vectors element-wise. More...

template<typename T >
void	std_vector_sub (const std::vector< T > &vec1, const std::vector< T > &vec2, std::vector< T > &result)
	Subtract one vector from another element-wise. More...

template<typename T >
void	std_scalar_mult (const std::vector< T > &vec, int scalar, std::vector< T > &result)
	Multiply each element of a vector by a scalar. More...

template<typename T >
T	std_dot_product (const std::vector< T > &vec1, const std::vector< T > &vec2)
	Compute the dot product of two vectors. More...

void	std_cross_product (const std::vector< double > &vec1, const std::vector< double > &vec2, std::vector< double > &result)
	Compute the cross product of two 3D vectors. More...

double	std_vector_norm (const std::vector< double > &vec)
	Compute the Euclidean norm (magnitude) of a vector. More...

void	std_vector_normalize (const std::vector< double > &vec, std::vector< double > &result)
	Normalize a vector to have unit length. More...

void	std_vector_projection (const std::vector< double > &vec, const std::vector< double > &onto_vec, std::vector< double > &result)
	Compute the projection of one vector onto another. More...

void	std_cross_product (const std::vector< int > &vec1, const std::vector< int > &vec2, std::vector< int > &result)
	Compute the cross product of two 3D vectors of integers. More...

double	std_vector_norm (const std::vector< int > &vec)
	Compute the Euclidean norm (magnitude) of a vector of integers. More...

void	std_vector_normalize (const std::vector< int > &vec, std::vector< double > &result)
	Normalize a vector of integers to have unit length. More...

void	std_vector_projection (const std::vector< int > &vec, const std::vector< int > &onto_vec, std::vector< double > &result)
	Compute the projection of one vector of integers onto another. More...

Function Documentation

◆ dot_product() [1/9]

double gpmp::linalg::dot_product	(	const std::vector< double > &	vec1,
		const std::vector< double > &	vec2
	)

Computes the dot product of two double vectors.

This function computes the dot product of two double vectors

Parameters

vec1	The first input vector
vec2	The second input vector

Returns: The dot product of the two input vectors

◆ dot_product() [2/9]

int gpmp::linalg::dot_product	(	const std::vector< int16_t > &	vec1,
		const std::vector< int16_t > &	vec2
	)

Computes the dot product for vectors of signed 16-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product() [3/9]

int gpmp::linalg::dot_product	(	const std::vector< int32_t > &	vec1,
		const std::vector< int32_t > &	vec2
	)

Computes the dot product for vectors of signed 32-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product() [4/9]

int gpmp::linalg::dot_product	(	const std::vector< int64_t > &	vec1,
		const std::vector< int64_t > &	vec2
	)

Computes the dot product for vectors of signed 64-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product() [5/9]

int gpmp::linalg::dot_product	(	const std::vector< int8_t > &	vec1,
		const std::vector< int8_t > &	vec2
	)

Computes the dot product for vectors of signed 8-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

Referenced by gpmp::ml::SVC::kernel(), gpmp::optim::QuasiNewton::line_search(), and gpmp::optim::QuasiNewton::update_hessian_inverse().

◆ dot_product() [6/9]

int gpmp::linalg::dot_product	(	const std::vector< uint16_t > &	vec1,
		const std::vector< uint16_t > &	vec2
	)

Computes the dot product for vectors of unsigned 16-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product() [7/9]

int gpmp::linalg::dot_product	(	const std::vector< uint32_t > &	vec1,
		const std::vector< uint32_t > &	vec2
	)

Computes the dot product for vectors of unsigned 32-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product() [8/9]

int gpmp::linalg::dot_product	(	const std::vector< uint64_t > &	vec1,
		const std::vector< uint64_t > &	vec2
	)

Computes the dot product for vectors of unsigned 64-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product() [9/9]

int gpmp::linalg::dot_product	(	const std::vector< uint8_t > &	vec1,
		const std::vector< uint8_t > &	vec2
	)

Computes the dot product for vectors of unsigned 8-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector

Returns: Dot product of the input vectors

◆ dot_product_i16()

template<typename T >

T gpmp::linalg::dot_product_i16	(	const T *	vec1,
		const T *	vec2,
		size_t	size
	)

Computes the dot product for signed 16-bit integer vectors.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

vec1	Pointer to the first input vector
vec2	Pointer to the second input vector
size	Size of the input vectors

Returns: Dot product of the input vectors

◆ dot_product_i32()

template<typename T >

T gpmp::linalg::dot_product_i32	(	const T *	vec1,
		const T *	vec2,
		size_t	size
	)

Computes the dot product for signed 32-bit integer vectors.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

vec1	Pointer to the first input vector
vec2	Pointer to the second input vector
size	Size of the input vectors

Returns: Dot product of the input vectors

◆ dot_product_i64()

template<typename T >

T gpmp::linalg::dot_product_i64	(	const T *	vec1,
		const T *	vec2,
		size_t	size
	)

Computes the dot product for signed 64-bit integer vectors.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

vec1	Pointer to the first input vector
vec2	Pointer to the second input vector
size	Size of the input vectors

Returns: Dot product of the input vectors

◆ dot_product_i8()

template<typename T >

T gpmp::linalg::dot_product_i8	(	const T *	vec1,
		const T *	vec2,
		size_t	size
	)

Computes the dot product for signed 8-bit integer vectors.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

vec1	Pointer to the first input vector
vec2	Pointer to the second input vector
size	Size of the input vectors

Returns: Dot product of the input vectors

◆ scalar_mult() [1/9]

void gpmp::linalg::scalar_mult	(	const std::vector< double > &	vec,
		double	scalar,
		std::vector< double > &	result
	)

Performs scalar multiplication for double vectors.

This function multiplies each element of a double vector by a scalar value and stores the result in the provided result vector

Parameters

vec	The input vector
scalar	The scalar value to multiply each element by
result	The vector where the result of the multiplication will be stored

◆ scalar_mult() [2/9]

void gpmp::linalg::scalar_mult	(	const std::vector< int16_t > &	vec1,
		int	scalar,
		std::vector< int16_t > &	result
	)

Performs scalar multiplication for vectors of signed 16-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [3/9]

void gpmp::linalg::scalar_mult	(	const std::vector< int32_t > &	vec1,
		int	scalar,
		std::vector< int32_t > &	result
	)

Performs scalar multiplication for vectors of signed 32-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [4/9]

void gpmp::linalg::scalar_mult	(	const std::vector< int64_t > &	vec1,
		int	scalar,
		std::vector< int64_t > &	result
	)

Performs scalar multiplication for vectors of signed 64-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [5/9]

void gpmp::linalg::scalar_mult	(	const std::vector< int8_t > &	vec1,
		int	scalar,
		std::vector< int8_t > &	result
	)

Performs scalar multiplication for vectors of signed 8-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [6/9]

void gpmp::linalg::scalar_mult	(	const std::vector< uint16_t > &	vec1,
		int	scalar,
		std::vector< uint16_t > &	result
	)

Performs scalar multiplication for vectors of unsigned 16-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [7/9]

void gpmp::linalg::scalar_mult	(	const std::vector< uint32_t > &	vec1,
		int	scalar,
		std::vector< uint32_t > &	result
	)

Performs scalar multiplication for vectors of unsigned 32-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [8/9]

void gpmp::linalg::scalar_mult	(	const std::vector< uint64_t > &	vec1,
		int	scalar,
		std::vector< uint64_t > &	result
	)

Performs scalar multiplication for vectors of unsigned 64-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult() [9/9]

void gpmp::linalg::scalar_mult	(	const std::vector< uint8_t > &	vec1,
		int	scalar,
		std::vector< uint8_t > &	result
	)

Performs scalar multiplication for vectors of unsigned 8-bit integers.

Parameters

vec1	Input vector
scalar	Scalar value to multiply each element by
result	Output vector containing the result of the multiplication

◆ scalar_mult_i16()

template<typename T >

void gpmp::linalg::scalar_mult_i16	(	const T *	data,
		int	scalar,
		T *	result_data,
		size_t	size
	)

Performs scalar multiplication for signed 16-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data	Pointer to the input data array
scalar	Scalar value to multiply each element by
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ scalar_mult_i32()

template<typename T >

void gpmp::linalg::scalar_mult_i32	(	const T *	data,
		int	scalar,
		T *	result_data,
		size_t	size
	)

Performs scalar multiplication for signed 32-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data	Pointer to the input data array
scalar	Scalar value to multiply each element by
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ scalar_mult_i64()

template<typename T >

void gpmp::linalg::scalar_mult_i64	(	const T *	data,
		int	scalar,
		T *	result_data,
		size_t	size
	)

Performs scalar multiplication for signed 64-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data	Pointer to the input data array
scalar	Scalar value to multiply each element by
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ scalar_mult_i8()

template<typename T >

void gpmp::linalg::scalar_mult_i8	(	const T *	data,
		int	scalar,
		T *	result_data,
		size_t	size
	)

Performs scalar multiplication for signed 8-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data	Pointer to the input data array
scalar	Scalar value to multiply each element by
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ std_cross_product() [1/2]

void gpmp::linalg::std_cross_product	(	const std::vector< double > &	vec1,
		const std::vector< double > &	vec2,
		std::vector< double > &	result
	)

Compute the cross product of two 3D vectors.

This function computes the cross product of two 3D vectors and stores the result in the output vector

Parameters

vec1	The first vector
vec2	The second vector
result	The output vector where the result will be stored

Definition at line 48 of file vector_naive.cpp.

                                                                 {
     result[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
     result[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
     result[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
 }

◆ std_cross_product() [2/2]

void gpmp::linalg::std_cross_product	(	const std::vector< int > &	vec1,
		const std::vector< int > &	vec2,
		std::vector< int > &	result
	)

Compute the cross product of two 3D vectors of integers.

This function computes the cross product of two 3D vectors of integers and stores the result in the output vector

Parameters

vec1	The first vector of integers
vec2	The second vector of integers
result	The output vector where the result will be stored

Definition at line 88 of file vector_naive.cpp.

                                                              {
     result.resize(3);
     result[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
     result[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
     result[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
 }

◆ std_dot_product()

template<typename T >

T gpmp::linalg::std_dot_product	(	const std::vector< T > &	vec1,
		const std::vector< T > &	vec2
	)

Compute the dot product of two vectors.

This function computes the dot product of two vectors

Parameters

vec1	The first vector
vec2	The second vector

Returns: The dot product of the two input vectors

Definition at line 681 of file vector.hpp.

                                                                       {
     T result = 0;
     for (size_t i = 0; i < vec1.size(); ++i) {
         result += vec1[i] * vec2[i];
     }
     return result;
 }

Referenced by std_vector_projection().

◆ std_scalar_mult()

template<typename T >

void gpmp::linalg::std_scalar_mult	(	const std::vector< T > &	vec,
		int	scalar,
		std::vector< T > &	result
	)

Multiply each element of a vector by a scalar.

This function multiplies each element of a vector by a scalar value and stores the result in the output vector

Parameters

vec	The input vector
scalar	The scalar value to multiply with
result	The output vector where the result will be stored

Definition at line 662 of file vector.hpp.

                                            {
     result.resize(vec.size());
     for (size_t i = 0; i < vec.size(); ++i) {
         result[i] = vec[i] * scalar;
     }
 }

◆ std_vector_add()

template<typename T >

void gpmp::linalg::std_vector_add	(	const std::vector< T > &	vec1,
		const std::vector< T > &	vec2,
		std::vector< T > &	result
	)

Add two vectors element-wise.

This function calculates the element-wise addition of two vectors and stores the result in the output vector

Parameters

vec1	The first vector
vec2	The second vector
result	The output vector where the result will be stored

Definition at line 622 of file vector.hpp.

                                           {
     result.resize(vec1.size());
     for (size_t i = 0; i < vec1.size(); ++i) {
         result[i] = vec1[i] + vec2[i];
     }
 }

◆ std_vector_norm() [1/2]

double gpmp::linalg::std_vector_norm ( const std::vector< double > & vec )

Compute the Euclidean norm (magnitude) of a vector.

This function computes the Euclidean norm (magnitude) of a vector

Parameters

vec	The input vector

Returns: The Euclidean norm of the input vector

Definition at line 56 of file vector_naive.cpp.

                                                                {
     double norm = 0.0;
     for (double value : vec) {
         norm += value * value;
     }
     return std::sqrt(norm);
 }

Referenced by std_vector_normalize().

◆ std_vector_norm() [2/2]

double gpmp::linalg::std_vector_norm ( const std::vector< int > & vec )

Compute the Euclidean norm (magnitude) of a vector of integers.

This function computes the Euclidean norm (magnitude) of a vector of integers

Parameters

vec	The input vector of integers

Returns: The Euclidean norm of the input vector

Definition at line 97 of file vector_naive.cpp.

                                                             {
     double norm = 0.0;
     for (int value : vec) {
         norm += value * value;
     }
     return std::sqrt(norm);
 }

◆ std_vector_normalize() [1/2]

void gpmp::linalg::std_vector_normalize	(	const std::vector< double > &	vec,
		std::vector< double > &	result
	)

Normalize a vector to have unit length.

This function normalizes a vector to have unit length

Parameters

vec	The input vector
result	The output vector where the normalized vector will be stored

Definition at line 65 of file vector_naive.cpp.

                                                                    {
     double norm = gpmp::linalg::std_vector_norm(vec);
     result.resize(vec.size());
     for (size_t i = 0; i < vec.size(); ++i) {
         result[i] = vec[i] / norm;
     }
 }

References std_vector_norm().

◆ std_vector_normalize() [2/2]

void gpmp::linalg::std_vector_normalize	(	const std::vector< int > &	vec,
		std::vector< double > &	result
	)

Normalize a vector of integers to have unit length.

This function normalizes a vector of integers to have unit length

Parameters

vec	The input vector of integers
result	The output vector where the normalized vector will be stored

Definition at line 106 of file vector_naive.cpp.

                                                                    {
     double norm = std_vector_norm(vec);
     result.resize(vec.size());
     for (size_t i = 0; i < vec.size(); ++i) {
         result[i] = static_cast<double>(vec[i]) / norm;
     }
 }

References std_vector_norm().

◆ std_vector_projection() [1/2]

void gpmp::linalg::std_vector_projection	(	const std::vector< double > &	vec,
		const std::vector< double > &	onto_vec,
		std::vector< double > &	result
	)

Compute the projection of one vector onto another.

This function computes the projection of one vector onto another and stores the result in the output vector

Parameters

vec	The vector to project
onto_vec	The vector onto which to project
result	The output vector where the projected vector will be stored

Definition at line 75 of file vector_naive.cpp.

                                                                     {
     double dot = std_dot_product(vec, onto_vec);
     double onto_vec_norm_sq = std_dot_product(onto_vec, onto_vec);
  
     result.resize(onto_vec.size());
     for (size_t i = 0; i < onto_vec.size(); ++i) {
         result[i] = (dot / onto_vec_norm_sq) * onto_vec[i];
     }
 }

References std_dot_product().

◆ std_vector_projection() [2/2]

void gpmp::linalg::std_vector_projection	(	const std::vector< int > &	vec,
		const std::vector< int > &	onto_vec,
		std::vector< double > &	result
	)

Compute the projection of one vector of integers onto another.

This function computes the projection of one vector of integers onto another and stores the result in the output vector

Parameters

vec	The vector of integers to project
onto_vec	The vector of integers onto which to project
result	The output vector where the projected vector will be stored

Definition at line 116 of file vector_naive.cpp.

                                                                     {
     double dot = std_dot_product(vec, onto_vec);
     double onto_vec_norm_sq = std_dot_product(onto_vec, onto_vec);
  
     result.resize(onto_vec.size());
     for (size_t i = 0; i < onto_vec.size(); ++i) {
         result[i] = (dot / onto_vec_norm_sq) * onto_vec[i];
     }
 }

References std_dot_product().

◆ std_vector_sub()

template<typename T >

void gpmp::linalg::std_vector_sub	(	const std::vector< T > &	vec1,
		const std::vector< T > &	vec2,
		std::vector< T > &	result
	)

Subtract one vector from another element-wise.

This function calculates the element-wise subtraction of one vector from another and stores the result in the output vector

Parameters

vec1	The vector to subtract from
vec2	The vector to subtract
result	The output vector where the result will be stored

Definition at line 642 of file vector.hpp.

                                           {
     result.resize(vec1.size());
     for (size_t i = 0; i < vec1.size(); ++i) {
         result[i] = vec1[i] - vec2[i];
     }
 }

◆ vector_add() [1/9]

void gpmp::linalg::vector_add	(	const std::vector< double > &	vec1,
		const std::vector< double > &	vec2,
		std::vector< double > &	result
	)

Performs vector addition for double vectors.

This function adds corresponding elements of two double vectors and stores the result in the provided result vector

Parameters

vec1	The first input vector
vec2	The second input vector
result	The vector where the result of the addition will be stored

◆ vector_add() [2/9]

void gpmp::linalg::vector_add	(	const std::vector< int16_t > &	vec1,
		const std::vector< int16_t > &	vec2,
		std::vector< int16_t > &	result
	)

Performs vector addition for vectors of signed 16-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [3/9]

void gpmp::linalg::vector_add	(	const std::vector< int32_t > &	vec1,
		const std::vector< int32_t > &	vec2,
		std::vector< int32_t > &	result
	)

Performs vector addition for vectors of signed 32-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [4/9]

void gpmp::linalg::vector_add	(	const std::vector< int64_t > &	vec1,
		const std::vector< int64_t > &	vec2,
		std::vector< int64_t > &	result
	)

Performs vector addition for vectors of signed 64-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [5/9]

void gpmp::linalg::vector_add	(	const std::vector< int8_t > &	vec1,
		const std::vector< int8_t > &	vec2,
		std::vector< int8_t > &	result
	)

Performs vector addition for vectors of signed 8-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [6/9]

void gpmp::linalg::vector_add	(	const std::vector< uint16_t > &	vec1,
		const std::vector< uint16_t > &	vec2,
		std::vector< uint16_t > &	result
	)

Performs vector addition for vectors of unsigned 16-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [7/9]

void gpmp::linalg::vector_add	(	const std::vector< uint32_t > &	vec1,
		const std::vector< uint32_t > &	vec2,
		std::vector< uint32_t > &	result
	)

Performs vector addition for vectors of unsigned 32-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [8/9]

void gpmp::linalg::vector_add	(	const std::vector< uint64_t > &	vec1,
		const std::vector< uint64_t > &	vec2,
		std::vector< uint64_t > &	result
	)

Performs vector addition for vectors of unsigned 64-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add() [9/9]

void gpmp::linalg::vector_add	(	const std::vector< uint8_t > &	vec1,
		const std::vector< uint8_t > &	vec2,
		std::vector< uint8_t > &	result
	)

Performs vector addition for vectors of unsigned 8-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the addition

◆ vector_add_i16()

template<typename T >

void gpmp::linalg::vector_add_i16	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector addition for signed 16-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_add_i32()

template<typename T >

void gpmp::linalg::vector_add_i32	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector addition for signed 32-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_add_i64()

template<typename T >

void gpmp::linalg::vector_add_i64	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector addition for signed 64-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_add_i8()

template<typename T >

void gpmp::linalg::vector_add_i8	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector addition for signed 8-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_sub() [1/9]

void gpmp::linalg::vector_sub	(	const std::vector< double > &	vec1,
		const std::vector< double > &	vec2,
		std::vector< double > &	result
	)

Performs vector subtraction for double vectors.

This function subtracts corresponding elements of two double vectors and stores the result in the provided result vector

Parameters

vec1	The first input vector
vec2	The second input vector
result	The vector where the result of the subtraction will be stored

◆ vector_sub() [2/9]

void gpmp::linalg::vector_sub	(	const std::vector< int16_t > &	vec1,
		const std::vector< int16_t > &	vec2,
		std::vector< int16_t > &	result
	)

Performs vector subtraction for vectors of signed 16-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [3/9]

void gpmp::linalg::vector_sub	(	const std::vector< int32_t > &	vec1,
		const std::vector< int32_t > &	vec2,
		std::vector< int32_t > &	result
	)

Performs vector subtraction for vectors of signed 32-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [4/9]

void gpmp::linalg::vector_sub	(	const std::vector< int64_t > &	vec1,
		const std::vector< int64_t > &	vec2,
		std::vector< int64_t > &	result
	)

Performs vector subtraction for vectors of signed 64-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [5/9]

void gpmp::linalg::vector_sub	(	const std::vector< int8_t > &	vec1,
		const std::vector< int8_t > &	vec2,
		std::vector< int8_t > &	result
	)

Performs vector subtraction for vectors of signed 8-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [6/9]

void gpmp::linalg::vector_sub	(	const std::vector< uint16_t > &	vec1,
		const std::vector< uint16_t > &	vec2,
		std::vector< uint16_t > &	result
	)

Performs vector subtraction for vectors of unsigned 16-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [7/9]

void gpmp::linalg::vector_sub	(	const std::vector< uint32_t > &	vec1,
		const std::vector< uint32_t > &	vec2,
		std::vector< uint32_t > &	result
	)

Performs vector subtraction for vectors of unsigned 32-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [8/9]

void gpmp::linalg::vector_sub	(	const std::vector< uint64_t > &	vec1,
		const std::vector< uint64_t > &	vec2,
		std::vector< uint64_t > &	result
	)

Performs vector subtraction for vectors of unsigned 64-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub() [9/9]

void gpmp::linalg::vector_sub	(	const std::vector< uint8_t > &	vec1,
		const std::vector< uint8_t > &	vec2,
		std::vector< uint8_t > &	result
	)

Performs vector subtraction for vectors of unsigned 8-bit integers.

Parameters

vec1	First input vector
vec2	Second input vector
result	Output vector containing the result of the subtraction

◆ vector_sub_i16()

template<typename T >

void gpmp::linalg::vector_sub_i16	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector subtraction for signed 16-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_sub_i32()

template<typename T >

void gpmp::linalg::vector_sub_i32	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector subtraction for signed 32-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_sub_i64()

template<typename T >

void gpmp::linalg::vector_sub_i64	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector subtraction for signed 64-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

◆ vector_sub_i8()

template<typename T >

void gpmp::linalg::vector_sub_i8	(	const T *	data1,
		const T *	data2,
		T *	result_data,
		size_t	size
	)

Performs vector subtraction for signed 8-bit integers.

Template Parameters

T	The type of the data (int8_t, uint8_t, etc )

Parameters

data1	Pointer to the first input data array
data2	Pointer to the second input data array
result_data	Pointer to the output data array
size	Size of the input and output arrays

Classes

Functions

Function Documentation

◆ dot_product() [1/9]

◆ dot_product() [2/9]

◆ dot_product() [3/9]

◆ dot_product() [4/9]

◆ dot_product() [5/9]

◆ dot_product() [6/9]

◆ dot_product() [7/9]

◆ dot_product() [8/9]

◆ dot_product() [9/9]

◆ dot_product_i16()

◆ dot_product_i32()

◆ dot_product_i64()

◆ dot_product_i8()

◆ scalar_mult() [1/9]

◆ scalar_mult() [2/9]

◆ scalar_mult() [3/9]

◆ scalar_mult() [4/9]

◆ scalar_mult() [5/9]

◆ scalar_mult() [6/9]

◆ scalar_mult() [7/9]

◆ scalar_mult() [8/9]

◆ scalar_mult() [9/9]

◆ scalar_mult_i16()

◆ scalar_mult_i32()

◆ scalar_mult_i64()

◆ scalar_mult_i8()

◆ std_cross_product() [1/2]

◆ std_cross_product() [2/2]

◆ std_dot_product()

◆ std_scalar_mult()

◆ std_vector_add()

◆ std_vector_norm() [1/2]

◆ std_vector_norm() [2/2]

◆ std_vector_normalize() [1/2]

◆ std_vector_normalize() [2/2]

◆ std_vector_projection() [1/2]

◆ std_vector_projection() [2/2]

◆ std_vector_sub()

◆ vector_add() [1/9]

◆ vector_add() [2/9]

◆ vector_add() [3/9]

◆ vector_add() [4/9]

◆ vector_add() [5/9]

◆ vector_add() [6/9]

◆ vector_add() [7/9]

◆ vector_add() [8/9]

◆ vector_add() [9/9]

◆ vector_add_i16()

◆ vector_add_i32()

◆ vector_add_i64()

◆ vector_add_i8()

◆ vector_sub() [1/9]

◆ vector_sub() [2/9]

◆ vector_sub() [3/9]

◆ vector_sub() [4/9]

◆ vector_sub() [5/9]

◆ vector_sub() [6/9]

◆ vector_sub() [7/9]

◆ vector_sub() [8/9]

◆ vector_sub() [9/9]

◆ vector_sub_i16()

◆ vector_sub_i32()

◆ vector_sub_i64()

◆ vector_sub_i8()