Auxiliary class for defining the range of iterations of objects. More...

#include <JLimit.hh>

Inheritance diagram for JSUPPORT::JLimit:

Public Types
typedef JRange< counter_type >	range_type

typedef JLANG::JClass< T > ::argument_type	argument_type

typedef T	key_type

typedef T	mapped_type

Public Member Functions
	JLimit ()
	Default constructor. More...

	JLimit (const counter_type counter)
	Constructor. More...

const JLimit &	getLimit () const
	Get limit. More...

JLimit &	getLimit ()
	Get limit. More...

void	setLimit (const JLimit &limit)
	Set limit. More...

bool	less (const JLimit &limit) const
	Compare limit. More...

bool	less (const counter_type counter) const
	Compare counter. More...

bool	more (const counter_type counter) const
	Compare counter. More...

const range_type &	getRange () const
	Get range. More...

void	setRange (const range_type &range)
	Set range. More...

void	setRange (argument_type x, argument_type y)
	Set lower and upper limit. More...

template<class R >
void	setRange (R first, R second)
	Set range. More...

template<class iterator_type , class value_type , class result_type >
void	setRange (iterator_type __begin, iterator_type __end, result_type value_type::*member)
	Set lower and upper limit according to minimal and maximal value in input data, respectively. More...

template<class iterator_type , class value_type , class result_type >
void	setRange (iterator_type __begin, iterator_type __end, result_type(value_type::*function)() const)
	Set lower and upper limit according to minimal and maximal value in input data, respectively. More...

T	getLowerLimit () const
	Get lower limit. More...

T	getUpperLimit () const
	Get upper limit. More...

void	setLowerLimit (argument_type x)
	Set lower limit. More...

void	setUpperLimit (argument_type y)
	Set upper limit. More...

void	fixLowerLimit (argument_type x)
	Fix lower limit. More...

void	fixUpperLimit (argument_type y)
	Fix upper limit. More...

bool	equals (const range_type &range) const
	Equal method. More...

T	getLength () const
	Get length (difference between upper and lower limit). More...

void	setLength (argument_type length)
	Set length (difference between upper and lower limit). More...

bool	is_valid () const
	Check validity of range. More...

bool	operator() (argument_type x) const
	Test whether value is inside range. More...

T	constrain (argument_type x) const
	Constrain value to range. More...

T	mod (argument_type x) const
	Modulo value with respect to range. More...

bool	overlap (const range_type &range) const
	Test overlap with given range. More...

range_type	include (argument_type x)
	Include given value to range. More...

range_type &	join (const range_type &range)
	Join ranges. More...

range_type &	combine (const range_type &range)
	Combine ranges. More...

range_type &	add (argument_type x)
	Add offset. More...

range_type &	add (const range_type &range)
	Add offsets. More...

range_type &	sub (argument_type x)
	Subtract offset. More...

range_type &	sub (const range_type &range)
	Subtract offsets. More...

range_type &	mul (const double factor)
	Multiply range. More...

JFirst_t &	mul (const JSecond_t &object)
	Multiply with object. More...

range_type &	div (const double factor)
	Divide range. More...

T	getN (const double R) const
	Get expected number of occurances of given rate within this interval. More...

const key_type &	getKey () const

const mapped_type &	getValue () const

mapped_type &	getValue ()

Static Public Member Functions
static counter_type	min ()
	Get minimum counter value. More...

static counter_type	max ()
	Get maximum counter value. More...

static T	getMinimum ()
	Get minimum possible value. More...

static T	getMaximum ()
	Get maximum possible value. More...

Public Attributes
JComparator_t	compare
	Function object. More...

T	first

T	second

Static Public Attributes
static const char	SEPARATOR = ':'
	separator between values More...

static const JRange< T, JComparator_t >	DEFAULT_RANGE
	Default range. More...

Protected Member Functions
template<class R >
void	setRange (R first, R second, const JLANG::JBool< false > &option)
	Set range. More...

template<class R >
void	setRange (R first, R second, const JLANG::JBool< true > &option)
	Set range. More...

Friends
std::istream &	operator>> (std::istream &in, JLimit &limit)
	Read limit from input. More...

Detailed Description

Auxiliary class for defining the range of iterations of objects.

Possible input syntax:

    <begin of iteration>:<number of iterations>
    <number of iterations>

where the iteration starts at 0.

Definition at line 41 of file JLimit.hh.

