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

#include <linearApproximationPolicy.h>

Inheritance diagram for gum::LinearApproximationPolicy< GUM_ELEMENT >:

Collaboration diagram for gum::LinearApproximationPolicy< GUM_ELEMENT >:

Public Member Functions
Constructors / Destructors
	LinearApproximationPolicy (GUM_ELEMENT low=(GUM_ELEMENT) 0.0, GUM_ELEMENT high=(GUM_ELEMENT) 1.0, GUM_ELEMENT eps=(GUM_ELEMENT) 0.1)
	Default constructor.
	LinearApproximationPolicy (const LinearApproximationPolicy< GUM_ELEMENT > *md)
	Copy constructor.
Accessors/Modifiers
GUM_ELEMENT	fromExact (const GUM_ELEMENT &value) const override
	Convert value to his approximation.
void	combineAdd (const ApproximationPolicy< GUM_ELEMENT > *ap) override
	Combine using addition with the given gum::ApproximationPolicy.
void	combineSub (const ApproximationPolicy< GUM_ELEMENT > *ap) override
	Combine using subtraction with the given gum::ApproximationPolicy.
void	combineMult (const ApproximationPolicy< GUM_ELEMENT > *ap) override
	Combine using multiplication with the given gum::ApproximationPolicy.
void	combineDiv (const ApproximationPolicy< GUM_ELEMENT > *ap) override
	Combine using division with the given gum::ApproximationPolicy.
void	combineMax (const ApproximationPolicy< GUM_ELEMENT > *ap) override
	Combine using max with the given gum::ApproximationPolicy.
void	combineMin (const ApproximationPolicy< GUM_ELEMENT > *ap) override
	Combine using min with the given gum::ApproximationPolicy.
GUM_ELEMENT	safeFromExact (const GUM_ELEMENT &value)
	Convert value to his approximation.
Idx	encode (const GUM_ELEMENT &value) const
	Encode a given value into its approximation representation.
GUM_ELEMENT	decode (Idx representation) const
	Convert approximation representation to value.
virtual void	setEpsilon (const GUM_ELEMENT &e)
	Sets approximation factor.
virtual void	setLimits (const GUM_ELEMENT &newLowLimit, const GUM_ELEMENT &newHighLimit)
	Set bounds in a whole.
virtual void	setLowLimit (const GUM_ELEMENT &newLowLimit)
	Sets lowest possible value.
const GUM_ELEMENT &	lowLimit () const
	Gets lowest possible value.
virtual void	setHighLimit (const GUM_ELEMENT &newHighLimit)
	Sets Highest possible value.
const GUM_ELEMENT &	highLimit () const
	Gets Highest possible value.
Accessors / Modifiers
virtual GUM_SCALAR	fromExact (const GUM_SCALAR &value) const=0
	Convert value to his approximation.
virtual void	combineAdd (const ApproximationPolicy< GUM_SCALAR > *ap)=0
	Combine using addition with the given gum::ApproximationPolicy.
virtual void	combineSub (const ApproximationPolicy< GUM_SCALAR > *ap)=0
	Combine using subtraction with the given gum::ApproximationPolicy.
virtual void	combineMult (const ApproximationPolicy< GUM_SCALAR > *ap)=0
	Combine using multiplication with the given gum::ApproximationPolicy.
virtual void	combineDiv (const ApproximationPolicy< GUM_SCALAR > *ap)=0
	Combine using division with the given gum::ApproximationPolicy.
virtual void	combineMax (const ApproximationPolicy< GUM_SCALAR > *ap)=0
	Combine using max with the given gum::ApproximationPolicy.
virtual void	combineMin (const ApproximationPolicy< GUM_SCALAR > *ap)=0
	Combine using min with the given gum::ApproximationPolicy.

Protected Member Functions
Idx	_encode_ (const GUM_ELEMENT &value) const
	Concretely computes the approximate representation.
GUM_ELEMENT	_decode_ (const GUM_ELEMENT &representation) const
	Concretely computes the approximate value from representation.
