gpmp::linalg::Tensor Class Reference

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

#include <tensor.hpp>

Public Member Functions
	Tensor ()
	Default constructor Creates an empty tensor. More...
	Tensor (const std::vector< size_t > &dimensions)
	Constructor with specified dimensions. More...
	Tensor (const std::vector< std::vector< std::vector< double >>> &data)
	Constructor with initial data. More...
Tensor	add (const Tensor &other) const
	Adds another tensor to the current tensor. More...
Tensor	multiply (double scalar) const
	Multiplies the tensor by a scalar value. More...
Tensor	multiply (const Tensor &other) const
	Multiplies the tensor by another tensor. More...
double	get (const std::vector< size_t > &indices) const
	Gets the value at the specified indices. More...
void	set (const std::vector< size_t > &indices, double value)
	Sets the value at the specified indices. More...
void	display () const
	Displays the tensor. More...

Private Attributes
std::vector< std::vector< std::vector< double > > >	data_
	< 3D vector representing the tensor data More...
size_t	dimensions_ [3]

Detailed Description

Represents a 3D tensor with basic operations.

This class provides basic operations for a 3D tensor, including addition, multiplication, element access, and display functionality

Definition at line 51 of file tensor.hpp.

Constructor & Destructor Documentation

Tensor() [1/3]

gpmp::linalg::Tensor::Tensor

(

)

Default constructor Creates an empty tensor.

Definition at line 38 of file tensor.cpp.

                         : data_({{{}}}), dimensions_{0, 0, 0} {
}

Tensor() [2/3]

gpmp::linalg::Tensor::Tensor ( const std::vector< size_t > &  dimensions )

explicit

Constructor with specified dimensions.

Parameters

dimensions

A vector containing three dimensions for the tensor

Exceptions

std::invalid_argument

if dimensions are empty

Constructs a tensor with specified dimensions and initializes the data

Definition at line 41 of file tensor.cpp.

                                                            {
    if (dimensions.empty()) {
        throw std::invalid_argument("Error: Tensor dimensions are empty.");
    }
 
    // Assign values to dimensions_
    for (size_t i = 0; i < 3; ++i) {
        dimensions_[i] = dimensions[i];
    }
 
    size_t totalSize = 1;
    for (size_t dim : dimensions) {
        totalSize *= dim;
    }
    data_ = std::vector<std::vector<std::vector<double>>>(
        dimensions_[0],
        std::vector<std::vector<double>>(
            dimensions_[1],
            std::vector<double>(dimensions_[2], 0.0)));
}

Tensor() [3/3]

gpmp::linalg::Tensor::Tensor

(

const std::vector< std::vector< std::vector< double >>> &

data

)

Constructor with initial data.

Parameters

data	3D vector representing the initial data for the tensor

Exceptions

std::invalid_argument

if data is empty

Constructs a tensor with the given initial data and sets dimensions accordingly

Definition at line 62 of file tensor.cpp.

    : data_(data) {
    if (data.empty() || data[0].empty()) {
        throw std::invalid_argument("Error: Tensor data is empty.");
    }
 
    dimensions_[0] = data.size();
    dimensions_[1] = data[0].size();
    dimensions_[2] = data[0][0].size();
}

References dimensions_.

Member Function Documentation

add()

gpmp::linalg::Tensor gpmp::linalg::Tensor::add

(

const Tensor &

other

)

const

Adds another tensor to the current tensor.

Parameters

other

Tensor to be added

Returns

A new tensor representing the sum

Exceptions

std::invalid_argument

if dimensions do not match

Definition at line 75 of file tensor.cpp.

                                                         {
    if (dimensions_[0] != other.dimensions_[0] ||
        dimensions_[1] != other.dimensions_[1] ||
        dimensions_[2] != other.dimensions_[2]) {
        throw std::invalid_argument(
            "Error: Tensor dimensions do not match for addition.");
    }
 
    gpmp::linalg::Tensor result;
    result.data_ = data_;
 
    for (size_t i = 0; i < dimensions_[0]; ++i) {
        for (size_t j = 0; j < dimensions_[1]; ++j) {
            for (size_t k = 0; k < dimensions_[2]; ++k) {
                result.data_[i][j][k] += other.data_[i][j][k];
            }
        }
    }
 
    return result;
}

References data_, and dimensions_.

display()

void gpmp::linalg::Tensor::display

(

)

const

Displays the tensor.

Definition at line 176 of file tensor.cpp.

                                     {
    for (size_t i = 0; i < dimensions_[0]; ++i) {
        for (size_t j = 0; j < dimensions_[1]; ++j) {
            for (size_t k = 0; k < dimensions_[2]; ++k) {
                std::cout << data_[i][j][k] << " ";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
}

get()

double gpmp::linalg::Tensor::get

(

const std::vector< size_t > &

indices

)

const

Gets the value at the specified indices.

Parameters

indices

Vector containing three indices

Returns

The value at the specified indices

Exceptions

std::out_of_range

if the number of indices is not 3 or if an index is out of bounds

Definition at line 143 of file tensor.cpp.

                                                                   {
    if (indices.size() != 3) {
        throw std::out_of_range(
            "Error: Invalid number of indices for tensor access.");
    }
 
    for (size_t i = 0; i < 3; ++i) {
        if (indices[i] >= dimensions_[i]) {
            throw std::out_of_range(
                "Error: Index out of bounds for tensor access.");
        }
    }
 
    return data_[indices[0]][indices[1]][indices[2]];
}

multiply() [1/2]

gpmp::linalg::Tensor gpmp::linalg::Tensor::multiply

(

const Tensor &

other

)

const

Multiplies the tensor by another tensor.

Parameters

other

Tensor to be multiplied

Returns

A new tensor representing the product

Exceptions

std::invalid_argument

if dimensions do not match

Definition at line 112 of file tensor.cpp.

                                                                     {
    if (dimensions_[2] != other.dimensions_[1]) {
        throw std::invalid_argument(
            "Error: Tensor dimensions do not match for multiplication.");
    }
 
    gpmp::linalg::Tensor result;
    result.dimensions_[0] = dimensions_[0];
    result.dimensions_[1] = dimensions_[1];
    result.dimensions_[2] = other.dimensions_[2];
 
    result.data_ = std::vector<std::vector<std::vector<double>>>(
        dimensions_[0],
        std::vector<std::vector<double>>(
            dimensions_[1],
            std::vector<double>(other.dimensions_[2], 0.0)));
 
    for (size_t i = 0; i < dimensions_[0]; ++i) {
        for (size_t j = 0; j < dimensions_[1]; ++j) {
            for (size_t k = 0; k < other.dimensions_[2]; ++k) {
                for (size_t l = 0; l < dimensions_[2]; ++l) {
                    result.data_[i][j][k] +=
                        data_[i][j][l] * other.data_[l][j][k];
                }
            }
        }
    }
 
    return result;
}

References data_, and dimensions_.

multiply() [2/2]

gpmp::linalg::Tensor gpmp::linalg::Tensor::multiply

(

double

scalar

)

const

Multiplies the tensor by a scalar value.

Parameters

scalar

The scalar value

Returns

A new tensor representing the product

Definition at line 97 of file tensor.cpp.

                                                               {
    gpmp::linalg::Tensor result;
    result.data_ = data_;
 
    for (size_t i = 0; i < dimensions_[0]; ++i) {
        for (size_t j = 0; j < dimensions_[1]; ++j) {
            for (size_t k = 0; k < dimensions_[2]; ++k) {
                result.data_[i][j][k] *= scalar;
            }
        }
    }
 
    return result;
}

References data_.

set()

void gpmp::linalg::Tensor::set	(	const std::vector< size_t > &	indices,
		double	value
	)

Sets the value at the specified indices.

Parameters

indices	Vector containing three indices
value	The value to set

Exceptions

std::out_of_range

if the number of indices is not 3 or if an index is out of bounds

Definition at line 159 of file tensor.cpp.

                                             {
    if (indices.size() != 3) {
        throw std::out_of_range(
            "Error: Invalid number of indices for tensor access.");
    }
 
    for (size_t i = 0; i < 3; ++i) {
        if (indices[i] >= dimensions_[i]) {
            throw std::out_of_range(
                "Error: Index out of bounds for tensor access.");
        }
    }
 
    data_[indices[0]][indices[1]][indices[2]] = value;
}

Member Data Documentation

data_

std::vector<std::vector<std::vector<double> > > gpmp::linalg::Tensor::data_

private

< 3D vector representing the tensor data

Array representing the dimensions of the tensor

Definition at line 125 of file tensor.hpp.

Referenced by add(), and multiply().

dimensions_

size_t gpmp::linalg::Tensor::dimensions_[3]

private

Definition at line 127 of file tensor.hpp.

Referenced by add(), multiply(), and Tensor().

---

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

• include/openGPMP/linalg/tensor.hpp
• modules/linalg/tensor.cpp