Member Typedef Documentation

typedef JRange<counter_type> JSUPPORT::JLimit::range_type

Definition at line 47 of file JLimit.hh.

template<class T, class JComparator_t = std::less<T>>

typedef JLANG::JClass<T>::argument_type JTOOLS::JRange< T, JComparator_t >::argument_type

inherited

Definition at line 42 of file JRange.hh.

typedef T JTOOLS::JPair< T , T >::key_type

inherited

Definition at line 32 of file JPair.hh.

typedef T JTOOLS::JPair< T , T >::mapped_type

inherited

Definition at line 33 of file JPair.hh.

Constructor & Destructor Documentation

JSUPPORT::JLimit::JLimit ( )

inline

Default constructor.

Definition at line 53 of file JLimit.hh.

              :
       JRange<counter_type>(JLimit::min(), JLimit::max())
     {}

JSUPPORT::JLimit::JLimit ( const counter_type counter )

inline

Constructor.

Parameters

counter end of iteration

Definition at line 63 of file JLimit.hh.

                                        :
       JRange<counter_type>(JLimit::min(), counter)
     {}

Member Function Documentation

const JLimit& JSUPPORT::JLimit::getLimit ( ) const

inline

Get limit.

Returns: this limit

Definition at line 73 of file JLimit.hh.

     { 
       return static_cast<const JLimit&>(*this);
     }

JLimit& JSUPPORT::JLimit::getLimit ( )

inline

Get limit.

Returns: this limit

Definition at line 84 of file JLimit.hh.

     {
       return static_cast<JLimit&>(*this);
     }

void JSUPPORT::JLimit::setLimit ( const JLimit & limit )

inline

Set limit.

Parameters

limit limit

Definition at line 95 of file JLimit.hh.

     {
       static_cast<JLimit&>(*this) = limit;
     }

static counter_type JSUPPORT::JLimit::min ( )

inlinestatic

Get minimum counter value.

Returns: value

Definition at line 106 of file JLimit.hh.

     {
       return 0;
     }

static counter_type JSUPPORT::JLimit::max ( )

inlinestatic

Get maximum counter value.

Returns: value

Definition at line 117 of file JLimit.hh.

     {
       return std::numeric_limits<counter_type>::max();
     }

bool JSUPPORT::JLimit::less ( const JLimit & limit ) const

inline

Compare limit.

Parameters

limit limit

Returns: true if this upper limit is less then given upper limit; else false

Definition at line 129 of file JLimit.hh.

     { 
       return getUpperLimit() < limit.getUpperLimit();
     }

bool JSUPPORT::JLimit::less ( const counter_type counter ) const

inline

Compare counter.

Parameters

counter counter

Returns: true if this upper limit is less than counter; else false

Definition at line 141 of file JLimit.hh.

     { 
       return getUpperLimit() < counter;
     }

bool JSUPPORT::JLimit::more ( const counter_type counter ) const

inline

Compare counter.

Parameters

counter counter

Returns: true if this upper limit is more than counter; else false

Definition at line 153 of file JLimit.hh.

     { 
       return getUpperLimit() > counter;
     }

template<class T, class JComparator_t = std::less<T>>

const range_type& JTOOLS::JRange< T, JComparator_t >::getRange ( ) const

inlineinherited

Get range.

Returns: range

Definition at line 128 of file JRange.hh.

     {
       return static_cast<const range_type&>(*this);
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setRange ( const range_type & range )

inlineinherited

Set range.

Parameters

range range

Definition at line 139 of file JRange.hh.

     {
       static_cast<range_type&>(*this) = range;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setRange	(	argument_type	x,
		argument_type	y
	)

inlineinherited

Set lower and upper limit.

Parameters

x	lower limit
y	upper limit

Definition at line 151 of file JRange.hh.

     {
       this->first  = x;
       this->second = y;
     }

template<class T, class JComparator_t = std::less<T>>

template<class R >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	R	first,
		R	second
	)

inlineinherited

Set range.

The arguments could be values or iterators.

Parameters

first	first
second	second

Definition at line 166 of file JRange.hh.

     {
       using namespace JLANG;
       
       setRange(first, second, JBool<is_iterator<R>::value>());
     }

template<class T, class JComparator_t = std::less<T>>

template<class iterator_type , class value_type , class result_type >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	iterator_type	__begin,
		iterator_type	__end,
		result_type value_type::*	member
	)

inlineinherited

Set lower and upper limit according to minimal and maximal value in input data, respectively.

Parameters

__begin	begin of data
__end	end of data
member	pointer to data member

Definition at line 182 of file JRange.hh.

     {
       setRange(getMaximum(), getMinimum());
 
       for (iterator_type i = __begin; i != __end; ++i) {
         include((*i).*member);
       }
     }

template<class T, class JComparator_t = std::less<T>>

template<class iterator_type , class value_type , class result_type >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	iterator_type	__begin,
		iterator_type	__end,
		result_type(value_type::*)() const	function
	)

inlineinherited

Set lower and upper limit according to minimal and maximal value in input data, respectively.

Parameters

__begin	begin of data
__end	end of data
function	pointer to member method

Definition at line 200 of file JRange.hh.

     {
       setRange(getMaximum(), getMinimum());
 
       for (iterator_type i = __begin; i != __end; ++i) {
         include(((*i).*function)());
       }
     }

template<class T, class JComparator_t = std::less<T>>

template<class R >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	R	first,
		R	second,
		const JLANG::JBool< false > &	option
	)

inlineprotectedinherited

Set range.

Parameters

first	first
second	second
option	false

Definition at line 590 of file JRange.hh.

     {
       setRange((argument_type) first, (argument_type) second);
     }

template<class T, class JComparator_t = std::less<T>>

template<class R >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	R	first,
		R	second,
		const JLANG::JBool< true > &	option
	)

inlineprotectedinherited

Set range.

Parameters

first	first
second	second
option	true