void	computeNbInterval_ ()
	Get the number of interval.

Protected Attributes
GUM_ELEMENT	lowLimit_
	Lowest value possible.
GUM_ELEMENT	highLimit_
	Highest value possible.
GUM_ELEMENT	epsilon_
	Approximation factor.
Idx	nbInterval_
	The number of interval.

Detailed Description

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

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/base/core/approximations/linearApproximationPolicy.h>

linearApproximationPolicy.h
Classes used to practice approximation on value.

Template Parameters

GUM_ELEMENT The type used for computations.

Definition at line 76 of file linearApproximationPolicy.h.

Constructor & Destructor Documentation

◆ LinearApproximationPolicy() [1/2]

template<typename GUM_ELEMENT>

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

Default constructor.

Parameters

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

Exceptions

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

Definition at line 59 of file linearApproximationPolicy_tpl.h.

                                                                                       :
      ApproximationPolicy< GUM_ELEMENT >(), lowLimit_(low), highLimit_(high), epsilon_(eps) {
    if (eps <= 0) { GUM_ERROR(OutOfBounds, "Epsilon must be >0") }
 
    computeNbInterval_();
  }

References gum::ApproximationPolicy< GUM_ELEMENT >::ApproximationPolicy(), computeNbInterval_(), epsilon_, GUM_ERROR, highLimit_, and lowLimit_.

Referenced by LinearApproximationPolicy(), combineAdd(), combineDiv(), combineMax(), combineMin(), combineMult(), and combineSub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LinearApproximationPolicy() [2/2]

template<typename GUM_ELEMENT>

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

Copy constructor.

Parameters

md	The gum::LinearApproximationPolicy to copy.

Definition at line 70 of file linearApproximationPolicy_tpl.h.

                                                          :
      ApproximationPolicy< GUM_ELEMENT >(md), epsilon_(md->epsilon_), nbInterval_(md->nbInterval_) {
  }

References gum::ApproximationPolicy< GUM_ELEMENT >::ApproximationPolicy(), LinearApproximationPolicy(), epsilon_, and nbInterval_.

Here is the call graph for this function:

Member Function Documentation

◆ _decode_()

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::_decode_ ( const GUM_ELEMENT & representation ) const

protected

Concretely computes the approximate value from representation.

Parameters

representation The approximate value to decode.

Returns: The decoded value.

Definition at line 400 of file linearApproximationPolicy_tpl.h.

                                                                                                {
    if (representation == 0) return this->lowLimit_;
 
    if (representation == nbInterval_) return this->highLimit_;
 
    return (GUM_ELEMENT)(((representation * this->epsilon_) - (this->epsilon_ / 2))
                         + this->lowLimit_);
  }

References epsilon_, highLimit_, lowLimit_, and nbInterval_.

Referenced by decode(), and fromExact().

Here is the caller graph for this function:

◆ _encode_()

template<typename GUM_ELEMENT>

Idx gum::LinearApproximationPolicy< GUM_ELEMENT >::_encode_ ( const GUM_ELEMENT & 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_ELEMENT&).

Parameters

value The value to encode.

Returns: The encoded value.

Definition at line 389 of file linearApproximationPolicy_tpl.h.

                                                                                       {
    if (value <= this->lowLimit_) return 0;
 
    if (value >= this->highLimit_) return nbInterval_;
 
    return 1 + Idx(((value - this->lowLimit_) / this->epsilon_));
  }

References epsilon_, highLimit_, lowLimit_, and nbInterval_.

Referenced by encode().

Here is the caller graph for this function:

◆ combineAdd() [1/2]

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

pure virtualinherited

Combine using addition with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

◆ combineAdd() [2/2]

template<typename GUM_ELEMENT>

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

override

Combine using addition with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Definition at line 83 of file linearApproximationPolicy_tpl.h.

                                                    {
    try {
      const LinearApproximationPolicy< GUM_ELEMENT >* lap
          = dynamic_cast< const LinearApproximationPolicy< GUM_ELEMENT >* >(ap);
 
      GUM_ELEMENT newHighLimit = lowLimit_ + lap->lowLimit();
      GUM_ELEMENT newLowLimit  = lowLimit_ + lap->lowLimit();
 
      GUM_ELEMENT 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;
 
      this->lowLimit_  = newLowLimit;
      this->highLimit_ = newHighLimit;
      computeNbInterval_();
    } catch (const std::bad_cast&) {}
  }

References LinearApproximationPolicy(), computeNbInterval_(), highLimit(), highLimit_, lowLimit(), and lowLimit_.

Here is the call graph for this function:

◆ combineDiv() [1/2]

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

pure virtualinherited

Combine using division with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

◆ combineDiv() [2/2]

template<typename GUM_ELEMENT>

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

override

Combine using division with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Definition at line 185 of file linearApproximationPolicy_tpl.h.

                                                    {
    try {
      const LinearApproximationPolicy< GUM_ELEMENT >* lap
          = dynamic_cast< const LinearApproximationPolicy< GUM_ELEMENT >* >(ap);
 
      GUM_ELEMENT newHighLimit = lowLimit_ / lap->lowLimit();
      GUM_ELEMENT newLowLimit  = lowLimit_ / lap->lowLimit();
 
      GUM_ELEMENT 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;
 
      this->lowLimit_  = newLowLimit;
      this->highLimit_ = newHighLimit;
      computeNbInterval_();
    } catch (const std::bad_cast&) {}
  }

References LinearApproximationPolicy(), computeNbInterval_(), highLimit(), highLimit_, lowLimit(), and lowLimit_.

Here is the call graph for this function:

◆ combineMax() [1/2]

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

pure virtualinherited

Combine using max with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

◆ combineMax() [2/2]

template<typename GUM_ELEMENT>

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

override

Combine using max with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Definition at line 219 of file linearApproximationPolicy_tpl.h.

                                                    {
    try {
      const LinearApproximationPolicy< GUM_ELEMENT >* lap
          = dynamic_cast< const LinearApproximationPolicy< GUM_ELEMENT >* >(ap);
 
      GUM_ELEMENT newHighLimit = lowLimit_ > lap->lowLimit() ? lowLimit_ : lap->lowLimit();
      GUM_ELEMENT newLowLimit  = lowLimit_ > lap->lowLimit() ? lowLimit_ : lap->lowLimit();
 
      GUM_ELEMENT 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;
 
      this->lowLimit_  = newLowLimit;
      this->highLimit_ = newHighLimit;
      computeNbInterval_();
    } catch (const std::bad_cast&) {}
  }

References LinearApproximationPolicy(), computeNbInterval_(), highLimit(), highLimit_, lowLimit(), and lowLimit_.

Here is the call graph for this function:

◆ combineMin() [1/2]

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

pure virtualinherited

Combine using min with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

◆ combineMin() [2/2]

template<typename GUM_ELEMENT>

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

override

Combine using min with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Definition at line 253 of file linearApproximationPolicy_tpl.h.

                                                    {
    try {
      const LinearApproximationPolicy< GUM_ELEMENT >* lap
          = dynamic_cast< const LinearApproximationPolicy< GUM_ELEMENT >* >(ap);
 
      GUM_ELEMENT newHighLimit = lowLimit_ < lap->lowLimit() ? lowLimit_ : lap->lowLimit();
      GUM_ELEMENT newLowLimit  = lowLimit_ < lap->lowLimit() ? lowLimit_ : lap->lowLimit();
 
      GUM_ELEMENT 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;
 
      this->lowLimit_  = newLowLimit;
      this->highLimit_ = newHighLimit;
      computeNbInterval_();
    } catch (const std::bad_cast&) {}
  }

References LinearApproximationPolicy(), computeNbInterval_(), highLimit(), highLimit_, lowLimit(), and lowLimit_.

Here is the call graph for this function:

◆ combineMult() [1/2]

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

pure virtualinherited

Combine using multiplication with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

◆ combineMult() [2/2]

template<typename GUM_ELEMENT>

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

override

Combine using multiplication with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Definition at line 151 of file linearApproximationPolicy_tpl.h.

                                                    {
    try {
      const LinearApproximationPolicy< GUM_ELEMENT >* lap
          = dynamic_cast< const LinearApproximationPolicy< GUM_ELEMENT >* >(ap);
 
      GUM_ELEMENT newHighLimit = lowLimit_ * lap->lowLimit();
      GUM_ELEMENT newLowLimit  = lowLimit_ * lap->lowLimit();
 
      GUM_ELEMENT 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;
 
      this->lowLimit_  = newLowLimit;
      this->highLimit_ = newHighLimit;
      computeNbInterval_();
    } catch (const std::bad_cast&) {}
  }

References LinearApproximationPolicy(), computeNbInterval_(), highLimit(), highLimit_, lowLimit(), and lowLimit_.

Here is the call graph for this function:

◆ combineSub() [1/2]

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

pure virtualinherited

Combine using subtraction with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

◆ combineSub() [2/2]

template<typename GUM_ELEMENT>

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

override

Combine using subtraction with the given gum::ApproximationPolicy.

Parameters

ap	The policy to combine with.

Definition at line 117 of file linearApproximationPolicy_tpl.h.

                                                    {
    try {
      const LinearApproximationPolicy< GUM_ELEMENT >* lap
          = dynamic_cast< const LinearApproximationPolicy< GUM_ELEMENT >* >(ap);
 
      GUM_ELEMENT newHighLimit = lowLimit_ - lap->lowLimit();
      GUM_ELEMENT newLowLimit  = lowLimit_ - lap->lowLimit();
 
      GUM_ELEMENT 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;
 
      this->lowLimit_  = newLowLimit;
      this->highLimit_ = newHighLimit;
      computeNbInterval_();
    } catch (const std::bad_cast&) {}
  }

References LinearApproximationPolicy(), computeNbInterval_(), highLimit(), highLimit_, lowLimit(), and lowLimit_.

Here is the call graph for this function:

◆ computeNbInterval_()

template<typename GUM_ELEMENT>

void gum::LinearApproximationPolicy< GUM_ELEMENT >::computeNbInterval_ ( )

protected

Get the number of interval.

Definition at line 411 of file linearApproximationPolicy_tpl.h.

                                                                    {
    nbInterval_ = 1 + Idx((this->highLimit_ - this->lowLimit_) / this->epsilon_);
  }

References epsilon_, highLimit_, lowLimit_, and nbInterval_.

Referenced by LinearApproximationPolicy(), combineAdd(), combineDiv(), combineMax(), combineMin(), combineMult(), combineSub(), setEpsilon(), setHighLimit(), setLimits(), and setLowLimit().

Here is the caller graph for this function:

◆ decode()

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::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 322 of file linearApproximationPolicy_tpl.h.

                                                                                       {
    if (representation > nbInterval_) {
      GUM_ERROR(OutOfBounds, "Interval Number asked is higher than total number of interval")
    }
 
    return _decode_(GUM_ELEMENT(representation));
  }

References _decode_(), GUM_ERROR, and nbInterval_.

Here is the call graph for this function:

◆ encode()

template<typename GUM_ELEMENT>

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

Encode a given value into its approximation representation.

Parameters

value The to encode.

Returns: Returns the encoded value.

Exceptions

OutOfBounds	Raised if value is out of bounds.
OutOfBounds	Raised if value is out of bounds.

Definition at line 301 of file linearApproximationPolicy_tpl.h.

                                                                                     {
// we keep the bounds checked in debug mode
#ifdef GUM_DEBUG_MODE
    if (value > this->highLimit_) {
      GUM_ERROR(OutOfBounds,
                "Value asked is higher than High limit :  not in (" << this->lowLimit_ << "-"
                                                                    << this->highLimit_ << ")")
    }
 
    if (value < this->lowLimit_) {
      GUM_ERROR(OutOfBounds,
                "Value asked is lower than low limit :  not in (" << this->lowLimit_ << "-"
                                                                  << this->highLimit_ << ")")
    }
 
#endif   // GUM_DEBUG_MODE
    return _encode_(value);
  }

References _encode_(), GUM_ERROR, highLimit_, and lowLimit_.

Referenced by fromExact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fromExact() [1/2]

virtual GUM_SCALAR gum::ApproximationPolicy< GUM_SCALAR >::fromExact ( const GUM_SCALAR & value ) const

pure virtualinherited

Convert value to his approximation.

This method, at least in release mode, should not verify the limits

Parameters

value The converted value.

Returns: The value approximation representation.

◆ fromExact() [2/2]

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::fromExact ( const GUM_ELEMENT & value ) const

override

Convert value to his approximation.

Parameters

value The converted value.

Returns: The value approximation representation.

Definition at line 77 of file linearApproximationPolicy_tpl.h.

                                                                                                {
    return _decode_(GUM_ELEMENT(encode(value)));
  }

References _decode_(), and encode().

Referenced by safeFromExact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ highLimit()

template<typename GUM_ELEMENT>

const GUM_ELEMENT & gum::LinearApproximationPolicy< GUM_ELEMENT >::highLimit ( ) const

Gets Highest possible value.

Returns: Returns the highest possible value.

Definition at line 383 of file linearApproximationPolicy_tpl.h.

                                                                               {
    return highLimit_;
  }

References highLimit_.

Referenced by combineAdd(), combineDiv(), combineMax(), combineMin(), combineMult(), and combineSub().

Here is the caller graph for this function:

◆ lowLimit()

template<typename GUM_ELEMENT>

const GUM_ELEMENT & gum::LinearApproximationPolicy< GUM_ELEMENT >::lowLimit ( ) const

Gets lowest possible value.

Returns: Returns the lowest possible value.

Definition at line 365 of file linearApproximationPolicy_tpl.h.

                                                                              {
    return lowLimit_;
  }

References lowLimit_.

Referenced by combineAdd(), combineDiv(), combineMax(), combineMin(), combineMult(), and combineSub().

Here is the caller graph for this function:

◆ safeFromExact()

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::safeFromExact ( const GUM_ELEMENT & value )

Convert value to his approximation.

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

Exceptions

OutOfBounds	Raised if value is out of bounds.
OutOfBounds	Raised if value is out of bounds.

Definition at line 289 of file linearApproximationPolicy_tpl.h.

                                                                                              {
    if (value > this->highLimit_) {
      GUM_ERROR(OutOfBounds, "Value asked is higher than high limit")
    }
 
    if (value < this->lowLimit_) { GUM_ERROR(OutOfBounds, "Value asked is lower than low limit") }
 
    return fromExact(value);
  }

References fromExact(), GUM_ERROR, highLimit_, and lowLimit_.

Here is the call graph for this function:

◆ setEpsilon()

template<typename GUM_ELEMENT>

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

virtual

Sets approximation factor.

Parameters

e	The new epsilon value.

Definition at line 332 of file linearApproximationPolicy_tpl.h.

                                                                                {
    if (e <= 0) { GUM_ERROR(OutOfBounds, "Epsilon must be >0") }
    epsilon_ = e;
    computeNbInterval_();
  }

References computeNbInterval_(), epsilon_, and GUM_ERROR.

Here is the call graph for this function:

◆ setHighLimit()

template<typename GUM_ELEMENT>

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

virtual

Sets Highest possible value.

Parameters

newHighLimit New higher bound.

Exceptions

OutOfBounds Raised if out of bound.

Definition at line 371 of file linearApproximationPolicy_tpl.h.

                                                                                             {
    if (newHighLimit < this->lowLimit_) {
      GUM_ERROR(OutOfBounds, "Value asked is lower than low limit")
    }
 
    highLimit_ = newHighLimit;
 
    computeNbInterval_();
  }

References computeNbInterval_(), GUM_ERROR, highLimit_, and lowLimit_.

Here is the call graph for this function:

◆ setLimits()

template<typename GUM_ELEMENT>

void gum::LinearApproximationPolicy< GUM_ELEMENT >::setLimits	(	const GUM_ELEMENT &	newLowLimit,
		const GUM_ELEMENT &	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 340 of file linearApproximationPolicy_tpl.h.

                                                                                            {
    if (newLowLimit > newHighLimit) {
      GUM_ERROR(OutOfBounds, "Asked low value is higher than asked high value")
    }
 
    lowLimit_  = newLowLimit;
    highLimit_ = newHighLimit;
    computeNbInterval_();
  }

References computeNbInterval_(), GUM_ERROR, highLimit_, and lowLimit_.

Here is the call graph for this function:

◆ setLowLimit()

template<typename GUM_ELEMENT>

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

virtual

Sets lowest possible value.

Parameters

newLowLimit New lower bound.

Exceptions

OutOfBounds Raised if out of bound.

Definition at line 353 of file linearApproximationPolicy_tpl.h.

                                                                                           {
    if (newLowLimit > this->highLimit_) {
      GUM_ERROR(OutOfBounds, "Value asked is higher than High limit")
    }
 
    lowLimit_ = newLowLimit;
 
    computeNbInterval_();
  }

References computeNbInterval_(), GUM_ERROR, highLimit_, and lowLimit_.

Here is the call graph for this function:

Member Data Documentation

◆ epsilon_

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::epsilon_

protected

Approximation factor.

Definition at line 230 of file linearApproximationPolicy.h.

Referenced by LinearApproximationPolicy(), LinearApproximationPolicy(), _decode_(), _encode_(), computeNbInterval_(), and setEpsilon().

◆ highLimit_

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::highLimit_

protected

Highest value possible.

Definition at line 227 of file linearApproximationPolicy.h.

Referenced by LinearApproximationPolicy(), _decode_(), _encode_(), combineAdd(), combineDiv(), combineMax(), combineMin(), combineMult(), combineSub(), computeNbInterval_(), encode(), highLimit(), safeFromExact(), setHighLimit(), setLimits(), and setLowLimit().

◆ lowLimit_

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::LinearApproximationPolicy< GUM_ELEMENT >::lowLimit_

protected

Lowest value possible.

Definition at line 224 of file linearApproximationPolicy.h.

Referenced by LinearApproximationPolicy(), _decode_(), _encode_(), combineAdd(), combineDiv(), combineMax(), combineMin(), combineMult(), combineSub(), computeNbInterval_(), encode(), lowLimit(), safeFromExact(), setHighLimit(), setLimits(), and setLowLimit().

◆ nbInterval_

template<typename GUM_ELEMENT>

Idx gum::LinearApproximationPolicy< GUM_ELEMENT >::nbInterval_

protected

The number of interval.

Definition at line 256 of file linearApproximationPolicy.h.

Referenced by LinearApproximationPolicy(), _decode_(), _encode_(), computeNbInterval_(), and decode().

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LinearApproximationPolicy() [1/2]

◆ LinearApproximationPolicy() [2/2]

Member Function Documentation

◆ _decode_()

◆ _encode_()

◆ combineAdd() [1/2]

◆ combineAdd() [2/2]

◆ combineDiv() [1/2]

◆ combineDiv() [2/2]

◆ combineMax() [1/2]

◆ combineMax() [2/2]

◆ combineMin() [1/2]

◆ combineMin() [2/2]

◆ combineMult() [1/2]

◆ combineMult() [2/2]

◆ combineSub() [1/2]

◆ combineSub() [2/2]

◆ computeNbInterval_()

◆ decode()

◆ encode()

◆ fromExact() [1/2]

◆ fromExact() [2/2]

◆ highLimit()

◆ lowLimit()

◆ safeFromExact()

◆ setEpsilon()

◆ setHighLimit()

◆ setLimits()

◆ setLowLimit()

Member Data Documentation

◆ epsilon_

◆ highLimit_

◆ lowLimit_

◆ nbInterval_