Class tensor (o2scl)¶

O2scl : Class List

template<class data_t = double, class vec_t = std::vector<data_t>, class vec_size_t = std::vector<size_t>> class tensor¶

Tensor class with arbitrary dimensions.

The elements of a tensor are typically specified as a list of size_t numbers with length equal to the tensor rank. For a rank-4 tensor named t, the element t[1][2][0][3] can be obtained with something similar to

size_t ix[4]={1,2,0,3};
double x=t.get(ix);

Empty tensors have zero rank.

The type vec_t can be any vector type with operator[], size() and resize() methods. The type vec_size_t can be any integer-like vector type with operator[], size() and resize() methods.

For I/O with tensors, see o2scl_hdf::hdf_file::setd_ten() and o2scl_hdf::hdf_file::getd_ten() .

See the the discussion in the sections Tensors and I/O and contiguous storage of the User’s Guide for more details.

The storage pattern is a generalization of row-major order. In the case of a 4-rank tensor, the location of a generic element is

\[ \left( \left( i_0 s_1 + i_1 \right) s_2 + i_2 \right) s_3 + i_3 \, . \]

In this case the distance between two elements \((i_0,i_1, i_2,i_3)\) and \( (i_0+1,i_1,i_2,i_3) \) is \( s_1 s_2 s_3 \), the distance between two elements \((i_0,i_1,i_2, i_3)\) and \( (i_0,i_1+1,i_2,i_3) \) is \( s_2 s_3 \), and the elements \((i_0,i_1,i_2,i_3)\) and \( (i_0,i_1,i_2,i_3+1) \) are adjacent.

Todo

In class tensor:

Future: Create an operator[] for tensor and not just tensor1?
Future: Could implement arithmetic operators + and - and some different products.
Future: Implement copies to and from vector and matrices
Future: Implement tensor contractions, i.e. tensor = tensor * tensor
Future: Could be interesting to write an iterator for this class.
Future: Try character and string tensors?

Note

Slices of tensors are subsets obtained from fixing the index of several dimensions, while letting other dimensions vary. For a slice with one dimension not fixed, see vector_slice(). The o2scl::tensor::vector_slice() function should clearly work for uBlas vectors, and seems to work with std::vector objects also, but latter use has not been fully tested.

Subclassed by o2scl::tensor_grid< std::vector< double >, std::vector< size_t > >, o2scl::tensor1< data_t, vec_t, vec_size_t >, o2scl::tensor2< data_t, vec_t, vec_size_t >, o2scl::tensor3< data_t, vec_t, vec_size_t >, o2scl::tensor4< data_t, vec_t, vec_size_t >, o2scl::tensor_grid< vec_t, vec_size_t >

Get functions

typedef boost::numeric::ublas::vector_slice<boost::numeric::ublas::vector<data_t>> ubvector_slice¶

typedef boost::numeric::ublas::vector_slice<const boost::numeric::ublas::vector<data_t>> const_ubvector_slice¶

typedef boost::numeric::ublas::slice slice¶

template<class size_vec_t> inline data_t &get(const size_vec_t &index)¶: Get the element indexed by index.

template<class size_vec_t> inline data_t const &get(const size_vec_t &index) const¶: Get a const reference to the element indexed by index.

Method to check for valid object

inline void is_valid() const¶: Check that the o2scl::tensor object is valid.

Copy constructors

inline tensor(const tensor<data_t, vec_t, vec_size_t> &t)¶: Copy using operator()

inline tensor<data_t, vec_t, vec_size_t> &operator=(const tensor<data_t, vec_t, vec_size_t> &t)¶: Copy using operator=()

Clear method

inline void clear()¶: Clear the tensor of all data and free allocated memory.

Set functions

template<class size_vec_t> inline void set(const size_vec_t &index, data_t val)¶: Set the element indexed by index to value val.

inline void set_all(data_t x)¶: Set all elements in a tensor to some fixed value.

inline void swap_data(vec_t &dat)¶: Swap the data vector.

inline friend void swap(tensor &t1, tensor &t2)¶: Swap two tensors.

Slice function

template<class size_vec_t> inline ubvector_slice vector_slice(size_t ix, const size_vec_t &index)¶

Fix all but one index to create a vector.

This function fixes all of the indices to the values given in index except for the index number ix, and returns the corresponding vector, whose length is equal to the size of the tensor in that index. The value index[ix] is ignored.