Definition at line 604 of file JRange.hh.

     {
       setRange(getMaximum(), getMinimum());
 
       for (R i = first; i != second; ++i) {
         include(*i);
       }
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getLowerLimit ( ) const

inlineinherited

Get lower limit.

Returns: lower limit

Definition at line 215 of file JRange.hh.

     {
       return this->first;
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getUpperLimit ( ) const

inlineinherited

Get upper limit.

Returns: upper limit

Definition at line 226 of file JRange.hh.

     {
       return this->second;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setLowerLimit ( argument_type x )

inlineinherited

Set lower limit.

Parameters

x	lower limit

Definition at line 237 of file JRange.hh.

     {
       this->first  = x;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setUpperLimit ( argument_type y )

inlineinherited

Set upper limit.

Parameters

y	upper limit

Definition at line 248 of file JRange.hh.

     {
       this->second = y;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::fixLowerLimit ( argument_type x )

inlineinherited

Fix lower limit.

The range is shifted to the given lower limit.

Parameters

x	lower limit

Definition at line 261 of file JRange.hh.

     {
       this->second += x - this->first;
       this->first   = x;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::fixUpperLimit ( argument_type y )

inlineinherited

Fix upper limit.

The range is shifted to the given upper limit.

Parameters

y	upper limit

Definition at line 275 of file JRange.hh.

     {
       this->first  += y - this->second;
       this->second  = y;
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::equals ( const range_type & range ) const

inlineinherited

Equal method.

Parameters

range range

Returns: true if this module range equal to given module range; else false

Definition at line 288 of file JRange.hh.

     {
       return (!this->compare(this->getLowerLimit(), range.getLowerLimit()) &&
               !this->compare(range.getLowerLimit(), this->getLowerLimit()) &&
               !this->compare(this->getUpperLimit(), range.getUpperLimit()) &&
               !this->compare(range.getUpperLimit(), this->getUpperLimit()));
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getLength ( ) const

inlineinherited

Get length (difference between upper and lower limit).

Returns: length

Definition at line 302 of file JRange.hh.

     {
       return getUpperLimit() - getLowerLimit();
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setLength ( argument_type length )

inlineinherited

Set length (difference between upper and lower limit).

Parameters

length length

Definition at line 313 of file JRange.hh.

     {
       setUpperLimit(getLowerLimit() + length);
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::is_valid ( ) const

inlineinherited

Check validity of range.

Returns: true if lower limit less than or equal to upper limit; else false

Definition at line 324 of file JRange.hh.

     {
       return !compare(getUpperLimit(), getLowerLimit());
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::operator() ( argument_type x ) const

inlineinherited

Test whether value is inside range.

Parameters

x value

Returns: true if lower limit <= value <= upper limit; else false

Definition at line 336 of file JRange.hh.

     {
       return (!compare(x, getLowerLimit()) && 
               !compare(getUpperLimit(), x));
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::constrain ( argument_type x ) const

inlineinherited

Constrain value to range.

This method returns the original value if it is in this range, else lower limit if value < lower limit or upper limit if value > upper limit.

Parameters

x value

Returns: lower limit <= x <= upper limit

Definition at line 351 of file JRange.hh.

     {
       if (compare(x, getLowerLimit())) { return getLowerLimit(); }
       if (compare(getUpperLimit(), x)) { return getUpperLimit(); }
 
       return x;
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::mod ( argument_type x ) const

inlineinherited

Modulo value with respect to range.

Parameters

x value

Returns: lower limit <= x <= upper limit

Definition at line 366 of file JRange.hh.

     {
       if      (compare(x, getLowerLimit()))
         return x + getLength() * floor((getUpperLimit() - x) / getLength());
       else if (compare(getUpperLimit(), x))
         return x - getLength() * floor((x - getLowerLimit()) / getLength());
       else
         return x;
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::overlap ( const range_type & range ) const

inlineinherited

Test overlap with given range.

The result is equivalent to join(range).is_valid().

Parameters

range range

Returns: true if there is a non-zero overlap; else false

Definition at line 384 of file JRange.hh.

     {  
       return (compare(getLowerLimit(), range.getUpperLimit()) &&
               compare(range.getLowerLimit(), getUpperLimit()));
     }

template<class T, class JComparator_t = std::less<T>>

range_type JTOOLS::JRange< T, JComparator_t >::include ( argument_type x )

inlineinherited

Include given value to range.

The new lower limit is the minimim of the original lower limit and given value and
the new upper limit is the maximum of the original upper limit and given value;

Parameters

x value

Returns: range

Definition at line 399 of file JRange.hh.

     {
       if (compare(x, getLowerLimit())) { setLowerLimit(x); }
       if (compare(getUpperLimit(), x)) { setUpperLimit(x); }
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::join ( const range_type & range )

inlineinherited

Join ranges.

The new lower limit is the maximim of the two lower limits and
the new upper limit is the minimum of the two upper limits.
This operation results in an equal or smaller range and may result in an unphysical range (i.e. lower limit > upper limit).

Parameters

range range

Definition at line 417 of file JRange.hh.

     {  
       if (compare(getLowerLimit(), range.getLowerLimit())) { setLowerLimit(range.getLowerLimit()); }
       if (compare(range.getUpperLimit(), getUpperLimit())) { setUpperLimit(range.getUpperLimit()); }
 
       return *this;      
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::combine ( const range_type & range )

inlineinherited

Combine ranges.

The new lower limit is the minimim of the two lower limits and
the new upper limit is the maximum of the two upper limits.
This operation results in an equal or larger range.

Parameters

range range

Definition at line 434 of file JRange.hh.

     {  
       if (compare(range.getLowerLimit(), getLowerLimit())) { setLowerLimit(range.getLowerLimit()); }
       if (compare(getUpperLimit(), range.getUpperLimit())) { setUpperLimit(range.getUpperLimit()); }
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::add ( argument_type x )

inlineinherited

Add offset.

Parameters

x offset

Definition at line 448 of file JRange.hh.

     { 
       this->first  += x;
       this->second += x;
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::add ( const range_type & range )

inlineinherited

Add offsets.

The new lower limit is the sum of the two lower limits and
the new upper limit is the sum of the two upper limits.

Parameters

range offset

Definition at line 478 of file JRange.hh.

     { 
       this->first  += range.getLowerLimit();
       this->second += range.getUpperLimit();
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::sub ( argument_type x )

inlineinherited

Subtract offset.

Parameters

x offset

Definition at line 462 of file JRange.hh.

     { 
       this->first  -= x;
       this->second -= x;
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::sub ( const range_type & range )

inlineinherited

Subtract offsets.

The new lower limit is the difference of the two lower limits and
the new upper limit is the difference of the two upper limits.

Parameters

range offset

Definition at line 494 of file JRange.hh.

     { 
       this->first  -= range.getLowerLimit();
       this->second -= range.getUpperLimit();
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::mul ( const double factor )

inlineinherited

Multiply range.

Parameters

factor factor

Definition at line 508 of file JRange.hh.

     { 
       this->first  *= factor;
       this->second *= factor;
 
       return *this;
     }

template<class JFirst_t, class JSecond_t = JNullType>

JFirst_t& JMATH::JMath< JFirst_t, JSecond_t >::mul ( const JSecond_t & object )

inlineinherited

Multiply with object.

Parameters

object object

Returns: result object

Definition at line 273 of file JMath.hh.

     {
       return static_cast<JFirst_t&>(*this) = JCalculator<JFirst_t>::calculator.mul(static_cast<const JFirst_t&>(*this), object);
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::div ( const double factor )

inlineinherited

Divide range.

Parameters

factor factor

Definition at line 522 of file JRange.hh.

     { 
       this->first  /= factor;
       this->second /= factor;
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getN ( const double R ) const

inlineinherited

Get expected number of occurances of given rate within this interval.

Parameters

R rate

Returns: expectation value

Definition at line 537 of file JRange.hh.

     {
       return R * (getUpperLimit() - getLowerLimit());
     }

template<class T, class JComparator_t = std::less<T>>

static T JTOOLS::JRange< T, JComparator_t >::getMinimum ( )

inlinestaticinherited

Get minimum possible value.

Returns: minimum possible value

Definition at line 548 of file JRange.hh.

     { 
       return JMATH::JLimits<T>::min();
     }

template<class T, class JComparator_t = std::less<T>>

static T JTOOLS::JRange< T, JComparator_t >::getMaximum ( )

inlinestaticinherited

Get maximum possible value.

Returns: maximum possible value

Definition at line 559 of file JRange.hh.

     { 
       return JMATH::JLimits<T>::max();
     }

const key_type& JTOOLS::JPair< T , T >::getKey ( ) const

inlineinherited

Definition at line 123 of file JPair.hh.

123 { return this->first; }

JTOOLS::JPair< T, T >::first

T first

Definition: JPair.hh:128

const mapped_type& JTOOLS::JPair< T , T >::getValue ( ) const

inlineinherited

Definition at line 124 of file JPair.hh.

124 { return this->second; }

JTOOLS::JPair< T, T >::second

T second

Definition: JPair.hh:129

mapped_type& JTOOLS::JPair< T , T >::getValue ( )

inlineinherited

Definition at line 126 of file JPair.hh.

126 { return this->second; }

JTOOLS::JPair< T, T >::second

T second

Definition: JPair.hh:129

Friends And Related Function Documentation

std::istream& operator>>	(	std::istream &	in,
		JLimit &	limit
	)

friend

Read limit from input.

Note that input n will set the begin and end of the iteration to 0 and n, respectively; and input i:n will set the begin and end of the iteration to i and i+n, respectively.

Parameters

in	input stream
limit	limit

Returns: input stream

Definition at line 169 of file JLimit.hh.

     {
       using namespace std;
 
       limit.setLowerLimit(JLimit::min());
       limit.setUpperLimit(JLimit::max());
 
       string buffer;
 
       if (in >> buffer) {
 
         string::size_type pos = buffer.find(SEPARATOR);
 
         if (pos != string::npos) {
           
           buffer[pos] = ' ';
 
           istringstream is(buffer);
           
           if (is >> static_cast<range_type&>(limit)) {
             limit.setUpperLimit(limit.getLowerLimit() + limit.getUpperLimit());
           }
 
         } else {
 
           counter_type value;
           
           istringstream is(buffer);
 
           is >> value;
 
           limit.setUpperLimit(value);
         }
       }
 
       return in;
     }

Member Data Documentation

const char JSUPPORT::JLimit::SEPARATOR = ':'

static

separator between values

Definition at line 208 of file JLimit.hh.

template<class T, class JComparator_t = std::less<T>>

const JRange< T, JComparator_t > JTOOLS::JRange< T, JComparator_t >::DEFAULT_RANGE

staticinherited

Default range.

This range corresponds to an unphysical range.

Definition at line 569 of file JRange.hh.

template<class T, class JComparator_t = std::less<T>>

JComparator_t JTOOLS::JRange< T, JComparator_t >::compare

inherited

Function object.

Parameters

first	first argument
second	second argument

Returns: true if first < second; else false

Definition at line 579 of file JRange.hh.

T JTOOLS::JPair< T , T >::first

inherited

Definition at line 128 of file JPair.hh.

T JTOOLS::JPair< T , T >::second

inherited

Definition at line 129 of file JPair.hh.

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

JLimit.hh

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation