A utility class for performing operations on tensors and vectors. More...

#include <TensorOp.h>

Collaboration diagram for txeo::TensorOp< T >:

Public Member Functions
	TensorOp (const TensorOp &)=delete

	TensorOp (TensorOp &&)=delete

TensorOp &	operator= (const TensorOp &)=delete

TensorOp &	operator= (TensorOp &&)=delete

	~TensorOp ()=default

Static Public Member Functions
static txeo::Tensor< T >	sum (const txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Returns the sum of two tensors.

static txeo::Tensor< T > &	sum_by (txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Sums the left operand with the right operand (in-place)

static txeo::Tensor< T >	sum (const txeo::Tensor< T > &left, const T &right)
	Element-wise sum of tensor and scalar (out-of-place)

static txeo::Tensor< T > &	sum_by (txeo::Tensor< T > &left, const T &right)
	In-place element-wise addition of scalar to tensor.

static txeo::Tensor< T >	subtract (const txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Returns the subtraction of two tensors.

static txeo::Tensor< T > &	subtract_by (txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Subtracts the left operand by the right operand (in-place)

static txeo::Tensor< T >	subtract (const txeo::Tensor< T > &left, const T &right)
	Element-wise subtraction of scalar from tensor (out-of-place)

static txeo::Tensor< T > &	subtract_by (txeo::Tensor< T > &left, const T &right)
	In-place element-wise subtraction of scalar from tensor.

static txeo::Tensor< T >	subtract (const T &left, const txeo::Tensor< T > &right)
	Element-wise subtraction of tensor from scalar (out-of-place)

static const T &	subtract_by (const T &left, txeo::Tensor< T > &right)
	In-place element-wise subtraction of tensor from scalar.

static txeo::Tensor< T >	multiply (const txeo::Tensor< T > &left, const T &right)
	Returns the multiplication of a tensor and a scalar.

static txeo::Tensor< T > &	multiply_by (txeo::Tensor< T > &left, const T &right)
	Multiplies the tensor by a scalar (in-place)

static txeo::Tensor< T >	divide (const txeo::Tensor< T > &left, const T &right)
	Element-wise division of tensor by scalar (out-of-place)

static txeo::Tensor< T > &	divide_by (txeo::Tensor< T > &left, const T &right)
	In-place element-wise division of tensor by scalar.

static txeo::Tensor< T >	divide (const T &left, const txeo::Tensor< T > &right)
	Element-wise division of scalar by tensor (out-of-place)

static txeo::Tensor< T > &	divide_by (const T &scalar, txeo::Tensor< T > &tensor)
	In-place element-wise division of scalar by tensor elements.

static txeo::Tensor< T >	hadamard_prod (const txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Returns the element-wise product (Hadamard Product) of two tensors.

static txeo::Tensor< T > &	hadamard_prod_by (txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Performs element-wise multiplication of the left operand by the right operand (in-place)

static txeo::Tensor< T >	hadamard_div (const txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Element-wise Hadamard division (out-of-place)

static txeo::Tensor< T > &	hadamard_div_by (txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	In-place element-wise Hadamard division.

static T	inner (const txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Computes the inner product of two tensors.

static txeo::Tensor< T >	product_tensors (const txeo::Tensor< T > &left, const txeo::Tensor< T > &right)
	Computes the matrix product of two second order tensors.

static txeo::Matrix< T >	dot (const txeo::Matrix< T > &left, const txeo::Matrix< T > &right)
	Computes the matrix product of two matrices.

static txeo::Tensor< T >	dot (const txeo::Matrix< T > &left, const txeo::Vector< T > &right)
	Computes the matrix product of a matrix and a vector.

Detailed Description

template<typename T>
class txeo::TensorOp< T >

A utility class for performing operations on tensors and vectors.

This class provides static methods for common tensor and vector operations, such as dot product.

Template Parameters

T	The data type of the tensor/vector elements (e.g., int, double).

Definition at line 25 of file TensorOp.h.

Constructor & Destructor Documentation

◆ TensorOp() [1/2]

template<typename T >

txeo::TensorOp< T >::TensorOp ( const TensorOp< T > & )

delete

◆ TensorOp() [2/2]

template<typename T >

txeo::TensorOp< T >::TensorOp ( TensorOp< T > && )

delete

◆ ~TensorOp()

template<typename T >

txeo::TensorOp< T >::~TensorOp ( )

default

Member Function Documentation

◆ divide() [1/2]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::divide	(	const T &	left,
		const txeo::Tensor< T > &	right
	)

static

Element-wise division of scalar by tensor (out-of-place)

Parameters

left	Scalar dividend
right	Tensor divisor (shape NxMx...)

Returns: New tensor with same shape as input

Example Usage:

txeo::Tensor<int> A({3}, {2, 5, 10});
auto B = TensorOp<int>::divide(100, A);
// B contains [50, 20, 10], shape [3]

◆ divide() [2/2]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::divide	(	const txeo::Tensor< T > &	left,
		const T &	right
	)

static

Element-wise division of tensor by scalar (out-of-place)

Parameters

left	Dividend tensor
right	Scalar divisor

Returns: New tensor with division results

Example Usage:

txeo::Tensor<float> t({2, 2}, {10.0f, 20.0f, 30.0f, 40.0f});
auto result = TensorOp<float>::divide(t, 2.0f);
// result contains [5.0, 10.0, 15.0, 20.0]

◆ divide_by() [1/2]

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::divide_by	(	const T &	scalar,
		txeo::Tensor< T > &	tensor
	)

static

In-place element-wise division of scalar by tensor elements.

Parameters

scalar	Scalar dividend
tensor	Tensor divisor (modified with results)

Example Usage:

txeo::Tensor<int> t({4}, {2, 5, 10, 25});
TensorOp<int>::divide_by(100, t);
// t now contains [50, 20, 10, 4]

◆ divide_by() [2/2]

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::divide_by	(	txeo::Tensor< T > &	left,
		const T &	right
	)

static

In-place element-wise division of tensor by scalar.

Parameters

left	Tensor to modify (dividend)
right	Scalar divisor

Example Usage:

txeo::Tensor<double> t({3}, {15.0, 30.0, 45.0});
TensorOp<double>::divide_by(t, 3.0);
// t now contains [5.0, 10.0, 15.0]

◆ dot() [1/2]

template<typename T >

static txeo::Matrix< T > txeo::TensorOp< T >::dot	(	const txeo::Matrix< T > &	left,
		const txeo::Matrix< T > &	right
	)

static

Computes the matrix product of two matrices.

Parameters

left	The left matrix (m x n).
right	The right matrix (n x p).

Returns: A new matrix (m x p) containing the result of the matrix product.

Exceptions

txeo::TensorOpError

Example Usage:

txeo::Matrix<int> left(2, 3, {1, 2, 3, 4, 5, 6});  // 2x3 matrix
txeo::Matrix<int> right(3, 2, {7, 8, 9, 10, 11, 12});  // 3x2 matrix
auto result = TensorOp<int>::product(left, right);
// result = [ [58, 64], [139, 154] ]

◆ dot() [2/2]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::dot	(	const txeo::Matrix< T > &	left,
		const txeo::Vector< T > &	right
	)

static

Computes the matrix product of a matrix and a vector.

Parameters

left	The left matrix (m x n).
right	The right vector (n).

Returns: A new tensor (m x 1) containing the result of the matrix product.

Exceptions

txeo::TensorOpError

Example Usage:

txeo::Matrix<int> left(2, 3, {1, 2, 3, 4, 5, 6});  // 2x3 matrix
txeo::Vector<int> right(3, {7, 8, 9});  // vector of size 3
auto result = TensorOp<int>::product(left, right);

◆ hadamard_div()

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::hadamard_div	(	const txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Element-wise Hadamard division (out-of-place)

Parameters

left	Dividend tensor (shape NxMx...)
right	Divisor tensor (must match left's shape)

Returns: New tensor with same shape as inputs

Example Usage:

txeo::Tensor<float> A({2}, {10.0f, 20.0f});
txeo::Tensor<float> B({2}, {2.0f, 5.0f});
auto C = TensorOp<float>::hadamard_div(A, B);
// C contains [5.0, 4.0], shape [2]

◆ hadamard_div_by()

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::hadamard_div_by	(	txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

In-place element-wise Hadamard division.

Parameters

left	Dividend tensor (modified with results)
right	Divisor tensor

Example Usage:

txeo::Tensor<float> a({3}, {10.0f, 20.0f, 30.0f});
txeo::Tensor<float> b({3}, {2.0f, 5.0f, 10.0f});
TensorOp<float>::hadamard_div_by(a, b);
// a now contains [5.0, 4.0, 3.0]

◆ hadamard_prod()

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::hadamard_prod	(	const txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Returns the element-wise product (Hadamard Product) of two tensors.

Parameters

left	Left operand
right	Right operand

Returns: txeo::Tensor<T> Result

Exceptions

TensorOpError Thrown if shapes mismatch

Example Usage:

txeo::Tensor<float> a({2,2}, {1.0f, 2.0f, 3.0f, 4.0f});
txeo::Tensor<float> b({2,2}, {2.0f, 3.0f, 4.0f, 5.0f});
auto c = TensorOp<float>::hadamard_prod(a, b);  // Result: [[2,6],[12,20]]

◆ hadamard_prod_by()

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::hadamard_prod_by	(	txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Performs element-wise multiplication of the left operand by the right operand (in-place)

Parameters

left	Operand to be modified
right	Operand to multiply with

Exceptions

TensorOpError Thrown if shapes mismatch

Example Usage:

txeo::Tensor<double> a({3}, {2.0, 3.0, 4.0});
txeo::Tensor<double> b({3}, {5.0, 6.0, 7.0});
TensorOp<double>::hadamard_prod_by(a, b);  // a becomes [10.0, 18.0, 28.0]

◆ inner()

template<typename T >

static T txeo::TensorOp< T >::inner	(	const txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Computes the inner product of two tensors.

Parameters

left	The first tensor.
right	The second tensors.

Returns: The dot product of the two tensors.

Exceptions

txeo::TensorOpError

Example Usage:

txeo::Tensor<int> left({1, 2, 3});  // Tensor [1, 2, 3]
txeo::Tensor<int> right({4, 5, 6}); // Tensor [4, 5, 6]
auto result = TensorOp<int>::inner(left, right);
// result = 1*4 + 2*5 + 3*6 = 32

◆ multiply()

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::multiply	(	const txeo::Tensor< T > &	left,
		const T &	right
	)

static

Returns the multiplication of a tensor and a scalar.

Parameters

left	Tensor operand
right	Scalar multiplier

Returns: txeo::Tensor<T> Result

Example Usage:

txeo::Tensor<double> a({3}, {1.5, 2.5, 3.5});

auto b = TensorOp<double>::multiply(a, 2.0); // Result: [3.0, 5.0, 7.0]

txeo::TensorOp::multiply

static txeo::Tensor< T > multiply(const txeo::Tensor< T > &left, const T &right)

Returns the multiplication of a tensor and a scalar.

◆ multiply_by()

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::multiply_by	(	txeo::Tensor< T > &	left,
		const T &	right
	)

static

Multiplies the tensor by a scalar (in-place)

Parameters

left	Operand to be modified
right	Scalar multiplier

Example Usage:

txeo::Tensor<int> a({2,2}, {1, 2, 3, 4});

TensorOp<int>::multiply_by(a, 3); // a becomes [[3,6],[9,12]]

txeo::TensorOp::multiply_by

static txeo::Tensor< T > & multiply_by(txeo::Tensor< T > &left, const T &right)

Multiplies the tensor by a scalar (in-place)

◆ operator=() [1/2]

template<typename T >

TensorOp & txeo::TensorOp< T >::operator= ( const TensorOp< T > & )

delete

◆ operator=() [2/2]

template<typename T >

TensorOp & txeo::TensorOp< T >::operator= ( TensorOp< T > && )

delete

◆ product_tensors()

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::product_tensors	(	const txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Computes the matrix product of two second order tensors.

Parameters

left	The left tensor (m x n).
right	The right tensor (n x p).

Returns: A new tensor (m x p) containing the result of the matrix product.

Exceptions

txeo::TensorOpError

Example Usage:

txeo::Tensor<int> left({2, 3}, {1, 2, 3, 4, 5, 6});  // 2x3 tensor
txeo::Tensor<int> right({3, 2}, {7, 8, 9, 10, 11, 12});  // 3x2 tensor
auto result = TensorOp<int>::product_tensors(left, right);
// result = [ [58, 64], [139, 154] ]

◆ subtract() [1/3]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::subtract	(	const T &	left,
		const txeo::Tensor< T > &	right
	)

static

Element-wise subtraction of tensor from scalar (out-of-place)

Parameters

left	Scalar value
right	Tensor to subtract

Returns: New tensor where each element = left - right[i]

Example Usage:

txeo::Tensor<double> t({2}, {1.5, 3.0});
auto result = TensorOp<double>::subtract(10.0, t);
// result contains [8.5, 7.0] with shape [2]

◆ subtract() [2/3]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::subtract	(	const txeo::Tensor< T > &	left,
		const T &	right
	)

static

Element-wise subtraction of scalar from tensor (out-of-place)

Parameters

left	Input tensor (shape NxMx...)
right	Scalar value to subtract

Returns: New tensor with same shape as input

Example Usage:

txeo::Tensor<int> A({2, 2}, {10, 20, 30, 40});
auto B = TensorOp<int>::subtract(A, 5);
// B contains [5, 15, 25, 35], shape [2,2]

◆ subtract() [3/3]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::subtract	(	const txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Returns the subtraction of two tensors.

Parameters

left	Left operand
right	Right operand

Returns: txeo::Tensor<T> Result

Exceptions

TensorOpError Thrown if shapes mismatch

Example Usage:

txeo::Tensor<int> a({2}, {10, 20});
txeo::Tensor<int> b({2}, {3, 5});
auto c = TensorOp<int>::subtract(a, b);  // Result: [7, 15]

◆ subtract_by() [1/3]

template<typename T >

static const T & txeo::TensorOp< T >::subtract_by	(	const T &	left,
		txeo::Tensor< T > &	right
	)

static

In-place element-wise subtraction of tensor from scalar.

Parameters

left	Scalar value (minuend)
right	Tensor to modify (subtrahend)

Example Usage:

txeo::Tensor<int> t({3}, {2, 3, 4});
TensorOp<int>::subtract_by(10, t);
// t now contains [8, 7, 6]

◆ subtract_by() [2/3]

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::subtract_by	(	txeo::Tensor< T > &	left,
		const T &	right
	)

static

In-place element-wise subtraction of scalar from tensor.

Parameters

left	Tensor to modify
right	Scalar to subtract

Example Usage:

txeo::Tensor<float> t({3}, {5.5f, 6.6f, 7.7f});
TensorOp<float>::subtract_by(t, 2.2f);
// t now contains [3.3, 4.4, 5.5]

◆ subtract_by() [3/3]

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::subtract_by	(	txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Subtracts the left operand by the right operand (in-place)

Parameters

left	Operand to be modified
right	Operand to subtract

Exceptions

TensorOpError Thrown if shapes mismatch

Example Usage:

txeo::Tensor<float> a({2,2}, {5.0f, 10.0f, 15.0f, 20.0f});
txeo::Tensor<float> b({2,2}, {1.0f, 2.0f, 3.0f, 4.0f});
TensorOp<float>::subtract_by(a, b);  // a becomes [[4,8],[12,16]]

◆ sum() [1/2]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::sum	(	const txeo::Tensor< T > &	left,
		const T &	right
	)

static

Element-wise sum of tensor and scalar (out-of-place)

Parameters

left	Input tensor (shape NxMx...)
right	Scalar value to add

Returns: New tensor with same shape as input

Example Usage:

txeo::Tensor<float> A({3}, {1.0f, 2.0f, 3.0f});
auto B = TensorOp<float>::sum(A, 5.0f);
// B contains [6.0, 7.0, 8.0], shape [3]

◆ sum() [2/2]

template<typename T >

static txeo::Tensor< T > txeo::TensorOp< T >::sum	(	const txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Returns the sum of two tensors.

Parameters

left	Left operand
right	Right operand

Returns: txeo::Tensor<T> Result

Exceptions

TensorOpError Thrown if shapes mismatch

Example Usage:

txeo::Tensor<float> a({2,2}, {1.0f, 2.0f, 3.0f, 4.0f});
txeo::Tensor<float> b({2,2}, {5.0f, 6.0f, 7.0f, 8.0f});
auto c = TensorOp<float>::sum(a, b);  // Result: [[6,8],[10,12]]

◆ sum_by() [1/2]

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::sum_by	(	txeo::Tensor< T > &	left,
		const T &	right
	)

static

In-place element-wise addition of scalar to tensor.

Parameters

left	Tensor to modify
right	Scalar to add

Example Usage:

txeo::Tensor<int> t({2, 2}, {1, 2, 3, 4});
TensorOp<int>::sum_by(t, 5);
// t now contains [6, 7, 8, 9] with shape [2,2]

◆ sum_by() [2/2]

template<typename T >

static txeo::Tensor< T > & txeo::TensorOp< T >::sum_by	(	txeo::Tensor< T > &	left,
		const txeo::Tensor< T > &	right
	)

static

Sums the left operand with the right operand (in-place)

Parameters

left	Operand to be modified
right	Operand to add

Exceptions

TensorOpError Thrown if shapes mismatch

Example Usage:

txeo::Tensor<double> a({3}, {1.0, 2.0, 3.0});
txeo::Tensor<double> b({3}, {4.0, 5.0, 6.0});
TensorOp<double>::sum_by(a, b);  // a becomes [5.0, 7.0, 9.0]

The documentation for this class was generated from the following files:

include/txeo/Matrix.h
include/txeo/TensorOp.h

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ TensorOp() [1/2]

◆ TensorOp() [2/2]

◆ ~TensorOp()

Member Function Documentation

◆ divide() [1/2]

◆ divide() [2/2]

◆ divide_by() [1/2]

◆ divide_by() [2/2]

◆ dot() [1/2]

◆ dot() [2/2]

◆ hadamard_div()

◆ hadamard_div_by()

◆ hadamard_prod()

◆ hadamard_prod_by()

◆ inner()

◆ multiply()

◆ multiply_by()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ product_tensors()

◆ subtract() [1/3]

◆ subtract() [2/3]

◆ subtract() [3/3]

◆ subtract_by() [1/3]

◆ subtract_by() [2/3]

◆ subtract_by() [3/3]

◆ sum() [1/2]

◆ sum() [2/2]

◆ sum_by() [1/2]

◆ sum_by() [2/2]