Jpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | List of all members
JTOOLS::JRange< T, JComparator_t > Class Template Reference

Range of values. More...

#include <JRange.hh>

Inheritance diagram for JTOOLS::JRange< T, JComparator_t >:
JTOOLS::JPair< T, T > JLANG::JEquals< JFirst_t, JSecond_t > JMATH::JMath< JFirst_t, JSecond_t > JDETECTOR::JPMTRateRange JSUPPORT::JLimit JUTC::JUTCTimeRange JSUPPORT::JMultipleFileScanner< JNullType > JSUPPORT::JSingleFileScanner< JNullType > JSUPPORT::JTreeScannerInterface< JClass_t, JNullType > JDETECTOR::JDetectorHeader JDETECTOR::JDetector JDETECTOR::JMonteCarloDetector

Public Types

typedef JRange< T, JComparator_t > range_type
 
typedef JLANG::JClass< T >
::argument_type 
argument_type
 
typedef T key_type
 
typedef T mapped_type
 

Public Member Functions

 JRange ()
 Default constructor. More...
 
 JRange (argument_type x, argument_type y)
 Constructor. More...
 
 JRange (argument_type x)
 Constructor. More...
 
template<class iterator_type , class value_type , class result_type >
 JRange (iterator_type __begin, iterator_type __end, result_type value_type::*member)
 Constructor. More...
 
template<class iterator_type , class value_type , class result_type >
 JRange (iterator_type __begin, iterator_type __end, result_type(value_type::*function)() const)
 Constructor. More...
 
const range_typegetRange () const
 Get range. More...
 
void setRange (const range_type &range)
 Set range. More...
 
void setRange (argument_type x, argument_type y)
 Set lower and uppper limit. 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 uppper limit. 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 uppper limit. More...
 
getLowerLimit () const
 Get lower limit. More...
 
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...
 
getLength () const
 Get 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...
 
constrain (argument_type x) const
 Constrain value 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_typejoin (const range_type &range)
 Join ranges. More...
 
range_typecombine (const range_type &range)
 Combine ranges. More...
 
range_typeadd (argument_type x)
 Add offset. More...
 
range_typesub (argument_type x)
 Subtract offset. More...
 
range_typeadd (const range_type &range)
 Add offset. More...
 
range_typesub (const range_type &range)
 Subtract offset. More...
 
range_typemul (const double factor)
 Multiply range. More...
 
range_typediv (const double factor)
 Divide range. More...
 
getN (const double R) const
 Get expected number of occurances of given rate within this interval. More...
 
const key_typegetKey () const
 
const mapped_typegetValue () const
 
mapped_typegetValue ()
 
JFirst_t & mul (const JSecond_t &object)
 Multiply with object. More...
 

Static Public Member Functions

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

Public Attributes

JComparator_t compare
 Function object. More...
 
first
 
second
 

Static Public Attributes

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

Detailed Description

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

Range of values.

Definition at line 33 of file JRange.hh.

Member Typedef Documentation

template<class T, class JComparator_t = std::less<T>>
typedef JRange<T, JComparator_t> JTOOLS::JRange< T, JComparator_t >::range_type

Definition at line 40 of file JRange.hh.

template<class T, class JComparator_t = std::less<T>>
typedef JLANG::JClass<T>::argument_type JTOOLS::JRange< T, JComparator_t >::argument_type

Definition at line 41 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

template<class T, class JComparator_t = std::less<T>>
JTOOLS::JRange< T, JComparator_t >::JRange ( )
inline

Default constructor.

This range corresponds to the maximal possible range.

Definition at line 48 of file JRange.hh.

48  :
50  {}
static T getMinimum()
Get minimum possible value.
Definition: JRange.hh:485
static T getMaximum()
Get maximum possible value.
Definition: JRange.hh:496
template<class T, class JComparator_t = std::less<T>>
JTOOLS::JRange< T, JComparator_t >::JRange ( argument_type  x,
argument_type  y 
)
inline

Constructor.

Parameters
xlower limit
yupper limit

Definition at line 59 of file JRange.hh.

60  :
61  JPair<T,T>(x, y)
62  {}
template<class T, class JComparator_t = std::less<T>>
JTOOLS::JRange< T, JComparator_t >::JRange ( argument_type  x)
inline

Constructor.

Parameters
xlower and upper limit

Definition at line 70 of file JRange.hh.

70  :
71  JPair<T,T>(x, x)
72  {}
template<class T, class JComparator_t = std::less<T>>
template<class iterator_type , class value_type , class result_type >
JTOOLS::JRange< T, JComparator_t >::JRange ( iterator_type  __begin,
iterator_type  __end,
result_type value_type::*  member 
)
inline

