tenex::Negate< T > Struct Template Reference

Defines the tensor expression representing the negation of a tensor expression. More...

#include <Negate.hpp>

Public Types
using	type = typename T::type
	The type of the data being stored in the result of the expression.
using	symmetry = typename T::symmetry
	The Symmetry of the result of the expression.
using	index_list = typename T::index_list
	The list of TensorIndexTypes of the result of the expression.
using	args_list = typename T::args_list
	The list of generic TensorIndexs of the result of the expression.

Public Member Functions
	Negate (T t)
template<typename LhsTensor >
void	assert_lhs_tensor_not_in_rhs_expression (const gsl::not_null< LhsTensor * > lhs_tensor) const
	Assert that the LHS tensor of the equation does not also appear in this expression's subtree.
template<typename LhsTensorIndices , typename LhsTensor >
void	assert_lhs_tensorindices_same_in_rhs (const gsl::not_null< LhsTensor * > lhs_tensor) const
	Assert that each instance of the LHS tensor in the RHS tensor expression uses the same generic index order that the LHS uses. More...
size_t	get_rhs_tensor_component_size () const
	Get the size of a component from a Tensor in this expression's subtree of the RHS TensorExpression More...
decltype(auto)	get (const std::array< size_t, num_tensor_indices > &multi_index) const
	Return the value of the component of the negated tensor expression at a given multi-index. More...
template<typename ResultType >
decltype(auto)	get_primary (const ResultType &result_component, const std::array< size_t, num_tensor_indices > &multi_index) const
	Return the value of the component of the negated tensor expression at a given multi-index. More...
template<typename ResultType >
void	evaluate_primary_subtree (ResultType &result_component, const std::array< size_t, num_tensor_indices > &multi_index) const
	Successively evaluate the LHS Tensor's result component at each leg in this expression's subtree. More...

Static Public Attributes
static constexpr auto	num_tensor_indices = implementation defined
	The number of tensor indices in the result of the expression.
static constexpr size_t	num_ops_left_child = T::num_ops_subtree
	The number of arithmetic tensor operations done in the subtree for the left operand.
static constexpr size_t	num_ops_right_child = 0
	The number of arithmetic tensor operations done in the subtree for the right operand. This is 0 because this expression represents a unary operation.
static constexpr size_t	num_ops_subtree = num_ops_left_child + 1
	The total number of arithmetic tensor operations done in this expression's whole subtree.
static constexpr size_t	height_relative_to_closest_tensor_leaf_in_subtree
	The height of this expression's node in the expression tree relative to the closest TensorAsExpression leaf in its subtree. More...
static constexpr bool	is_primary_end = T::is_primary_start
	If on the primary path, whether or not the expression is an ending point of a leg.
static constexpr size_t	num_ops_to_evaluate_primary_left_child
	If on the primary path, this is the remaining number of arithmetic tensor operations that need to be done in the subtree of the child along the primary path, given that we will have already computed the whole subtree at the next lowest leg's starting point. More...
static constexpr size_t	num_ops_to_evaluate_primary_right_child
	If on the primary path, this is the remaining number of arithmetic tensor operations that need to be done in the right operand's subtree. No splitting is currently done, so this is just num_ops_right_child. More...
static constexpr size_t	num_ops_to_evaluate_primary_subtree
	If on the primary path, this is the remaining number of arithmetic tensor operations that need to be done for this expression's subtree, given that we will have already computed the subtree at the next lowest leg's starting point. More...
static constexpr bool	is_primary_start
	If on the primary path, whether or not the expression is a starting point of a leg. More...
static constexpr bool	primary_child_subtree_contains_primary_start
	If on the primary path, whether or not the expression's child along the primary path is a subtree that contains a starting point of a leg along the primary path. More...
static constexpr bool	primary_subtree_contains_primary_start
	If on the primary path, whether or not this subtree contains a starting point of a leg along the primary path. More...

Detailed Description

template<typename T>
struct tenex::Negate< T >

Defines the tensor expression representing the negation of a tensor expression.

Details

For details on aliases and members defined in this class, as well as general TensorExpression terminology used in its members' documentation, see documentation for TensorExpression.

Template Parameters

T	the type of tensor expression being negated

Member Function Documentation

assert_lhs_tensorindices_same_in_rhs()

template<typename T >

template<typename LhsTensorIndices , typename LhsTensor >

void tenex::Negate< T >::assert_lhs_tensorindices_same_in_rhs ( const gsl::not_null< LhsTensor * >  lhs_tensor ) const

inline

Assert that each instance of the LHS tensor in the RHS tensor expression uses the same generic index order that the LHS uses.

Template Parameters

LhsTensorIndices

the list of generic TensorIndexs of the LHS result Tensor being computed

Parameters

lhs_tensor

the LHS result Tensor being computed

evaluate_primary_subtree()

template<typename T >

template<typename ResultType >

void tenex::Negate< T >::evaluate_primary_subtree ( ResultType &  result_component, const std::array< size_t, num_tensor_indices > &  multi_index  ) const

inline

Successively evaluate the LHS Tensor's result component at each leg in this expression's subtree.

Details

This function takes into account whether we have already computed part of the result component at a lower subtree. In recursively computing this negation, the current result component will be substituted in for the most recent (highest) subtree below it that has already been evaluated.

Parameters

result_component	the LHS tensor component to evaluate
multi_index	the multi-index of the component of the result tensor to evaluate

get()

template<typename T >

decltype(auto) tenex::Negate< T >::get ( const std::array< size_t, num_tensor_indices > &  multi_index ) const

inline

Return the value of the component of the negated tensor expression at a given multi-index.

Parameters

multi_index

the multi-index of the component to retrieve from the negated tensor expression

Returns: the value of the component at multi_index in the negated tensor expression

get_primary()

template<typename T >

template<typename ResultType >

decltype(auto) tenex::Negate< T >::get_primary ( const ResultType &  result_component, const std::array< size_t, num_tensor_indices > &  multi_index  ) const

inline

Return the value of the component of the negated tensor expression at a given multi-index.

Details

This function differs from get in that it takes into account whether we have already computed part of the result component at a lower subtree. In recursively computing this negation, the current result component will be substituted in for the most recent (highest) subtree below it that has already been evaluated.

Parameters

result_component	the LHS tensor component to evaluate
multi_index	the multi-index of the component to retrieve from the negated tensor expression

Returns: the value of the component at multi_index in the negated tensor expression

get_rhs_tensor_component_size()

template<typename T >

size_t tenex::Negate< T >::get_rhs_tensor_component_size ( ) const

inline

Get the size of a component from a Tensor in this expression's subtree of the RHS TensorExpression

Returns: the size of a component from a Tensor in this expression's subtree of the RHS TensorExpression

Member Data Documentation

height_relative_to_closest_tensor_leaf_in_subtree

template<typename T >

constexpr size_t tenex::Negate< T >::height_relative_to_closest_tensor_leaf_in_subtree

staticconstexpr

Initial value:

=
      T::height_relative_to_closest_tensor_leaf_in_subtree !=
              std::numeric_limits<size_t>::max()
          ? T::height_relative_to_closest_tensor_leaf_in_subtree + 1
          : T::height_relative_to_closest_tensor_leaf_in_subtree

The height of this expression's node in the expression tree relative to the closest TensorAsExpression leaf in its subtree.

is_primary_start

template<typename T >

constexpr bool tenex::Negate< T >::is_primary_start

staticconstexpr

Initial value:

=
      num_ops_to_evaluate_primary_subtree >=
      detail::max_num_ops_in_sub_expression<type>

If on the primary path, whether or not the expression is a starting point of a leg.

num_ops_to_evaluate_primary_left_child

template<typename T >

constexpr size_t tenex::Negate< T >::num_ops_to_evaluate_primary_left_child

staticconstexpr

Initial value:

=
      is_primary_end ? 0 : T::num_ops_to_evaluate_primary_subtree

If on the primary path, this is the remaining number of arithmetic tensor operations that need to be done in the subtree of the child along the primary path, given that we will have already computed the whole subtree at the next lowest leg's starting point.

num_ops_to_evaluate_primary_right_child

template<typename T >

constexpr size_t tenex::Negate< T >::num_ops_to_evaluate_primary_right_child

staticconstexpr

Initial value:

=
      num_ops_right_child

If on the primary path, this is the remaining number of arithmetic tensor operations that need to be done in the right operand's subtree. No splitting is currently done, so this is just num_ops_right_child.

num_ops_to_evaluate_primary_subtree

template<typename T >

constexpr size_t tenex::Negate< T >::num_ops_to_evaluate_primary_subtree

staticconstexpr

Initial value:

=
      num_ops_to_evaluate_primary_left_child +
      num_ops_to_evaluate_primary_right_child + 1

If on the primary path, this is the remaining number of arithmetic tensor operations that need to be done for this expression's subtree, given that we will have already computed the subtree at the next lowest leg's starting point.

primary_child_subtree_contains_primary_start

template<typename T >

constexpr bool tenex::Negate< T >::primary_child_subtree_contains_primary_start

staticconstexpr

Initial value:

=
      T::primary_subtree_contains_primary_start

If on the primary path, whether or not the expression's child along the primary path is a subtree that contains a starting point of a leg along the primary path.

primary_subtree_contains_primary_start

template<typename T >

constexpr bool tenex::Negate< T >::primary_subtree_contains_primary_start

staticconstexpr

Initial value:

=
      is_primary_start or primary_child_subtree_contains_primary_start

If on the primary path, whether or not this subtree contains a starting point of a leg along the primary path.

---

The documentation for this struct was generated from the following file:

• src/DataStructures/Tensor/Expressions/Negate.hpp