boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/ublas/tags.hpp

@@ -0,0 +1,37 @@
+/**
+ * -*- c++ -*-
+ *
+ * \file tags.hpp
+ *
+ * \brief Tags.
+ *
+ * Copyright (c) 2009, Marco Guazzone
+ *
+ * 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)
+ *
+ * \author Marco Guazzone, marco.guazzone@gmail.com
+ */
+
+#ifndef BOOST_NUMERIC_UBLAS_TAG_HPP
+#define BOOST_NUMERIC_UBLAS_TAG_HPP
+
+
+namespace boost { namespace numeric { namespace ublas { namespace tag {
+
+/// \brief Tag for the major dimension.
+struct major {};
+
+
+/// \brief Tag for the minor dimension.
+struct minor {};
+
+
+/// \brief Tag for the leading dimension.
+struct leading {};
+
+}}}} // Namespace boost::numeric::ublas::tag
+
+
+#endif // BOOST_NUMERIC_UBLAS_TAG_HPP

package/boost/numeric/ublas/tensor/algorithms.hpp

@@ -0,0 +1,345 @@
+//
+//  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_ALGORITHMS_HPP
+#define _BOOST_UBLAS_TENSOR_ALGORITHMS_HPP
+
+
+#include <stdexcept>
+#include <complex>
+#include <functional>
+
+namespace boost {
+namespace numeric {
+namespace ublas {
+
+
+
+/** @brief Copies a tensor to another tensor with different layouts
+ *
+ * Implements C[i1,i2,...,ip] = A[i1,i2,...,ip]
+ *
+ * @param[in]  p rank of input and output tensor
+ * @param[in]  n pointer to the extents of input or output tensor of length p
+ * @param[in] pi pointer to a one-based permutation tuple of length p
+ * @param[out] c pointer to the output tensor
+ * @param[in] wc pointer to the strides of output tensor c
+ * @param[in]  a pointer to the input tensor
+ * @param[in] wa pointer to the strides of input tensor a
+*/
+template <class	PointerOut, class PointerIn, class SizeType>
+void copy(const SizeType p, SizeType const*const n,
+          PointerOut c, SizeType const*const wc,
+          PointerIn a,  SizeType const*const wa)
+{
+	static_assert( std::is_pointer<PointerOut>::value & std::is_pointer<PointerIn>::value,
+	               "Static error in boost::numeric::ublas::copy: Argument types for pointers are not pointer types.");
+	if( p == 0 )
+		return;
+
+	if(c == nullptr || a == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::copy: Pointers shall not be null pointers.");
+
+	if(wc == nullptr || wa == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::copy: Pointers shall not be null pointers.");
+
+	if(n == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::copy: Pointers shall not be null pointers.");
+
+
+	std::function<void(SizeType r, PointerOut c, PointerIn  a)> lambda;
+
+	lambda = [&lambda, n, wc, wa](SizeType r, PointerOut c, PointerIn a)
+	{
+		if(r > 0)
+			for(auto d = 0u; d < n[r]; c += wc[r], a += wa[r], ++d)
+				lambda(r-1, c, a );
+		else
+			for(auto d = 0u; d < n[0]; c += wc[0], a += wa[0], ++d)
+				*c = *a;
+	};
+
+	lambda( p-1, c, a );
+}
+
+
+
+/** @brief Copies a tensor to another tensor with different layouts applying a unary operation
+ *
+ * Implements C[i1,i2,...,ip] = op ( A[i1,i2,...,ip] )
+ *
+ * @param[in]  p rank of input and output tensor
+ * @param[in]  n pointer to the extents of input or output tensor of length p
+ * @param[in] pi pointer to a one-based permutation tuple of length p
+ * @param[out] c pointer to the output tensor
+ * @param[in] wc pointer to the strides of output tensor c
+ * @param[in]  a pointer to the input tensor
+ * @param[in] wa pointer to the strides of input tensor a
+ * @param[in] op unary operation
+*/
+template <class	PointerOut, class PointerIn, class SizeType, class UnaryOp>
+void transform(const SizeType p,
+               SizeType const*const n,
+               PointerOut c, SizeType const*const wc,
+               PointerIn a,  SizeType const*const wa,
+               UnaryOp op)
+{
+	static_assert( std::is_pointer<PointerOut>::value & std::is_pointer<PointerIn>::value,
+	               "Static error in boost::numeric::ublas::transform: Argument types for pointers are not pointer types.");
+	if( p == 0 )
+		return;
+
+	if(c == nullptr || a == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+	if(wc == nullptr || wa == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+	if(n == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+
+	std::function<void(SizeType r, PointerOut c, PointerIn a)> lambda;
+
+	lambda = [&lambda, n, wc, wa, op](SizeType r, PointerOut c, PointerIn a)
+	{
+		if(r > 0)
+			for(auto d = 0u; d < n[r]; c += wc[r], a += wa[r], ++d)
+				lambda(r-1, c, a);
+		else
+			for(auto d = 0u; d < n[0]; c += wc[0], a += wa[0], ++d)
+				*c = op(*a);
+	};
+
+	lambda( p-1, c, a );
+
+}
+
+
+/** @brief Performs a reduce operation with all elements of the tensor and an initial value
+ *
+ * Implements k = sum_{i1,..,ip} A[i1,i2,...,ip]
+ *
+ * @param[in] r  zero-based recursion level starting with r=p-1
+ * @param[in] n  pointer to the extents of input or output tensor
+ * @param[in] a  pointer to the first input tensor
+ * @param[in] w  pointer to the strides of input tensor a
+ * @param[in] k  accumulated value
+*/
+template <class PointerIn, class ValueType, class SizeType>
+ValueType accumulate(SizeType const p, SizeType const*const n,
+                     PointerIn a, SizeType const*const w,
+                     ValueType k)
+{
+	static_assert(std::is_pointer<PointerIn>::value,
+	              "Static error in boost::numeric::ublas::transform: Argument types for pointers are not pointer types.");
+
+	if( p == 0 )
+		return k;
+
+	if(a == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+	if(w == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+	if(n == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+
+	std::function<ValueType(SizeType r, PointerIn a, ValueType k)> lambda;
+
+	lambda = [&lambda, n, w](SizeType r, PointerIn a, ValueType k)
+	{
+		if(r > 0u)
+			for(auto d = 0u; d < n[r]; a += w[r], ++d)
+				k = lambda(r-1, a, k);
+		else
+			for(auto d = 0u; d < n[0]; a += w[0], ++d)
+				k += *a;
+		return k;
+	};
+
+	return lambda( p-1, a,  k );
+}
+
+/** @brief Performs a reduce operation with all elements of the tensor and an initial value
+ *
+ * Implements k = op ( k , A[i1,i2,...,ip] ), for all ir
+ *
+ * @param[in] r  zero-based recursion level starting with r=p-1
+ * @param[in] n  pointer to the extents of input or output tensor
+ * @param[in] a  pointer to the first input tensor
+ * @param[in] w  pointer to the strides of input tensor a
+ * @param[in] k  accumulated value
+ * @param[in] op binary operation
+*/
+
+template <class PointerIn, class ValueType, class SizeType, class BinaryOp>
+ValueType accumulate(SizeType const p, SizeType const*const n,
+                     PointerIn a, SizeType const*const w,
+                     ValueType k, BinaryOp op)
+{
+	static_assert(std::is_pointer<PointerIn>::value,
+	              "Static error in boost::numeric::ublas::transform: Argument types for pointers are not pointer types.");
+
+
+	if( p == 0 )
+		return k;
+
+	if(a == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+	if(w == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+	if(n == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::transform: Pointers shall not be null pointers.");
+
+
+	std::function<ValueType(SizeType r, PointerIn a, ValueType k)> lambda;
+
+	lambda = [&lambda, n, w, op](SizeType r, PointerIn a, ValueType k)
+	{
+		if(r > 0u)
+			for(auto d = 0u; d < n[r]; a += w[r], ++d)
+				k = lambda(r-1, a, k);
+		else
+			for(auto d = 0u; d < n[0]; a += w[0], ++d)
+				k = op ( k, *a );
+		return k;
+	};
+
+	return lambda( p-1, a,  k );
+}
+
+/** @brief Transposes a tensor
+ *
+ * Implements C[tau[i1],tau[i2],...,tau[ip]] = A[i1,i2,...,ip]
+ *
+ * @note is used in function trans
+ *
+ * @param[in]  p rank of input and output tensor
+ * @param[in] na pointer to the extents of the input tensor a of length p
+ * @param[in] pi pointer to a one-based permutation tuple of length p
+ * @param[out] c pointer to the output tensor
+ * @param[in] wc pointer to the strides of output tensor c
+ * @param[in]  a pointer to the input tensor
+ * @param[in] wa pointer to the strides of input tensor a
+*/
+
+template <class PointerOut, class PointerIn, class SizeType>
+void trans( SizeType const p,  SizeType const*const na, SizeType const*const pi,
+            PointerOut c,      SizeType const*const wc,
+            PointerIn a,       SizeType const*const wa)
+{
+
+	static_assert( std::is_pointer<PointerOut>::value & std::is_pointer<PointerIn>::value,
+	               "Static error in boost::numeric::ublas::trans: Argument types for pointers are not pointer types.");
+
+	if( p < 2)
+		return;
+
+	if(c == nullptr || a == nullptr)
+		throw std::runtime_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+	if(na == nullptr)
+		throw std::runtime_error("Error in boost::numeric::ublas::trans: Pointers shall not be null.");
+
+	if(wc == nullptr || wa == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+	if(na == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+	if(pi == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+
+	std::function<void(SizeType r, PointerOut c, PointerIn a)> lambda;
+
+	lambda = [&lambda, na, wc, wa, pi](SizeType r, PointerOut c, PointerIn a)
+	{
+		if(r > 0)
+			for(auto d = 0u; d < na[r]; c += wc[pi[r]-1], a += wa[r], ++d)
+				lambda(r-1, c, a);
+		else
+			for(auto d = 0u; d < na[0]; c += wc[pi[0]-1], a += wa[0], ++d)
+				*c = *a;
+	};
+
+	lambda( p-1, c, a );
+}
+
+
+/** @brief Transposes a tensor
+ *
+ * Implements C[tau[i1],tau[i2],...,tau[ip]] = A[i1,i2,...,ip]
+ *
+ * @note is used in function trans
+ *
+ * @param[in]  p rank of input and output tensor
+ * @param[in] na pointer to the extents of the input tensor a of length p
+ * @param[in] pi pointer to a one-based permutation tuple of length p
+ * @param[out] c pointer to the output tensor
+ * @param[in] wc pointer to the strides of output tensor c
+ * @param[in]  a pointer to the input tensor
+ * @param[in] wa pointer to the strides of input tensor a
+*/
+
+template <class ValueType, class SizeType>
+void trans( SizeType const p,
+            SizeType const*const na,
+            SizeType const*const pi,
+            std::complex<ValueType>* c,  SizeType const*const wc,
+            std::complex<ValueType>* a,  SizeType const*const wa)
+{
+	if( p < 2)
+		return;
+
+	if(c == nullptr || a == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+	if(wc == nullptr || wa == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+	if(na == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+	if(pi == nullptr)
+		throw std::length_error("Error in boost::numeric::ublas::trans: Pointers shall not be null pointers.");
+
+
+	std::function<void(SizeType r, std::complex<ValueType>* c, std::complex<ValueType>* a)> lambda;
+
+	lambda = [&lambda, na, wc, wa, pi](SizeType r, std::complex<ValueType>* c, std::complex<ValueType>* a)
+	{
+		if(r > 0)
+			for(auto d = 0u; d < na[r]; c += wc[pi[r]-1], a += wa[r], ++d)
+				lambda(r-1, c, a);
+		else
+			for(auto d = 0u; d < na[0]; c += wc[pi[0]-1], a += wa[0], ++d)
+				*c = std::conj(*a);
+	};
+
+	lambda( p-1, c, a );
+
+}
+
+
+
+
+}
+}
+}
+
+#endif

package/boost/numeric/ublas/tensor/expression.hpp

@@ -0,0 +1,181 @@
+//
+//  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_EXPRESSIONS_HPP
+#define BOOST_UBLAS_TENSOR_EXPRESSIONS_HPP
+
+#include <cstddef>
+#include <boost/numeric/ublas/expression_types.hpp>
+
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+
+
+template<class element_type, class storage_format, class storage_type>
+class tensor;
+
+template<class size_type>
+class basic_extents;
+
+
+//TODO: put in fwd.hpp
+struct tensor_tag {};
+
+}
+}
+}
+
+namespace boost   {
+namespace numeric {
+namespace ublas   {
+namespace detail  {
+
+/** @\brief base class for tensor expressions
+ *
+ * \note implements crtp - no use of virtual function calls
+ *
+ * \tparam T type of the tensor
+ * \tparam E type of the derived expression (crtp)
+ *
+ **/
+template<class T, class E>
+struct tensor_expression
+    : public ublas_expression<E>
+{
+	//	static const unsigned complexity = 0;
+	using expression_type = E;
+	using type_category = tensor_tag;
+	using tensor_type = T;
+
+	BOOST_UBLAS_INLINE
+	auto const& operator()() const { return *static_cast<const expression_type*> (this); }
+
+protected :
+	explicit tensor_expression() = default;
+	tensor_expression(const tensor_expression&) = delete;
+	tensor_expression& operator=(const tensor_expression&) = delete;
+};
+
+
+template<class T, class EL, class ER, class OP>
+struct binary_tensor_expression
+    : public tensor_expression <T, binary_tensor_expression<T,EL,ER,OP>>
+{
+	using self_type = binary_tensor_expression<T,EL,ER,OP>;
+	using tensor_type  = T;
+	using binary_operation = OP;
+	using expression_type_left  = EL;
+	using expression_type_right = ER;
+	using derived_type =  tensor_expression <tensor_type,self_type>;
+
+	using size_type = typename tensor_type::size_type;
+
+	explicit binary_tensor_expression(expression_type_left  const& l, expression_type_right const& r, binary_operation o)
+	  : el(l) , er(r) , op(o) {}
+	binary_tensor_expression() = delete;
+	binary_tensor_expression(const binary_tensor_expression& l) = delete;
+	binary_tensor_expression(binary_tensor_expression&& l)
+	  : el(l.el), er(l.er), op(l.op) {}
+
+	BOOST_UBLAS_INLINE
+	decltype(auto)  operator()(size_type i) const { return op(el(i), er(i)); }
+
+	expression_type_left const& el;
+	expression_type_right const& er;
+	binary_operation op;
+};
+
+/// @brief helper function to simply instantiation of lambda proxy class
+template<class T, class EL, class ER, class OP>
+auto make_binary_tensor_expression( tensor_expression<T,EL> const& el, tensor_expression<T,ER> const& er, OP op)
+{
+	return binary_tensor_expression<T,EL,ER,OP>( el(), er(), op) ;
+}
+
+template<class T, class EL, class ER, class OP>
+auto make_binary_tensor_expression( matrix_expression<EL> const& el, tensor_expression<T,ER> const& er, OP op)
+{
+	return binary_tensor_expression<T,EL,ER,OP>( el(), er(), op) ;
+}
+
+template<class T, class EL, class ER, class OP>
+auto make_binary_tensor_expression( tensor_expression<T,EL> const& el, matrix_expression<ER> const& er, OP op)
+{
+	return binary_tensor_expression<T,EL,ER,OP>( el(), er(), op) ;
+}
+
+template<class T, class EL, class ER, class OP>
+auto make_binary_tensor_expression( vector_expression<EL> const& el, tensor_expression<T,ER> const& er, OP op)
+{
+	return binary_tensor_expression<T,EL,ER,OP>( el(), er(), op) ;
+}
+
+template<class T, class EL, class ER, class OP>
+auto make_binary_tensor_expression( tensor_expression<T,EL> const& el, vector_expression<ER> const& er, OP op)
+{
+	return binary_tensor_expression<T,EL,ER,OP>( el(), er(), op) ;
+}
+
+
+
+template<class T, class E, class OP>
+struct unary_tensor_expression
+    : public tensor_expression <T, unary_tensor_expression<T,E,OP>>
+{
+
+	using self_type = unary_tensor_expression<T,E,OP>;
+	using tensor_type  = T;
+	using expression_type = E;
+
+	using derived_type = tensor_expression <T, unary_tensor_expression<T,E,OP>>;
+
+	using size_type = typename tensor_type::size_type;
+
+	explicit unary_tensor_expression(E const& ee, OP o) : e(ee) , op(o) {}
+	unary_tensor_expression() = delete;
+	unary_tensor_expression(const unary_tensor_expression& l) = delete;
+	unary_tensor_expression(unary_tensor_expression&& l)
+	  : e(l.e), op(op.l) {}
+
+	BOOST_UBLAS_INLINE
+	decltype(auto) operator()(size_type i) const { return op(e(i)); }
+
+	E const& e;
+	OP op;
+};
+
+// \brief helper function to simply instantiation of lambda proxy class
+template<class T, class E, class OP>
+auto make_unary_tensor_expression( tensor_expression<T,E> const& e, OP op)
+{
+	return unary_tensor_expression<T,E,OP>( e() , op);
+}
+
+template<class T, class E, class OP>
+auto make_unary_tensor_expression( matrix_expression<E> const& e, OP op)
+{
+	return unary_tensor_expression<T,E,OP>( e() , op);
+}
+
+template<class T, class E, class OP>
+auto make_unary_tensor_expression( vector_expression<E> const& e, OP op)
+{
+	return unary_tensor_expression<T,E,OP>( e() , op);
+}
+
+
+}
+}
+}
+}
+#endif