Constructor.

Parameters
__beginbegin of data
__endend of data
memberpointer to data member

Definition at line 83 of file JRange.hh.

83  :
85  {
86  setRange(__begin, __end, member);
87  }
static T getMinimum()
Get minimum possible value.
Definition: JRange.hh:485
void setRange(const range_type &range)
Set range.
Definition: JRange.hh:120
static T getMaximum()
Get maximum possible value.
Definition: JRange.hh:496
template<class T, class JComparator_t = std::less<T>>
template<class iterator_type , class value_type , class result_type >
JTOOLS::JRange< T, JComparator_t >::JRange ( iterator_type  __begin,
iterator_type  __end,
result_type(value_type::*)() const  function 
)
inline

Constructor.

Parameters
__beginbegin of data
__endend of data
functionpointer to member method

Definition at line 98 of file JRange.hh.

99  {
100  setRange(__begin, __end, function);
101  }
static T getMinimum()
Get minimum possible value.
Definition: JRange.hh:485
void setRange(const range_type &range)
Set range.
Definition: JRange.hh:120
static T getMaximum()
Get maximum possible value.
Definition: JRange.hh:496

Member Function Documentation

template<class T, class JComparator_t = std::less<T>>
const range_type& JTOOLS::JRange< T, JComparator_t >::getRange ( ) const
inline

Get range.

Returns
range

Definition at line 109 of file JRange.hh.

110  {
111  return static_cast<const range_type&>(*this);
112  }
JRange< T, JComparator_t > range_type
Definition: JRange.hh:40
template<class T, class JComparator_t = std::less<T>>
void JTOOLS::JRange< T, JComparator_t >::setRange ( const range_type range)
inline

Set range.

Parameters
rangerange

Definition at line 120 of file JRange.hh.

121  {
122  static_cast<range_type&>(*this) = range;
123  }
JRange< T, JComparator_t > range_type
Definition: JRange.hh:40
template<class T, class JComparator_t = std::less<T>>
void JTOOLS::JRange< T, JComparator_t >::setRange ( argument_type  x,
argument_type  y 
)
inline

Set lower and uppper limit.

Parameters
xlower limit
yupper limit

Definition at line 132 of file JRange.hh.

133  {
134  this->first = x;
135  this->second = y;
136  }
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 
)
inline

Set lower and uppper limit.

Parameters
__beginbegin of data
__endend of data
memberpointer to data member

Definition at line 147 of file JRange.hh.

148  {
150 
151  for (iterator_type i = __begin; i != __end; ++i) {
152  include((*i).*member);
153  }
154  }
range_type include(argument_type x)
Include given value to range.
Definition: JRange.hh:336
static T getMinimum()
Get minimum possible value.
Definition: JRange.hh:485
void setRange(const range_type &range)
Set range.
Definition: JRange.hh:120
static T getMaximum()
Get maximum possible value.
Definition: JRange.hh:496
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 
)
inline

Set lower and uppper limit.

Parameters
__beginbegin of data
__endend of data
functionpointer to member method

Definition at line 165 of file JRange.hh.

166  {
168 
169  for (iterator_type i = __begin; i != __end; ++i) {
170  include(((*i).*function)());
171  }
172  }
range_type include(argument_type x)
Include given value to range.
Definition: JRange.hh:336
static T getMinimum()
Get minimum possible value.
Definition: JRange.hh:485
void setRange(const range_type &range)
Set range.
Definition: JRange.hh:120
static T getMaximum()
Get maximum possible value.
Definition: JRange.hh:496
template<class T, class JComparator_t = std::less<T>>
T JTOOLS::JRange< T, JComparator_t >::getLowerLimit ( ) const
inline

Get lower limit.

Returns
lower limit

Definition at line 180 of file JRange.hh.

181  {
182  return this->first;
183  }
template<class T, class JComparator_t = std::less<T>>
T JTOOLS::JRange< T, JComparator_t >::getUpperLimit ( ) const
inline

Get upper limit.

Returns
upper limit

Definition at line 191 of file JRange.hh.

192  {
193  return this->second;
194  }
template<class T, class JComparator_t = std::less<T>>
void JTOOLS::JRange< T, JComparator_t >::setLowerLimit ( argument_type  x)
inline

Set lower limit.

Parameters
xlower limit

Definition at line 202 of file JRange.hh.

