FM / tensor

/usr/include/boost/numeric/ublas/tensor/

/usr/include/boost/numeric/ublas/tensor

Name	Size	Mode	Actions
algorithms.hpp	11269	0644	edit dl rm
expression.hpp	5082	0644	edit dl rm
expression_evaluation.hpp	8957	0644	edit dl rm
extents.hpp	7727	0644	edit dl rm
functions.hpp	17254	0644	edit dl rm
index.hpp	2560	0644	edit dl rm
multiplication.hpp	36639	0644	edit dl rm
multi_index.hpp	2662	0644	edit dl rm
multi_index_utility.hpp	11140	0644	edit dl rm
operators_arithmetic.hpp	10106	0644	edit dl rm
operators_comparison.hpp	7222	0644	edit dl rm
ostream.hpp	2426	0644	edit dl rm
storage_traits.hpp	2385	0644	edit dl rm
strides.hpp	6107	0644	edit dl rm
tensor.hpp	19650	0644	edit dl rm

Edit: /usr/include/boost/numeric/ublas/tensor/operators_arithmetic.hpp (10106B)

#ifndef BOOST_UBLAS_TENSOR_OPERATORS_ARITHMETIC_HPP
#define BOOST_UBLAS_TENSOR_OPERATORS_ARITHMETIC_HPP

#include "expression.hpp"
#include "expression_evaluation.hpp"
#include "multi_index_utility.hpp"
#include "functions.hpp"

#include <type_traits>
#include <functional>
#include <algorithm>

namespace boost{
namespace numeric{
namespace ublas {

template<class element_type, class storage_format, class storage_type>
class tensor;

template<class E>
class matrix_expression;

template<class E>
class vector_expression;

}
}
}

#define FIRST_ORDER_OPERATOR_RIGHT(OP, EXPR_TYPE_L, EXPR_TYPE_R) \
template<class T, class L, class R> \
auto operator OP ( boost::numeric::ublas:: EXPR_TYPE_L <T,L> const& lhs, boost::numeric::ublas:: EXPR_TYPE_R <R> const& rhs) { \
	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), \
	  [](auto const& l, auto const& r){ return l OP r; }); \
} \

FIRST_ORDER_OPERATOR_RIGHT (*, detail:: tensor_expression , vector_expression)
FIRST_ORDER_OPERATOR_RIGHT (+, detail:: tensor_expression , vector_expression)
FIRST_ORDER_OPERATOR_RIGHT (-, detail:: tensor_expression , vector_expression)
FIRST_ORDER_OPERATOR_RIGHT (/, detail:: tensor_expression , vector_expression)

FIRST_ORDER_OPERATOR_RIGHT (*, detail:: tensor_expression , matrix_expression)
FIRST_ORDER_OPERATOR_RIGHT (+, detail:: tensor_expression , matrix_expression)
FIRST_ORDER_OPERATOR_RIGHT (-, detail:: tensor_expression , matrix_expression)
FIRST_ORDER_OPERATOR_RIGHT (/, detail:: tensor_expression , matrix_expression)

#define FIRST_ORDER_OPERATOR_LEFT(OP, EXPR_TYPE_L, EXPR_TYPE_R) \
template<class T, class L, class R> \
auto operator OP ( boost::numeric::ublas:: EXPR_TYPE_L <L> const& lhs, boost::numeric::ublas:: EXPR_TYPE_R <T,R> const& rhs) { \
	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), \
	  [](auto const& l, auto const& r){ return l OP r; }); \
} \

FIRST_ORDER_OPERATOR_LEFT (*, vector_expression, detail:: tensor_expression)
FIRST_ORDER_OPERATOR_LEFT (+, vector_expression, detail:: tensor_expression)
FIRST_ORDER_OPERATOR_LEFT (-, vector_expression, detail:: tensor_expression)
FIRST_ORDER_OPERATOR_LEFT (/, vector_expression, detail:: tensor_expression)

