gum::LinearApproximationPolicy< GUM_SCALAR > Class Template Reference

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

Template Parameters

GUM_SCALAR

The type used for computations.

Definition at line 54 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 37 of file linearApproximationPolicy_tpl.h.

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

    computeNbInterval_();
  }

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.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

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 360 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                             {
    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 call 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 349 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
    if (value <= this->lowLimit_) return 0;

    if (value >= this->highLimit_) return nbInterval_;

    return 1 + Idx(((value - this->lowLimit_) / this->epsilon_));
  }

Here is the call 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::Set< Key, Alloc >::emplace().

                                                  {
    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::Set< Key, Alloc >::emplace().

                                                  {
    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::Set< Key, Alloc >::emplace().

                                                  {
    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 214 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                  {
    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::Set< Key, Alloc >::emplace().

                                                  {
    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::Set< Key, Alloc >::emplace().

                                                  {
    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:

computeNbInterval_()

template<typename GUM_SCALAR >

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

protected

Get the number of interval.

Definition at line 371 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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 282 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
    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 261 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

    if (value < this->lowLimit_) {
      GUM_ERROR(OutOfLowerBound,
                "Value asked is lower than low limit :  not in (" << this->lowLimit_ << "-"
                                                                  << this->highLimit_ << ")")
    }

#endif   // GUM_DEBUG_MODE
    return _encode_(value);
  }

Here is the call 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 58 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 343 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
    return highLimit_;
  }

Here is the call 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 324 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                   {
    return lowLimit_;
  }

Here is the call 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 247 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                   {
    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 292 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                     {
    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 331 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                         {
    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 299 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                 {
    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 312 of file linearApproximationPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                {
    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 208 of file linearApproximationPolicy.h.

highLimit_

template<typename GUM_SCALAR >

GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::highLimit_

protected

Highest value possible.

Definition at line 205 of file linearApproximationPolicy.h.

lowLimit_

template<typename GUM_SCALAR >

GUM_SCALAR gum::LinearApproximationPolicy< GUM_SCALAR >::lowLimit_

protected

Lowest value possible.

Definition at line 202 of file linearApproximationPolicy.h.

nbInterval_

template<typename GUM_SCALAR >

Idx gum::LinearApproximationPolicy< GUM_SCALAR >::nbInterval_

protected

The number of interval.

Definition at line 234 of file linearApproximationPolicy.h.

---

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

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