203  {
204  this->first = x;
205  }
template<class T, class JComparator_t = std::less<T>>
void JTOOLS::JRange< T, JComparator_t >::setUpperLimit ( argument_type  y)
inline

Set upper limit.

Parameters
yupper limit

Definition at line 213 of file JRange.hh.

214  {
215  this->second = y;
216  }
template<class T, class JComparator_t = std::less<T>>
void JTOOLS::JRange< T, JComparator_t >::fixLowerLimit ( argument_type  x)
inline

Fix lower limit.

The range is shifted to the given lower limit.

Parameters
xlower limit

Definition at line 226 of file JRange.hh.

227  {
228  this->second += x - this->first;
229  this->first = x;
230  }
template<class T, class JComparator_t = std::less<T>>
void JTOOLS::JRange< T, JComparator_t >::fixUpperLimit ( argument_type  y)
inline

Fix upper limit.

The range is shifted to the given upper limit.

Parameters
yupper limit

Definition at line 240 of file JRange.hh.

241  {
242  this->first += y - this->second;
243  this->second = y;
244  }
template<class T, class JComparator_t = std::less<T>>
bool JTOOLS::JRange< T, JComparator_t >::equals ( const range_type range) const
inline

Equal method.

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

Definition at line 253 of file JRange.hh.