For example, for a rank 3 tensor allocated with

tensor t;
size_t dim[3]={3,4,5};
t.resize(3,dim);

the following code

size_t index[3]={1,0,3};
ubvector_view v=t.vector_slice(1,index);

Gives a vector v of length 4 which refers to the values t(1,0,3), t(1,1,3), t(1,2,3), and t(1,3,3).

template<class size_vec_t> inline const const_ubvector_slice const_vector_slice(size_t ix, const size_vec_t &index) const¶

Fix all but one index to create a vector (const version)

See documentation for vector_slice().

Resize method

template<class size_vec_t> inline void resize(size_t rank, const size_vec_t &dim)¶

Resize the tensor to rank rank with sizes given in dim.

The parameter dim must be a vector of sizes with a length equal to rank. This resize method is always destructive.

If the user requests any of the sizes to be zero, this function will call the error handler.

Size functions

inline size_t get_rank() const¶: Return the rank of the tensor.

inline size_t get_size(size_t i) const¶: Returns the size of the ith index.

inline const vec_size_t &get_size_arr() const¶: Return the full vector of sizes.

inline const vec_t &get_data() const¶: Return the full data vector.

inline size_t total_size() const¶: Returns the size of the tensor (the product of the sizes over every index)

Index manipulation

template<class size_vec_t> inline size_t pack_indices(const size_vec_t &index)¶: Pack the indices into a single vector index.

template<class size_vec_t> inline void unpack_index(size_t ix, size_vec_t &index)¶: Unpack the single vector index into indices.

Minimum, maximum, and sum

inline data_t min_value()¶: Compute the minimum value in the tensor.

inline void min_index(vec_size_t &index)¶: Compute the index of the minimum value in the tensor.

inline void min(vec_size_t &index, data_t &val)¶: Compute the index of the minimum value in the tensor and return the minimum.

inline data_t max_value()¶: Compute the maximum value in the tensor.

inline void max_index(vec_size_t &index)¶: Compute the index of the maximum value in the tensor.

inline void max(vec_size_t &index, data_t &val)¶: Compute the index and value of the maximum value in the tensor and return the maximum.

inline void minmax_value(data_t &min, data_t &max)¶: Compute the minimum and maximum values in the tensor.

inline void minmax_index(vec_size_t &index_min, vec_size_t &index_max)¶: Compute the indices of the minimum and maximum values in the tensor.

inline void minmax(vec_size_t &index_min, data_t &min, vec_size_t &index_max, data_t &max)¶: Compute the indices and values of the maximum and minimum in the tensor.

inline double total_sum() const¶: Return the sum over every element in the tensor.

Slicing and converting to table3d objects

inline void copy_table3d_sum(size_t ix_x, size_t ix_y, table3d &tab, std::string x_name = "x", std::string y_name = "y", std::string slice_name = "z")¶: Copy to a o2scl::table3d object by summing over all but two indices.

template<class size_vec2_t> inline void copy_table3d(size_t ix_x, size_t ix_y, size_vec2_t &index, table3d &tab, std::string x_name = "x", std::string y_name = "y", std::string slice_name = "z") const¶: Copy to a table3d object by fixing two indices.

Warning

The vector input index must be initialized before calling this function so that all elements in the vector (except for those at index ix_x and ix_y) are specified. If this is not the case, then this function will return unpredictable results.

inline void copy_table3d(size_t ix_x, size_t ix_y, table3d &tab, std::string x_name = "x", std::string y_name = "y", std::string slice_name = "z") const¶

Copy to a table3d object by fixing two indices.

In this function, all other indices are set to 0. The indices ix_x and ix_y may be the same, in which case this function effectively performs a trace over those two indices.

Public Functions

inline tensor()¶: Create an empty tensor with zero rank.

template<class size_vec_t> inline tensor(size_t rank, const size_vec_t &dim)¶

Create a tensor of rank rank with sizes given in dim.

The parameter dim must be a pointer to a vector of sizes with length rank. If the user requests any of the sizes to be zero, this constructor will call the error handler, create an empty tensor, and will allocate no memory.

inline virtual ~tensor()¶

Protected Attributes

vec_t data¶: The data.

vec_size_t size¶: A rank-sized vector of the sizes of each dimension.

size_t rk¶: Rank.