Range, vaguely a la Intel TBB, to encapsulate a random-access, STL-like start and end iterator with chunksize. More...

#include <range.h>

Public Types
using	iterator = iteratorT
	Alias for the iterator type.

Public Member Functions
	Range (const iterator &start, const iterator &finish, int chunk=1)
	Makes the range [start, finish).

	Range (const Range &r)
	Copy constructor. Cost is O(1).

	Range (Range &left, const Split &)
	Splits range between new and old (r) objects. Cost is O(1).

const iterator &	begin () const
	Access the beginning.

bool	empty () const
	Returns true if `size == 0`.

const iterator &	end () const
	Access the end.

unsigned int	get_chunksize () const
	Access the chunk size.

bool	is_divisible () const
	Return true if this iteration range can be divided; that is, there are more items than the chunk size.

size_t	size () const
	Returns the number of items in the range (cost is O(1)).

Static Private Member Functions
template<typename integralT , typename distanceT >
static std::enable_if< std::is_integral< integralT >::value, void >::type	advance (integralT &i, distanceT n)
	Advance by `n` elements in the range.

template<typename iterT , typename distanceT >
static std::enable_if<!std::is_integral< iterT >::value, void >::type	advance (iterT &it, distanceT n)
	Advance by `n` elements in the range.

template<class integralT >
static std::enable_if< std::is_integral< integralT >::value, integralT >::type	distance (integralT first, integralT last)
	Calculate the distance between two iterators.

template<class iterT >
static auto	distance (iterT first, iterT last, typename std::enable_if<!std::is_integral< iterT >::value >::type *=nullptr) -> decltype(std::distance(first, last))
	Calculate the distance between two iterators.

Private Attributes
int	chunksize
	Number of items to give to each thread/process.

iteratorT	finish
	Last item for iteration (first past the end, conventionally).

long	n
	Number of items to iterator over.

iteratorT	start
	First item for iteration.

Detailed Description

template<typename iteratorT>
class madness::Range< iteratorT >

Range, vaguely a la Intel TBB, to encapsulate a random-access, STL-like start and end iterator with chunksize.

Template Parameters

iteratorT The iterator type.

Member Typedef Documentation

◆ iterator

template<typename iteratorT >

using madness::Range< iteratorT >::iterator = iteratorT

Alias for the iterator type.

Constructor & Destructor Documentation

◆ Range() [1/3]

template<typename iteratorT >

madness::Range< iteratorT >::Range	(	const iterator &	start,
		const iterator &	finish,
		int	chunk = `1`
	)

inline

Makes the range [start, finish).

The motivated reader should look at the Intel TBB range, partitioner, split, concepts, etc.

Parameters

[in]	start	The first item to iterate over.
[in]	finish	The last item for iteration (one past the end).
[in]	chunk	The number of items to give to each thread/process.

References madness::Range< iteratorT >::chunksize.

◆ Range() [2/3]

template<typename iteratorT >

madness::Range< iteratorT >::Range ( const Range< iteratorT > & r )

inline

Copy constructor. Cost is O(1).

Todo:: Can we make this = default?

Parameters

[in] r The Range to copy.

◆ Range() [3/3]

template<typename iteratorT >

madness::Range< iteratorT >::Range	(	Range< iteratorT > &	left,
		const Split &
	)

inline

Splits range between new and old (r) objects. Cost is O(1).

Parameters

[in] left The range to be split.

References madness::Range< iteratorT >::advance(), madness::Range< iteratorT >::chunksize, madness::Range< iteratorT >::finish, madness::Range< iteratorT >::n, madness::nonlinear_vector_solver(), and madness::Range< iteratorT >::start.

Member Function Documentation

◆ advance() [1/2]

template<typename iteratorT >

template<typename integralT , typename distanceT >

static std::enable_if< std::is_integral< integralT >::value, void >::type madness::Range< iteratorT >::advance	(	integralT &	i,
		distanceT	n
	)

inlinestaticprivate

Advance by n elements in the range.

This version is for cases where the "iterator type" is integral.

Template Parameters

integralT	The integral iterator type.
distanceT	The distance type.

Parameters

[in,out]	i	The integral iterator.
[in]	n	The number of elements to advance.

References madness::Range< iteratorT >::n.

Referenced by madness::Range< iteratorT >::Range().

◆ advance() [2/2]

template<typename iteratorT >

template<typename iterT , typename distanceT >

static std::enable_if<!std::is_integral< iterT >::value, void >::type madness::Range< iteratorT >::advance	(	iterT &	it,
		distanceT	n
	)

inlinestaticprivate

Advance by n elements in the range.

This version is for cases where the "iterator type" is not integral.

Template Parameters

iterT	The non-integral iterator type.
distanceT	The distance type.

Parameters

[in,out]	it	The iterator.
[in]	n	The number of elements to advance.

References std::advance(), and madness::Range< iteratorT >::n.

◆ begin()

template<typename iteratorT >

const iterator & madness::Range< iteratorT >::begin ( ) const

inline

Access the beginning.

Returns: Iterator to the first element.

References madness::Range< iteratorT >::start.

◆ distance() [1/2]

template<typename iteratorT >

template<class integralT >

static std::enable_if< std::is_integral< integralT >::value, integralT >::type madness::Range< iteratorT >::distance	(	integralT	first,
		integralT	last
	)

inlinestaticprivate

Calculate the distance between two iterators.

This version is for cases where the "iterator type" is integral.

Template Parameters

integralT The integral iterator type.

Parameters

[in]	first	One iterator.
[in]	last	The other iterator.

Returns: The distance between the first and last iterators.

References madness::nonlinear_vector_solver().

◆ distance() [2/2]

template<typename iteratorT >

template<class iterT >

static auto madness::Range< iteratorT >::distance	(	iterT	first,
		iterT	last,
		typename std::enable_if<!std::is_integral< iterT >::value >::type *	= `nullptr`
	)		-> decltype(std::distance(first, last))

inlinestaticprivate

Calculate the distance between two iterators.

This version is for cases where the "iterator type" is not integral.

Template Parameters

iterT The non-integral iterator type.

Parameters

[in]	first	One iterator.
[in]	last	The other iterator.

Returns: The distance between the first and last iterators.

References std::distance(), and madness::nonlinear_vector_solver().

◆ empty()

template<typename iteratorT >

bool madness::Range< iteratorT >::empty ( ) const

inline

Returns true if size == 0.

Returns: True if size == 0.

References madness::Range< iteratorT >::n.

◆ end()

template<typename iteratorT >

const iterator & madness::Range< iteratorT >::end ( ) const

inline

Access the end.

Returns: Iterator to the last element (one past the end).

References madness::Range< iteratorT >::finish.

◆ get_chunksize()

template<typename iteratorT >

unsigned int madness::Range< iteratorT >::get_chunksize ( ) const

inline

Access the chunk size.

Todo:: Should this return long, or size_t?

Returns: The chunk size.

References madness::Range< iteratorT >::chunksize.

◆ is_divisible()

template<typename iteratorT >

bool madness::Range< iteratorT >::is_divisible ( ) const

inline

Return true if this iteration range can be divided; that is, there are more items than the chunk size.

Returns: True if this range can be divided.

References madness::Range< iteratorT >::chunksize, and madness::Range< iteratorT >::n.

◆ size()

template<typename iteratorT >

size_t madness::Range< iteratorT >::size ( ) const

inline

Returns the number of items in the range (cost is O(1)).

Returns: The number of items in the range.

References madness::Range< iteratorT >::n.

Referenced by split().

Member Data Documentation

◆ chunksize

template<typename iteratorT >

int madness::Range< iteratorT >::chunksize

private

Number of items to give to each thread/process.

Referenced by madness::Range< iteratorT >::Range(), madness::Range< iteratorT >::Range(), madness::Range< iteratorT >::get_chunksize(), and madness::Range< iteratorT >::is_divisible().

◆ finish

template<typename iteratorT >

iteratorT madness::Range< iteratorT >::finish

private

Last item for iteration (first past the end, conventionally).

Referenced by madness::Range< iteratorT >::Range(), and madness::Range< iteratorT >::end().

◆ n

template<typename iteratorT >

long madness::Range< iteratorT >::n

private

Number of items to iterator over.

Todo:: Could this be replaced by size_t?

Referenced by madness::Range< iteratorT >::Range(), madness::Range< iteratorT >::advance(), madness::Range< iteratorT >::advance(), madness::Range< iteratorT >::empty(), madness::Range< iteratorT >::is_divisible(), and madness::Range< iteratorT >::size().

◆ start

template<typename iteratorT >

iteratorT madness::Range< iteratorT >::start

private

First item for iteration.

Referenced by madness::Range< iteratorT >::Range(), and madness::Range< iteratorT >::begin().

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

range.h

Public Types

Public Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ iterator

Constructor & Destructor Documentation

◆ Range() [1/3]

◆ Range() [2/3]

◆ Range() [3/3]

Member Function Documentation

◆ advance() [1/2]

◆ advance() [2/2]

◆ begin()

◆ distance() [1/2]

◆ distance() [2/2]

◆ empty()

◆ end()

◆ get_chunksize()

◆ is_divisible()

◆ size()

Member Data Documentation

◆ chunksize

◆ finish

◆ n

◆ start