254  {
255  return (!this->compare(this->getLowerLimit(), range.getLowerLimit()) &&
256  !this->compare(range.getLowerLimit(), this->getLowerLimit()) &&
257  !this->compare(this->getUpperLimit(), range.getUpperLimit()) &&
258  !this->compare(range.getUpperLimit(), this->getUpperLimit()));
259  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
T JTOOLS::JRange< T, JComparator_t >::getLength ( ) const
inline

Get length (difference between upper and lower limit).

Returns
length

Definition at line 267 of file JRange.hh.

268  {
269  return getUpperLimit() - getLowerLimit();
270  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
bool JTOOLS::JRange< T, JComparator_t >::is_valid ( ) const
inline

Check validity of range.

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

Definition at line 278 of file JRange.hh.

279  {
280  return !compare(getUpperLimit(), getLowerLimit());
281  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
bool JTOOLS::JRange< T, JComparator_t >::operator() ( argument_type  x) const
inline

Test whether value is inside range.

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

Definition at line 290 of file JRange.hh.

291  {
292  return (!compare(x, getLowerLimit()) &&
293  !compare(getUpperLimit(), x));
294  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
T JTOOLS::JRange< T, JComparator_t >::constrain ( argument_type  x) const
inline

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
xvalue
Returns
lower limit <= x <= upper limit

Definition at line 305 of file JRange.hh.

306  {
307  if (compare(x, getLowerLimit())) return getLowerLimit();
308  if (compare(getUpperLimit(), x)) return getUpperLimit();
309 
310  return x;
311  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
bool JTOOLS::JRange< T, JComparator_t >::overlap ( const range_type range) const
inline

Test overlap with given range.

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

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

Definition at line 321 of file JRange.hh.

322  {
323  return (compare(getLowerLimit(), range.getUpperLimit()) &&
324  compare(range.getLowerLimit(), getUpperLimit()));
325  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
range_type JTOOLS::JRange< T, JComparator_t >::include ( argument_type  x)
inline

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
xvalue
Returns
range

Definition at line 336 of file JRange.hh.

337  {
338  if (compare(x, getLowerLimit())) setLowerLimit(x);
339  if (compare(getUpperLimit(), x)) setUpperLimit(x);
340 
341  return *this;
342  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
void setUpperLimit(argument_type y)
Set upper limit.
Definition: JRange.hh:213
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
void setLowerLimit(argument_type x)
Set lower limit.
Definition: JRange.hh:202
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::join ( const range_type range)
inline

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
rangerange

Definition at line 354 of file JRange.hh.

355  {
356  if (compare(getLowerLimit(), range.getLowerLimit())) setLowerLimit(range.getLowerLimit());
357  if (compare(range.getUpperLimit(), getUpperLimit())) setUpperLimit(range.getUpperLimit());
358 
359  return *this;
360  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
void setUpperLimit(argument_type y)
Set upper limit.
Definition: JRange.hh:213
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
void setLowerLimit(argument_type x)
Set lower limit.
Definition: JRange.hh:202
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::combine ( const range_type range)
inline

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
rangerange

Definition at line 371 of file JRange.hh.

372  {
373  if (compare(range.getLowerLimit(), getLowerLimit())) setLowerLimit(range.getLowerLimit());
374  if (compare(getUpperLimit(), range.getUpperLimit())) setUpperLimit(range.getUpperLimit());
375 
376  return *this;
377  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
JComparator_t compare
Function object.
Definition: JRange.hh:516
void setUpperLimit(argument_type y)
Set upper limit.
Definition: JRange.hh:213
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
void setLowerLimit(argument_type x)
Set lower limit.
Definition: JRange.hh:202
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::add ( argument_type  x)
inline

Add offset.

Parameters
xoffset

Definition at line 385 of file JRange.hh.

386  {
387  this->first += x;
388  this->second += x;
389 
390  return *this;
391  }
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::sub ( argument_type  x)
inline

Subtract offset.

Parameters
xoffset

Definition at line 399 of file JRange.hh.

400  {
401  this->first -= x;
402  this->second -= x;
403 
404  return *this;
405  }
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::add ( const range_type range)
inline

Add offset.

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
rangeoffset

Definition at line 415 of file JRange.hh.

416  {
417  this->first += range.getLowerLimit();
418  this->second += range.getUpperLimit();
419 
420  return *this;
421  }
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::sub ( const range_type range)
inline

Subtract offset.

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
rangeoffset

Definition at line 431 of file JRange.hh.

432  {
433  this->first -= range.getLowerLimit();
434  this->second -= range.getUpperLimit();
435 
436  return *this;
437  }
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::mul ( const double  factor)
inline

Multiply range.

Parameters
factorfactor

Definition at line 445 of file JRange.hh.

446  {
447  this->first *= factor;
448  this->second *= factor;
449 
450  return *this;
451  }
template<class T, class JComparator_t = std::less<T>>
range_type& JTOOLS::JRange< T, JComparator_t >::div ( const double  factor)
inline

Divide range.

Parameters
factorfactor

Definition at line 459 of file JRange.hh.

460  {
461  this->first /= factor;
462  this->second /= factor;
463 
464  return *this;
465  }
template<class T, class JComparator_t = std::less<T>>
T JTOOLS::JRange< T, JComparator_t >::getN ( const double  R) const
inline

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

Parameters
Rrate
Returns
expectation value

Definition at line 474 of file JRange.hh.

475  {
476  return R * (getUpperLimit() - getLowerLimit());
477  }
T getLowerLimit() const
Get lower limit.
Definition: JRange.hh:180
T getUpperLimit() const
Get upper limit.
Definition: JRange.hh:191
template<class T, class JComparator_t = std::less<T>>
static T JTOOLS::JRange< T, JComparator_t >::getMinimum ( )
inlinestatic

Get minimum possible value.

Returns
minimum possible value

Definition at line 485 of file JRange.hh.

486  {
487  return JMATH::JLimits<T>::min();
488  }
float min()
Definition: JLimits.hh:96
template<class T, class JComparator_t = std::less<T>>
static T JTOOLS::JRange< T, JComparator_t >::getMaximum ( )
inlinestatic

Get maximum possible value.

Returns
maximum possible value

Definition at line 496 of file JRange.hh.

497  {
498  return JMATH::JLimits<T>::max();
499  }
Auxiliary class for minimum and maximum values for any class.
Definition: JLimits.hh:21
const key_type& JTOOLS::JPair< T , T >::getKey ( ) const
inlineinherited

Definition at line 123 of file JPair.hh.

123 { return this->first; }
const mapped_type& JTOOLS::JPair< T , T >::getValue ( ) const
inlineinherited

Definition at line 124 of file JPair.hh.

124 { return this->second; }
mapped_type& JTOOLS::JPair< T , T >::getValue ( )
inlineinherited

Definition at line 126 of file JPair.hh.

126 { return this->second; }
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
objectobject
Returns
result object

Definition at line 273 of file JMath.hh.

274  {
275  return static_cast<JFirst_t&>(*this) = JCalculator<JFirst_t>::calculator.mul(static_cast<const JFirst_t&>(*this), object);
276  }
Auxiliary class for product evaluation of objects.
Definition: JCalculator.hh:18

Member Data Documentation

template<class T, class JComparator_t = std::less<T>>
const JRange< T, JComparator_t > JTOOLS::JRange< T, JComparator_t >::DEFAULT_RANGE
static

Default range.

This range corresponds to an unphysical range.

Definition at line 506 of file JRange.hh.

template<class T, class JComparator_t = std::less<T>>
JComparator_t JTOOLS::JRange< T, JComparator_t >::compare

Function object.

Parameters
firstfirst argument
secondsecond argument
Returns
true if first < second; else false

Definition at line 516 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 class was generated from the following file: