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/strides.hpp (6107B)

//
//  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
//
/// \file strides.hpp Definition for the basic_strides template class

#ifndef BOOST_UBLAS_TENSOR_STRIDES_HPP
#define BOOST_UBLAS_TENSOR_STRIDES_HPP

#include <vector>
#include <limits>
#include <numeric>
#include <stdexcept>
#include <initializer_list>
#include <algorithm>
#include <cassert>

#include <boost/numeric/ublas/functional.hpp>

namespace boost { 
namespace numeric { 
namespace ublas {

using first_order = column_major;
using last_order = row_major;

template<class T>
class basic_extents;

/** @brief Template class for storing tensor strides for iteration with runtime variable size.
 *
 * Proxy template class of std::vector<int_type>.
 *
 */
template<class __int_type, class __layout>
class basic_strides
{
public:

using base_type = std::vector<__int_type>;

static_assert( std::numeric_limits<typename base_type::value_type>::is_integer,
								 "Static error in boost::numeric::ublas::basic_strides: type must be of type integer.");
	static_assert(!std::numeric_limits<typename base_type::value_type>::is_signed,
								"Static error in boost::numeric::ublas::basic_strides: type must be of type unsigned integer.");
	static_assert(std::is_same<__layout,first_order>::value || std::is_same<__layout,last_order>::value,
								"Static error in boost::numeric::ublas::basic_strides: layout type must either first or last order");

using layout_type = __layout;
	using value_type = typename base_type::value_type;
	using reference = typename base_type::reference;
	using const_reference = typename base_type::const_reference;
	using size_type = typename base_type::size_type;
	using const_pointer = typename base_type::const_pointer;
	using const_iterator = typename base_type::const_iterator;

/** @brief Default constructs basic_strides
	 *
	 * @code auto ex = basic_strides<unsigned>{};
	 */
	constexpr explicit basic_strides()
		: _base{}
	{
	}

/** @brief Constructs basic_strides from basic_extents for the first- and last-order storage formats
	 *
	 * @code auto strides = basic_strides<unsigned>( basic_extents<std::size_t>{2,3,4} );
	 *
	 */
	template <class T>
	basic_strides(basic_extents<T> const& s)
			: _base(s.size(),1)
	{
		if(s.empty())
			return;

if(!s.valid())
			throw std::runtime_error("Error in boost::numeric::ublas::basic_strides() : shape is not valid.");

if(s.is_vector() || s.is_scalar())
			return;

if(this->size() < 2)
			throw std::runtime_error("Error in boost::numeric::ublas::basic_strides() : size of strides must be greater or equal 2.");

if constexpr (std::is_same<layout_type,first_order>::value){
			size_type k = 1ul, kend = this->size();
			for(; k < kend; ++k)
				_base[k] = _base[k-1] * s[k-1];
		}
		else {
			size_type k = this->size()-2, kend = 0ul;
			for(; k > kend; --k)
				_base[k] = _base[k+1] * s[k+1];
			_base[0] = _base[1] * s[1];
		}
	}

basic_strides(basic_strides const& l)
	    : _base(l._base)
	{}

basic_strides(basic_strides && l )
	    : _base(std::move(l._base))
	{}

basic_strides(base_type const& l )
	    : _base(l)
	{}

basic_strides(base_type && l )
			: _base(std::move(l))
	{}

~basic_strides() = default;

basic_strides& operator=(basic_strides other)
	{
		swap (*this, other);
		return *this;
	}

friend void swap(basic_strides& lhs, basic_strides& rhs) {
		std::swap(lhs._base   , rhs._base);
	}

const_reference operator[] (size_type p) const{
		return _base[p];
	}

const_pointer data() const{
		return _base.data();
	}

const_reference at (size_type p) const{
		return _base.at(p);
	}

bool empty() const{
		return _base.empty();
	}

size_type size() const{
		return _base.size();
	}

template<class other_layout>
	bool operator == (basic_strides<value_type, other_layout> const& b) const{
		return b.base() == this->base();
	}

template<class other_layout>
	bool operator != (basic_strides<value_type, other_layout> const& b) const{
		return b.base() != this->base();
	}

bool operator == (basic_strides const& b) const{
		return b._base == _base;
	}

bool operator != (basic_strides const& b) const{
		return b._base != _base;
	}

const_iterator begin() const{
		return _base.begin();
	}

const_iterator end() const{
		return _base.end();
	}

void clear() {
		this->_base.clear();
	}

base_type const& base() const{
		return this->_base;
	}

protected:
	base_type _base;
};

template<class layout_type>
using strides = basic_strides<std::size_t, layout_type>;

namespace detail {

/** @brief Returns relative memory index with respect to a multi-index
 *
 * @code auto j = access(std::vector{3,4,5}, strides{shape{4,2,3},first_order}); @endcode
 *
 * @param[in] i multi-index of length p
 * @param[in] w stride vector of length p
 * @returns relative memory location depending on \c i and \c w
*/
BOOST_UBLAS_INLINE
template<class size_type, class layout_type>
auto access(std::vector<size_type> const& i, basic_strides<size_type,layout_type> const& w)
{
	const auto p = i.size();
	size_type sum = 0u;
	for(auto r = 0u; r < p; ++r)
		sum += i[r]*w[r];
	return sum;
}

/** @brief Returns relative memory index with respect to a multi-index
 *
 * @code auto j = access(0, strides{shape{4,2,3},first_order}, 2,3,4); @endcode
 *
 * @param[in] i   first element of the partial multi-index
 * @param[in] is  the following elements of the partial multi-index
 * @param[in] sum the current relative memory index
 * @returns relative memory location depending on \c i and \c w
*/
BOOST_UBLAS_INLINE
template<std::size_t r, class layout_type, class ... size_types>
auto access(std::size_t sum, basic_strides<std::size_t, layout_type> const& w, std::size_t i, size_types ... is)
{
	sum+=i*w[r];
	if constexpr (sizeof...(is) == 0)
		return sum;
	else
		return detail::access<r+1>(sum,w,std::forward<size_types>(is)...);
}

}

}
}
}

#endif

cmd: