Class implementing linear approximation policy (meaning possible value are split out in interval). More...

#include <linearApproximationPolicy.h>

Inheritance diagram for gum::LinearApproximationPolicy< GUM_SCALAR >:

Collaboration diagram for gum::LinearApproximationPolicy< GUM_SCALAR >:

Public Member Functions
Constructors / Destructors
	LinearApproximationPolicy (GUM_SCALAR low=(GUM_SCALAR) 0.0, GUM_SCALAR high=(GUM_SCALAR) 1.0, GUM_SCALAR eps=(GUM_SCALAR) 0.1)
	Default constructor. More...

	LinearApproximationPolicy (const LinearApproximationPolicy< GUM_SCALAR > *md)
	Copy constructor. More...

Accessors/Modifiers
GUM_SCALAR	fromExact (const GUM_SCALAR &value) const
	Convert value to his approximation. More...

void	combineAdd (const ApproximationPolicy< GUM_SCALAR > *ap)
	Combine using addition with the given gum::ApproximationPolicy. More...

void	combineSub (const ApproximationPolicy< GUM_SCALAR > *ap)
	Combine using substraction with the given gum::ApproximationPolicy. More...

void	combineMult (const ApproximationPolicy< GUM_SCALAR > *ap)
	Combine using multiplication with the given gum::ApproximationPolicy. More...

void	combineDiv (const ApproximationPolicy< GUM_SCALAR > *ap)
	Combine using division with the given gum::ApproximationPolicy. More...

void	combineMax (const ApproximationPolicy< GUM_SCALAR > *ap)
	Combine using max with the given gum::ApproximationPolicy. More...

void	combineMin (const ApproximationPolicy< GUM_SCALAR > *ap)
	Combine using min with the given gum::ApproximationPolicy. More...

GUM_SCALAR	safeFromExact (const GUM_SCALAR &value)
	Convert value to his approximation. More...

Idx	encode (const GUM_SCALAR &value) const
	Encode a given value into its approximation representation. More...

GUM_SCALAR	decode (Idx representation) const
	Convert approximation representation to value. More...

virtual void	setEpsilon (const GUM_SCALAR &e)
	Sets approximation factor. More...

virtual void	setLimits (const GUM_SCALAR &newLowLimit, const GUM_SCALAR &newHighLimit)
	Set bounds in a whole. More...

virtual void	setLowLimit (const GUM_SCALAR &newLowLimit)
	Sets lowest possible value. More...

const GUM_SCALAR &	lowLimit () const
	Gets lowest possible value. More...

virtual void	setHighLimit (const GUM_SCALAR &newHighLimit)
	Sets Highest possible value. More...

const GUM_SCALAR &	highLimit () const
	Gets Highest possible value. More...

Protected Attributes
GUM_SCALAR	_lowLimit
	Lowest value possible. More...

GUM_SCALAR	_highLimit
	Highest value possible. More...

GUM_SCALAR	_epsilon
	Approximation factor. More...

Idx	_nbInterval
	The number of interval. More...

Protected Member Functions
Idx	__encode (const GUM_SCALAR &value) const
	Concretely computes the approximate representation. More...

GUM_SCALAR	__decode (const GUM_SCALAR &representation) const
	Concretely computes the approximate value from representation. More...

void	_computeNbInterval ()
	Get the number of interval. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::LinearApproximationPolicy< GUM_SCALAR >

Class implementing linear approximation policy (meaning possible value are split out in interval).

Warning: Doxygen does not like spanning command on multiple line, so we could not configure it with the correct include directive. Use the following code snippet to include this file.
#include <agrum/core/approximations/linearApproximationPolicy.h>

Template Parameters

GUM_SCALAR The type used for computations.

Definition at line 55 of file linearApproximationPolicy.h.

Constructor & Destructor Documentation

◆ LinearApproximationPolicy() [1/2]

template<typename GUM_SCALAR >

gum::LinearApproximationPolicy< GUM_SCALAR >::LinearApproximationPolicy	(	GUM_SCALAR	low = `(GUM_SCALAR)0.0`,
		GUM_SCALAR	high = `(GUM_SCALAR)1.0`,
		GUM_SCALAR	eps = `(GUM_SCALAR)0.1`
	)

Default constructor.

Parameters

low	The lower limit.
high	The higher limit.
eps	The epsilon.

Exceptions

OutOfBound if out of bounds (low<high, eps>0)

Definition at line 38 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), and GUM_ERROR.

                                                       :
       ApproximationPolicy< GUM_SCALAR >(),
       _lowLimit(low), _highLimit(high), _epsilon(eps) {
     if (eps <= 0) { GUM_ERROR(OutOfBounds, "Epsilon must be >0"); }
 
     _computeNbInterval();
   }

Here is the call graph for this function:

◆ LinearApproximationPolicy() [2/2]

template<typename GUM_SCALAR >

gum::LinearApproximationPolicy< GUM_SCALAR >::LinearApproximationPolicy ( const LinearApproximationPolicy< GUM_SCALAR > * md )

Copy constructor.

Parameters

md	The gum::LinearApproximationPolicy to copy.

Definition at line 49 of file linearApproximationPolicy_tpl.h.

                                                         :
       ApproximationPolicy< GUM_SCALAR >(md),
       _epsilon(md->_epsilon), _nbInterval(md->_nbInterval) {}

Member Function Documentation

◆ __decode()

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::__decode ( const GUM_SCALAR & representation ) const

protected

Concretely computes the approximate value from representation.

Parameters

representation The approximate value to decode.

Returns: The decoded value.

Definition at line 373 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_epsilon, gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and gum::LinearApproximationPolicy< GUM_SCALAR >::_nbInterval.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::decode(), and gum::LinearApproximationPolicy< GUM_SCALAR >::fromExact().

                                              {
     if (representation == 0) return this->_lowLimit;
 
     if (representation == _nbInterval) return this->_highLimit;
 
     return (GUM_SCALAR)(((representation * this->_epsilon) - (this->_epsilon / 2))
                         + this->_lowLimit);
   }

Here is the caller graph for this function:

◆ __encode()

template<typename GUM_SCALAR >

INLINE Idx gum::LinearApproximationPolicy< GUM_SCALAR >::__encode ( const GUM_SCALAR & value ) const

protected

Concretely computes the approximate representation.

Warning: We accept value smaller or higher than limits : please

See also: gum::ApproximationPolicy::safeFromExact(const GUM_SCALAR&).

Parameters

value The value to encode.

Returns: The encoded value.

Definition at line 362 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_epsilon, gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and gum::LinearApproximationPolicy< GUM_SCALAR >::_nbInterval.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::encode().

                                     {
     if (value <= this->_lowLimit) return 0;
 
     if (value >= this->_highLimit) return _nbInterval;
 
     return 1 + Idx(((value - this->_lowLimit) / this->_epsilon));
   }

Here is the caller graph for this function:

◆ _computeNbInterval()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval ( )

protected

Get the number of interval.

Definition at line 385 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_epsilon, gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and gum::LinearApproximationPolicy< GUM_SCALAR >::_nbInterval.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::LinearApproximationPolicy(), gum::LinearApproximationPolicy< GUM_SCALAR >::setEpsilon(), gum::LinearApproximationPolicy< GUM_SCALAR >::setHighLimit(), gum::LinearApproximationPolicy< GUM_SCALAR >::setLimits(), and gum::LinearApproximationPolicy< GUM_SCALAR >::setLowLimit().

                                                                           {
     _nbInterval = 1 + Idx((this->_highLimit - this->_lowLimit) / this->_epsilon);
   }

Here is the caller graph for this function:

◆ combineAdd()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::combineAdd ( const ApproximationPolicy< GUM_SCALAR > * ap )

virtual

Combine using addition with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 64 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit(), and gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit().

                                                   {
     try {
       const LinearApproximationPolicy< GUM_SCALAR >* lap =
          dynamic_cast< const LinearApproximationPolicy< GUM_SCALAR >* >(ap);
 
       GUM_SCALAR newHighLimit = _lowLimit + lap->lowLimit();
       GUM_SCALAR newLowLimit = _lowLimit + lap->lowLimit();
 
       GUM_SCALAR newVal = _lowLimit + lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit + lap->lowLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit + lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
     } catch (const std::bad_cast&) {}
   }

Here is the call graph for this function:

◆ combineDiv()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::combineDiv ( const ApproximationPolicy< GUM_SCALAR > * ap )

virtual

Combine using division with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 154 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit(), and gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit().

                                                   {
     try {
       const LinearApproximationPolicy< GUM_SCALAR >* lap =
          dynamic_cast< const LinearApproximationPolicy< GUM_SCALAR >* >(ap);
 
       GUM_SCALAR newHighLimit = _lowLimit / lap->lowLimit();
       GUM_SCALAR newLowLimit = _lowLimit / lap->lowLimit();
 
       GUM_SCALAR newVal = _lowLimit / lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit / lap->lowLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit / lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
     } catch (const std::bad_cast&) {}
   }

Here is the call graph for this function:

◆ combineMax()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::combineMax ( const ApproximationPolicy< GUM_SCALAR > * ap )

virtual

Combine using max with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 184 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit(), and gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit().

                                                   {
     try {
       const LinearApproximationPolicy< GUM_SCALAR >* lap =
          dynamic_cast< const LinearApproximationPolicy< GUM_SCALAR >* >(ap);
 
       GUM_SCALAR newHighLimit =
          _lowLimit > lap->lowLimit() ? _lowLimit : lap->lowLimit();
       GUM_SCALAR newLowLimit =
          _lowLimit > lap->lowLimit() ? _lowLimit : lap->lowLimit();
 
       GUM_SCALAR newVal =
          _lowLimit > lap->highLimit() ? _lowLimit : lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit > lap->lowLimit() ? _highLimit : lap->lowLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit > lap->highLimit() ? _highLimit : lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
     } catch (const std::bad_cast&) {}
   }

Here is the call graph for this function:

◆ combineMin()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::combineMin ( const ApproximationPolicy< GUM_SCALAR > * ap )

virtual

Combine using min with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 217 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit(), and gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit().

                                                   {
     try {
       const LinearApproximationPolicy< GUM_SCALAR >* lap =
          dynamic_cast< const LinearApproximationPolicy< GUM_SCALAR >* >(ap);
 
       GUM_SCALAR newHighLimit =
          _lowLimit < lap->lowLimit() ? _lowLimit : lap->lowLimit();
       GUM_SCALAR newLowLimit =
          _lowLimit < lap->lowLimit() ? _lowLimit : lap->lowLimit();
 
       GUM_SCALAR newVal =
          _lowLimit < lap->highLimit() ? _lowLimit : lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit < lap->lowLimit() ? _highLimit : lap->lowLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit < lap->highLimit() ? _highLimit : lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
     } catch (const std::bad_cast&) {}
   }

Here is the call graph for this function:

◆ combineMult()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::combineMult ( const ApproximationPolicy< GUM_SCALAR > * ap )

virtual

Combine using multiplication with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 124 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit(), and gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit().

                                                   {
     try {
       const LinearApproximationPolicy< GUM_SCALAR >* lap =
          dynamic_cast< const LinearApproximationPolicy< GUM_SCALAR >* >(ap);
 
       GUM_SCALAR newHighLimit = _lowLimit * lap->lowLimit();
       GUM_SCALAR newLowLimit = _lowLimit * lap->lowLimit();
 
       GUM_SCALAR newVal = _lowLimit * lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit * lap->lowLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit * lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
     } catch (const std::bad_cast&) {}
   }

Here is the call graph for this function:

◆ combineSub()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::combineSub ( const ApproximationPolicy< GUM_SCALAR > * ap )

virtual

Combine using substraction with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 94 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit(), and gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit().

                                                   {
     try {
       const LinearApproximationPolicy< GUM_SCALAR >* lap =
          dynamic_cast< const LinearApproximationPolicy< GUM_SCALAR >* >(ap);
 
       GUM_SCALAR newHighLimit = _lowLimit - lap->lowLimit();
       GUM_SCALAR newLowLimit = _lowLimit - lap->lowLimit();
 
       GUM_SCALAR newVal = _lowLimit - lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit - lap->lowLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
 
       newVal = _highLimit - lap->highLimit();
 
       if (newHighLimit < newVal) newHighLimit = newVal;
 
       if (newLowLimit > newVal) newLowLimit = newVal;
     } catch (const std::bad_cast&) {}
   }

Here is the call graph for this function:

◆ decode()

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::decode ( Idx representation ) const

Convert approximation representation to value.

Parameters

representation The approximation representation to decode.

Returns: Returns the value decoded from its approximation reprensentation.

Definition at line 290 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::__decode(), gum::LinearApproximationPolicy< GUM_SCALAR >::_nbInterval, and GUM_ERROR.

                                                                                  {
     if (representation > _nbInterval) {
       GUM_ERROR(OutOfUpperBound,
                 "Interval Number asked is higher than total number of interval");
     }
 
     return __decode(GUM_SCALAR(representation));
   }

Here is the call graph for this function:

◆ encode()

template<typename GUM_SCALAR >

INLINE Idx gum::LinearApproximationPolicy< GUM_SCALAR >::encode ( const GUM_SCALAR & value ) const

Encode a given value into its approximation representation.

Parameters

value The to encode.

Returns: Returns the encoded value.

Exceptions

OutOfLowerBound	Raised if value is out of bounds.
OutOfUpperBound	Raised if value is out of bounds.

Definition at line 267 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::__encode(), gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and GUM_ERROR.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::fromExact().

                                     {
 // we keep the bounds checked in debug mode
 #ifdef GUM_DEBUG_MODE
     if (value > this->_highLimit) {
       GUM_TRACE(value << " not in (" << this->_lowLimit << "-" << this->_highLimit
                       << ")");
       GUM_ERROR(OutOfUpperBound, "Value asked is higher than High limit");
     }
 
     if (value < this->_lowLimit) {
       GUM_TRACE(value << " not in (" << this->_lowLimit << "-" << this->_highLimit
                       << ")");
       GUM_ERROR(OutOfLowerBound, "Value asked is lower than low limit");
     }
 
 #endif   // GUM_DEBUG_MODE
     return __encode(value);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fromExact()

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::fromExact ( const GUM_SCALAR & value ) const

virtual

Convert value to his approximation.

Parameters

value The converted value.

Returns: The value approximation representation.

Implements gum::ApproximationPolicy< GUM_SCALAR >.

Definition at line 57 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::__decode(), and gum::LinearApproximationPolicy< GUM_SCALAR >::encode().

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::safeFromExact().

                                     {
     return __decode(GUM_SCALAR(encode(value)));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ highLimit()

template<typename GUM_SCALAR >

INLINE const GUM_SCALAR & gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit ( ) const

Gets Highest possible value.

Returns: Returns the highest possible value.

Definition at line 356 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::combineAdd(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineDiv(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineMax(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineMin(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineMult(), and gum::LinearApproximationPolicy< GUM_SCALAR >::combineSub().

                                                                         {
     return _highLimit;
   }

Here is the caller graph for this function:

◆ lowLimit()

template<typename GUM_SCALAR >

INLINE const GUM_SCALAR & gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit ( ) const

Gets lowest possible value.

Returns: Returns the lowest possible value.

Definition at line 336 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::combineAdd(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineDiv(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineMax(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineMin(), gum::LinearApproximationPolicy< GUM_SCALAR >::combineMult(), and gum::LinearApproximationPolicy< GUM_SCALAR >::combineSub().

                                                                        {
     return _lowLimit;
   }

Here is the caller graph for this function:

◆ safeFromExact()

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::safeFromExact ( const GUM_SCALAR & value )

Convert value to his approximation.

This method is slower than fromExact since it verifies the bounds.

Exceptions

OutOfLowerBound	Raised if value is out of bounds.
OutOfUpperBound	Raised if value is out of bounds.

Definition at line 252 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::fromExact(), and GUM_ERROR.

                               {
     if (value > this->_highLimit) {
       GUM_ERROR(OutOfUpperBound, "Value asked is higher than high limit");
     }
 
     if (value < this->_lowLimit) {
       GUM_ERROR(OutOfLowerBound, "Value asked is lower than low limit");
     }
 
     return fromExact(value);
   }

Here is the call graph for this function:

◆ setEpsilon()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::setEpsilon ( const GUM_SCALAR & e )

virtual

Sets approximation factor.

Parameters

e	The new epsilon value.

Definition at line 302 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), and gum::LinearApproximationPolicy< GUM_SCALAR >::_epsilon.

                                                                             {
     _epsilon = e;
     _computeNbInterval();
   }

Here is the call graph for this function:

◆ setHighLimit()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::setHighLimit ( const GUM_SCALAR & newHighLimit )

virtual

Sets Highest possible value.

Parameters

newHighLimit New higher bound.

Exceptions

OutOfLowerBound Raised if out of bound.

Definition at line 342 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and GUM_ERROR.

                                      {
     if (newHighLimit < this->_lowLimit) {
       GUM_ERROR(OutOfLowerBound, "Value asked is lower than low limit");
     }
 
     _highLimit = newHighLimit;
 
     _computeNbInterval();
   }

Here is the call graph for this function:

◆ setLimits()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::setLimits	(	const GUM_SCALAR &	newLowLimit,
		const GUM_SCALAR &	newHighLimit
	)

virtual

Set bounds in a whole.

Parameters

newLowLimit	New lower bound.
newHighLimit	New higher bound.

Exceptions

OutOfBounds Raised if new bounds are not legit.

Definition at line 309 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and GUM_ERROR.

                                                                     {
     if (newLowLimit > newHighLimit) {
       GUM_ERROR(OutOfBounds, "Asked low value is higher than asked high value");
     }
 
     _lowLimit = newLowLimit;
     _highLimit = newHighLimit;
     _computeNbInterval();
   }

Here is the call graph for this function:

◆ setLowLimit()

template<typename GUM_SCALAR >

INLINE void gum::LinearApproximationPolicy< GUM_SCALAR >::setLowLimit ( const GUM_SCALAR & newLowLimit )

virtual

Sets lowest possible value.

Parameters

newLowLimit New lower bound.

Exceptions

OutOfUpperBound Raised if out of bound.

Definition at line 322 of file linearApproximationPolicy_tpl.h.

References gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit, gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit, and GUM_ERROR.

                                     {
     if (newLowLimit > this->_highLimit) {
       GUM_ERROR(OutOfUpperBound, "Value asked is higher than High limit");
     }
 
     _lowLimit = newLowLimit;
 
     _computeNbInterval();
   }

Here is the call graph for this function:

Member Data Documentation

◆ _epsilon

template<typename GUM_SCALAR>

GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::_epsilon

protected

Approximation factor.

Definition at line 211 of file linearApproximationPolicy.h.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::__decode(), gum::LinearApproximationPolicy< GUM_SCALAR >::__encode(), gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), and gum::LinearApproximationPolicy< GUM_SCALAR >::setEpsilon().

◆ _highLimit

template<typename GUM_SCALAR>

GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::_highLimit

protected

Highest value possible.

Definition at line 208 of file linearApproximationPolicy.h.

◆ _lowLimit

template<typename GUM_SCALAR>

GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::_lowLimit

protected

Lowest value possible.

Definition at line 205 of file linearApproximationPolicy.h.

◆ _nbInterval

template<typename GUM_SCALAR>

Idx gum::LinearApproximationPolicy< GUM_SCALAR >::_nbInterval

protected

The number of interval.

Definition at line 237 of file linearApproximationPolicy.h.

Referenced by gum::LinearApproximationPolicy< GUM_SCALAR >::__decode(), gum::LinearApproximationPolicy< GUM_SCALAR >::__encode(), gum::LinearApproximationPolicy< GUM_SCALAR >::_computeNbInterval(), and gum::LinearApproximationPolicy< GUM_SCALAR >::decode().

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

agrum/core/approximations/linearApproximationPolicy.h
agrum/core/approximations/linearApproximationPolicy_tpl.h

Public Member Functions

Protected Attributes

Protected Member Functions

Detailed Description

template<typename GUM_SCALAR> class gum::LinearApproximationPolicy< GUM_SCALAR >

Constructor & Destructor Documentation

◆ LinearApproximationPolicy() [1/2]

◆ LinearApproximationPolicy() [2/2]

Member Function Documentation

◆ __decode()

◆ __encode()

◆ _computeNbInterval()

◆ combineAdd()

◆ combineDiv()

◆ combineMax()

◆ combineMin()

◆ combineMult()

◆ combineSub()

◆ decode()

◆ encode()

◆ fromExact()

◆ highLimit()

◆ lowLimit()

◆ safeFromExact()

◆ setEpsilon()

◆ setHighLimit()

◆ setLimits()

◆ setLowLimit()

Member Data Documentation

◆ _epsilon

◆ _highLimit

◆ _lowLimit

◆ _nbInterval

template<typename GUM_SCALAR>
class gum::LinearApproximationPolicy< GUM_SCALAR >