FIRST_ORDER_OPERATOR_LEFT (*, matrix_expression, detail:: tensor_expression)
FIRST_ORDER_OPERATOR_LEFT (+, matrix_expression, detail:: tensor_expression)
FIRST_ORDER_OPERATOR_LEFT (-, matrix_expression, detail:: tensor_expression)
FIRST_ORDER_OPERATOR_LEFT (/, matrix_expression, detail:: tensor_expression)

template<class T, class L, class R>
auto operator+( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l + r; });
}
template<class T, class L, class R>
auto operator-( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l - r; });
//	return boost::numeric::ublas::detail::make_lambda<T>([&lhs,&rhs](std::size_t i){ return lhs(i) - rhs(i);});
}
template<class T, class L, class R>
auto operator*( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l * r; });
}
template<class T, class L, class R>
auto operator/( boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_binary_tensor_expression<T> (lhs(), rhs(), [](auto const& l, auto const& r){ return l / r; });
}

// Overloaded Arithmetic Operators with Scalars
template<class T, class R>
auto operator+(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs + r; });
	//return boost::numeric::ublas::detail::make_lambda<T>( [&lhs,&rhs](std::size_t i) {return lhs + rhs(i); } );
}
template<class T, class R>
auto operator-(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs - r; });
}
template<class T, class R>
auto operator*(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs * r; });
}
template<class T, class R>
auto operator/(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression<T,R> const& rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (rhs(), [lhs](auto const& r){ return lhs / r; });
}

template<class T, class L>
auto operator+(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l + rhs; } );
}
template<class T, class L>
auto operator-(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l - rhs; } );
}
template<class T, class L>
auto operator*(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l * rhs; } );
}
template<class T, class L>
auto operator/(boost::numeric::ublas::detail::tensor_expression<T,L> const& lhs, typename T::const_reference rhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [rhs] (auto const& l) { return l / rhs; } );
}

template<class T, class D>
auto& operator += (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l+=r; } );
	return lhs;
}

template<class T, class D>
auto& operator -= (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l-=r; } );
	return lhs;
}

template<class T, class D>
auto& operator *= (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l*=r; } );
	return lhs;
}

template<class T, class D>
auto& operator /= (T& lhs, const boost::numeric::ublas::detail::tensor_expression<T,D> &expr) {
	boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l/=r; } );
	return lhs;
}

template<class E, class F, class A>
auto& operator += (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l+=r; } );
	return lhs;
}

template<class E, class F, class A>
auto& operator -= (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l-=r; } );
	return lhs;
}

template<class E, class F, class A>
auto& operator *= (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l*=r; } );
	return lhs;
}

template<class E, class F, class A>
auto& operator /= (boost::numeric::ublas::tensor<E,F,A>& lhs, typename boost::numeric::ublas::tensor<E,F,A>::const_reference r) {
	boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l/=r; } );
	return lhs;
}

template<class T, class D>
auto const& operator +(const boost::numeric::ublas::detail::tensor_expression<T,D>& lhs) {
	return lhs;
}

template<class T, class D>
auto operator -(boost::numeric::ublas::detail::tensor_expression<T,D> const& lhs) {
	return boost::numeric::ublas::detail::make_unary_tensor_expression<T> (lhs(), [] (auto const& l) { return -l; } );
}

/** @brief Performs a tensor contraction, not an elementwise multiplication
	*
*/

template<class tensor_type_left, class tuple_type_left, class tensor_type_right, class tuple_type_right>
auto operator*(
		std::pair< tensor_type_left  const&, tuple_type_left  > lhs,
		std::pair< tensor_type_right const&, tuple_type_right > rhs)
{

using namespace boost::numeric::ublas;

auto const& tensor_left  = lhs.first;
	auto const& tensor_right = rhs.first;

auto multi_index_left = lhs.second;
	auto multi_index_right = rhs.second;

static constexpr auto num_equal_ind = number_equal_indexes<tuple_type_left, tuple_type_right>::value;

if constexpr ( num_equal_ind == 0  ){
		return tensor_left * tensor_right;
	}
	else if constexpr ( num_equal_ind==std::tuple_size<tuple_type_left>::value && std::is_same<tuple_type_left, tuple_type_right>::value ){

return boost::numeric::ublas::inner_prod( tensor_left, tensor_right );
	}
	else {
		auto array_index_pairs = index_position_pairs(multi_index_left,multi_index_right);
		auto index_pairs = array_to_vector(  array_index_pairs  );
		return boost::numeric::ublas::prod( tensor_left, tensor_right, index_pairs.first, index_pairs.second );
	}

}

#endif

// // Copyright (c) 2018-2019, Cem Bassoy, cem.bassoy@gmail.com // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // The authors gratefully acknowledge the support of // Fraunhofer IOSB, Ettlingen, Germany // #ifndef BOOST_UBLAS_TENSOR_OPERATORS_ARITHMETIC_HPP #define BOOST_UBLAS_TENSOR_OPERATORS_ARITHMETIC_HPP #include "expression.hpp" #include "expression_evaluation.hpp" #include "multi_index_utility.hpp" #include "functions.hpp" #include #include #include namespace boost{ namespace numeric{ namespace ublas { template class tensor; template class matrix_expression; template class vector_expression; } } } #define FIRST_ORDER_OPERATOR_RIGHT(OP, EXPR_TYPE_L, EXPR_TYPE_R) \ template \ auto operator OP ( boost::numeric::ublas:: EXPR_TYPE_L const& lhs, boost::numeric::ublas:: EXPR_TYPE_R const& rhs) { \ return boost::numeric::ublas::detail::make_binary_tensor_expression (lhs(), rhs(), \ [](auto const& l, auto const& r){ return l OP r; }); \ } \ FIRST_ORDER_OPERATOR_RIGHT (*, detail:: tensor_expression , vector_expression) FIRST_ORDER_OPERATOR_RIGHT (+, detail:: tensor_expression , vector_expression) FIRST_ORDER_OPERATOR_RIGHT (-, detail:: tensor_expression , vector_expression) FIRST_ORDER_OPERATOR_RIGHT (/, detail:: tensor_expression , vector_expression) FIRST_ORDER_OPERATOR_RIGHT (*, detail:: tensor_expression , matrix_expression) FIRST_ORDER_OPERATOR_RIGHT (+, detail:: tensor_expression , matrix_expression) FIRST_ORDER_OPERATOR_RIGHT (-, detail:: tensor_expression , matrix_expression) FIRST_ORDER_OPERATOR_RIGHT (/, detail:: tensor_expression , matrix_expression) #define FIRST_ORDER_OPERATOR_LEFT(OP, EXPR_TYPE_L, EXPR_TYPE_R) \ template \ auto operator OP ( boost::numeric::ublas:: EXPR_TYPE_L const& lhs, boost::numeric::ublas:: EXPR_TYPE_R const& rhs) { \ return boost::numeric::ublas::detail::make_binary_tensor_expression (lhs(), rhs(), \ [](auto const& l, auto const& r){ return l OP r; }); \ } \ FIRST_ORDER_OPERATOR_LEFT (*, vector_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (+, vector_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (-, vector_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (/, vector_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (*, matrix_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (+, matrix_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (-, matrix_expression, detail:: tensor_expression) FIRST_ORDER_OPERATOR_LEFT (/, matrix_expression, detail:: tensor_expression) template auto operator+( boost::numeric::ublas::detail::tensor_expression const& lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_binary_tensor_expression (lhs(), rhs(), [](auto const& l, auto const& r){ return l + r; }); } template auto operator-( boost::numeric::ublas::detail::tensor_expression const& lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_binary_tensor_expression (lhs(), rhs(), [](auto const& l, auto const& r){ return l - r; }); // return boost::numeric::ublas::detail::make_lambda([&lhs,&rhs](std::size_t i){ return lhs(i) - rhs(i);}); } template auto operator*( boost::numeric::ublas::detail::tensor_expression const& lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_binary_tensor_expression (lhs(), rhs(), [](auto const& l, auto const& r){ return l * r; }); } template auto operator/( boost::numeric::ublas::detail::tensor_expression const& lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_binary_tensor_expression (lhs(), rhs(), [](auto const& l, auto const& r){ return l / r; }); } // Overloaded Arithmetic Operators with Scalars template auto operator+(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (rhs(), [lhs](auto const& r){ return lhs + r; }); //return boost::numeric::ublas::detail::make_lambda( [&lhs,&rhs](std::size_t i) {return lhs + rhs(i); } ); } template auto operator-(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (rhs(), [lhs](auto const& r){ return lhs - r; }); } template auto operator*(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (rhs(), [lhs](auto const& r){ return lhs * r; }); } template auto operator/(typename T::const_reference lhs, boost::numeric::ublas::detail::tensor_expression const& rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (rhs(), [lhs](auto const& r){ return lhs / r; }); } template auto operator+(boost::numeric::ublas::detail::tensor_expression const& lhs, typename T::const_reference rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (lhs(), [rhs] (auto const& l) { return l + rhs; } ); } template auto operator-(boost::numeric::ublas::detail::tensor_expression const& lhs, typename T::const_reference rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (lhs(), [rhs] (auto const& l) { return l - rhs; } ); } template auto operator*(boost::numeric::ublas::detail::tensor_expression const& lhs, typename T::const_reference rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (lhs(), [rhs] (auto const& l) { return l * rhs; } ); } template auto operator/(boost::numeric::ublas::detail::tensor_expression const& lhs, typename T::const_reference rhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (lhs(), [rhs] (auto const& l) { return l / rhs; } ); } template auto& operator += (T& lhs, const boost::numeric::ublas::detail::tensor_expression &expr) { boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l+=r; } ); return lhs; } template auto& operator -= (T& lhs, const boost::numeric::ublas::detail::tensor_expression &expr) { boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l-=r; } ); return lhs; } template auto& operator *= (T& lhs, const boost::numeric::ublas::detail::tensor_expression &expr) { boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l*=r; } ); return lhs; } template auto& operator /= (T& lhs, const boost::numeric::ublas::detail::tensor_expression &expr) { boost::numeric::ublas::detail::eval(lhs, expr(), [](auto& l, auto const& r) { l/=r; } ); return lhs; } template auto& operator += (boost::numeric::ublas::tensor& lhs, typename boost::numeric::ublas::tensor::const_reference r) { boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l+=r; } ); return lhs; } template auto& operator -= (boost::numeric::ublas::tensor& lhs, typename boost::numeric::ublas::tensor::const_reference r) { boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l-=r; } ); return lhs; } template auto& operator *= (boost::numeric::ublas::tensor& lhs, typename boost::numeric::ublas::tensor::const_reference r) { boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l*=r; } ); return lhs; } template auto& operator /= (boost::numeric::ublas::tensor& lhs, typename boost::numeric::ublas::tensor::const_reference r) { boost::numeric::ublas::detail::eval(lhs, [r](auto& l) { l/=r; } ); return lhs; } template auto const& operator +(const boost::numeric::ublas::detail::tensor_expression& lhs) { return lhs; } template auto operator -(boost::numeric::ublas::detail::tensor_expression const& lhs) { return boost::numeric::ublas::detail::make_unary_tensor_expression (lhs(), [] (auto const& l) { return -l; } ); } /** @brief Performs a tensor contraction, not an elementwise multiplication * */ template auto operator*( std::pair< tensor_type_left const&, tuple_type_left > lhs, std::pair< tensor_type_right const&, tuple_type_right > rhs) { using namespace boost::numeric::ublas; auto const& tensor_left = lhs.first; auto const& tensor_right = rhs.first; auto multi_index_left = lhs.second; auto multi_index_right = rhs.second; static constexpr auto num_equal_ind = number_equal_indexes::value; if constexpr ( num_equal_ind == 0 ){ return tensor_left * tensor_right; } else if constexpr ( num_equal_ind==std::tuple_size::value && std::is_same::value ){ return boost::numeric::ublas::inner_prod( tensor_left, tensor_right ); } else { auto array_index_pairs = index_position_pairs(multi_index_left,multi_index_right); auto index_pairs = array_to_vector( array_index_pairs ); return boost::numeric::ublas::prod( tensor_left, tensor_right, index_pairs.first, index_pairs.second ); } } #endif