Linear in two dimensions and constant in the others. More...

#include <PrimitiveFunctions.h>

Inheritance diagram for inet::math::BilinearFunction< R, D >:

Public Member Functions
	BilinearFunction (const typename D::P &lowerLower, const typename D::P &lowerUpper, const typename D::P &upperLower, const typename D::P &upperUpper, const R rLowerLower, const R rLowerUpper, const R rUpperLower, const R rUpperUpper, const int dimension1, const int dimension2)

virtual const D::P &	getLowerLower () const

virtual const D::P &	getLowerUpper () const

virtual const D::P &	getUpperLower () const

virtual const D::P &	getUpperUpper () const

virtual R	getRLowerLower () const

virtual R	getRLowerUpper () const

virtual R	getRUpperLower () const

virtual R	getRUpperUpper () const

virtual int	getDimension1 () const

virtual int	getDimension2 () const

virtual Interval< R >	getRange () const override
	Returns the valid range of the function as an interval. More...

virtual R	getValue (const typename D::P &p) const override
	Returns the value of the function at the given point. More...

virtual void	partition (const typename D::I &i, const std::function< void(const typename D::I &, const IFunction< R, D > *)> callback) const override
	Subdivides the provided domain and calls back f with the subdomains and the corresponding potentially simpler domain limited functions. More...

virtual bool	isFinite (const typename D::I &i) const override
	Returns true if the function value is finite in the given domain. More...

virtual bool	isNonZero (const typename D::I &i) const override
	Returns true if the function value is non-zero in the given domain. More...

virtual R	getMin (const typename D::I &i) const override
	Returns the minimum value for the given domain. More...

virtual R	getMax (const typename D::I &i) const override
	Returns the maximum value for the given domain. More...

virtual R	getMean (const typename D::I &i) const override
	Returns the mean value for the given domain. More...

virtual void	printPartition (std::ostream &os, const typename D::I &i, int level=0) const override
	Prints a single partition of this function in a human readable form to the provided stream for the given domain. More...

Public Member Functions inherited from inet::math::FunctionBase< R, D >
virtual Interval< R >	getRange (const typename D::I &i) const override
	Returns the valid range of the function as an interval for the given domain. More...

virtual D::I	getDomain () const override
	Returns the valid domain of the function as an interval. More...

virtual bool	isFinite () const override
	Returns true if the function value is finite in the whole domain. More...

virtual bool	isNonZero () const override
	Returns true if the function value is non-zero in the whole domain. More...

virtual R	getMin () const override
	Returns the minimum value for the whole domain. More...

virtual R	getMax () const override
	Returns the maximum value for the whole domain. More...

virtual R	getMean () const override
	Returns the mean value for the whole domain. More...

virtual R	getIntegral () const override
	Returns the integral value for the whole domain. More...

virtual R	getIntegral (const typename D::I &i) const override
	Returns the integral value for the given domain. More...

virtual const Ptr< const IFunction< R, D > >	add (const Ptr< const IFunction< R, D >> &o) const override
	Adds the provided function to this function. More...

virtual const Ptr< const IFunction< R, D > >	subtract (const Ptr< const IFunction< R, D >> &o) const override
	Substracts the provided function from this function. More...

virtual const Ptr< const IFunction< R, D > >	multiply (const Ptr< const IFunction< double, D >> &o) const override
	Multiplies the provided function with this function. More...

virtual const Ptr< const IFunction< double, D > >	divide (const Ptr< const IFunction< R, D >> &o) const override
	Divides this function with the provided function. More...

virtual std::ostream &	printOn (std::ostream &os) const override

virtual void	print (std::ostream &os, int level=0) const override
	Prints this function in human readable form to the provided stream for the whole domain. More...

virtual void	print (std::ostream &os, const typename D::I &i, int level=0) const override
	Prints this function in a human readable form to the provided stream for the given domain. More...

virtual void	printPartitioning (std::ostream &os, const typename D::I &i, int level) const override
	Prints the partitioning of this function in a human readable form to the provided stream for the given domain. More...

virtual void	printStructure (std::ostream &os, int level=0) const override
	Prints the internal data structure of this function in a human readable form to the provided stream. More...

Public Member Functions inherited from inet::math::IFunction< R, D >
virtual	~IFunction ()

Protected Member Functions
D::I	getOtherInterval (const typename D::I &i) const

Protected Attributes
const D::P	lowerLower

const D::P	lowerUpper

const D::P	upperLower

const D::P	upperUpper

const R	rLowerLower

const R	rLowerUpper

const R	rUpperLower

const R	rUpperUpper

const int	dimension1

const int	dimension2

Detailed Description

template<typename R, typename D>
class inet::math::BilinearFunction< R, D >

Linear in two dimensions and constant in the others.

Constructor & Destructor Documentation

◆ BilinearFunction()

template<typename R , typename D >

inet::math::BilinearFunction< R, D >::BilinearFunction	(	const typename D::P &	lowerLower,
		const typename D::P &	lowerUpper,
		const typename D::P &	upperLower,
		const typename D::P &	upperUpper,
		const R	rLowerLower,
		const R	rLowerUpper,
		const R	rUpperLower,
		const R	rUpperUpper,
		const int	dimension1,
		const int	dimension2
	)

inline

                                                                                                                                                      :
         lowerLower(lowerLower), lowerUpper(lowerUpper), upperLower(upperLower), upperUpper(upperUpper),
         rLowerLower(rLowerLower), rLowerUpper(rLowerUpper), rUpperLower(rUpperLower), rUpperUpper(rUpperUpper),
         dimension1(dimension1), dimension2(dimension2) {}

Member Function Documentation

◆ getDimension1()

template<typename R , typename D >

virtual int inet::math::BilinearFunction< R, D >::getDimension1 ( ) const

inlinevirtual

166 { return dimension1; }

◆ getDimension2()

template<typename R , typename D >

virtual int inet::math::BilinearFunction< R, D >::getDimension2 ( ) const

inlinevirtual

167 { return dimension2; }

◆ getLowerLower()

template<typename R , typename D >

virtual const D::P& inet::math::BilinearFunction< R, D >::getLowerLower ( ) const

inlinevirtual

158 { return lowerLower; }

◆ getLowerUpper()

template<typename R , typename D >

virtual const D::P& inet::math::BilinearFunction< R, D >::getLowerUpper ( ) const

inlinevirtual

159 { return lowerUpper; }

◆ getMax()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getMax ( const typename D::I & i ) const

inlineoverridevirtual

Returns the maximum value for the given domain.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                           {
         auto j = getOtherInterval(i);
         return math::maxnan(math::maxnan(getValue(i.getLower()), getValue(j.getLower())), math::maxnan(getValue(j.getUpper()), getValue(i.getUpper())));
     }

◆ getMean()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getMean ( const typename D::I & i ) const

inlineoverridevirtual

Returns the mean value for the given domain.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                            {
         return getValue((i.getLower() + i.getUpper()) / 2);
     }

◆ getMin()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getMin ( const typename D::I & i ) const

inlineoverridevirtual

Returns the minimum value for the given domain.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                           {
         auto j = getOtherInterval(i);
         return math::minnan(math::minnan(getValue(i.getLower()), getValue(j.getLower())), math::minnan(getValue(j.getUpper()), getValue(i.getUpper())));
     }

◆ getOtherInterval()

template<typename R , typename D >

D::I inet::math::BilinearFunction< R, D >::getOtherInterval ( const typename D::I & i ) const

inlineprotected

                                                              {
         const typename D::P& lower = i.getLower();
         const typename D::P& upper = i.getUpper();
         typename D::P lowerUpper = D::P::getZero();
         typename D::P upperLower = D::P::getZero();
         lowerUpper.set(dimension1, lower.get(dimension1));
         lowerUpper.set(dimension2, upper.get(dimension2));
         upperLower.set(dimension1, upper.get(dimension1));
         upperLower.set(dimension2, lower.get(dimension2));
         return typename D::I(lowerUpper, upperLower, i.getLowerClosed(), i.getUpperClosed(), i.getFixed());
     }

◆ getRange()

template<typename R , typename D >

virtual Interval<R> inet::math::BilinearFunction< R, D >::getRange ( ) const

inlineoverridevirtual

Returns the valid range of the function as an interval.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                   {
         return Interval<R>(math::minnan(math::minnan(rLowerLower, rLowerUpper), math::minnan(rUpperLower, rUpperUpper)),
                 math::maxnan(math::maxnan(rLowerLower, rLowerUpper), math::maxnan(rUpperLower, rUpperUpper)),
                 0b1, 0b1, 0b0);
     }

◆ getRLowerLower()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getRLowerLower ( ) const

inlinevirtual

162 { return rLowerLower; }

Referenced by inet::math::simplifyAndCall().

◆ getRLowerUpper()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getRLowerUpper ( ) const

inlinevirtual

163 { return rLowerUpper; }

Referenced by inet::math::simplifyAndCall().

◆ getRUpperLower()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getRUpperLower ( ) const

inlinevirtual

164 { return rUpperLower; }

Referenced by inet::math::simplifyAndCall().

◆ getRUpperUpper()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getRUpperUpper ( ) const

inlinevirtual

165 { return rUpperUpper; }

Referenced by inet::math::simplifyAndCall().

◆ getUpperLower()

template<typename R , typename D >

virtual const D::P& inet::math::BilinearFunction< R, D >::getUpperLower ( ) const

inlinevirtual

160 { return upperLower; }

◆ getUpperUpper()

template<typename R , typename D >

virtual const D::P& inet::math::BilinearFunction< R, D >::getUpperUpper ( ) const

inlinevirtual

161 { return upperUpper; }

◆ getValue()

template<typename R , typename D >

virtual R inet::math::BilinearFunction< R, D >::getValue ( const typename D::P & p ) const

inlineoverridevirtual

Returns the value of the function at the given point.

The returned value falls into the range of the function. The provided point must fall into the domain of the function.

Implements inet::math::IFunction< R, D >.

                                                             {
         double lowerAlpha = (p - lowerLower).get(dimension1) / (upperLower - lowerLower).get(dimension1);
         R rLower = rLowerLower * (1 - lowerAlpha) + rUpperLower * lowerAlpha;
         const typename D::P lower = lowerLower * (1 - lowerAlpha) + upperLower * lowerAlpha;
  
         double upperAlpha = (p - lowerUpper).get(dimension1) / (upperUpper - lowerUpper).get(dimension1);
         R rUpper = rLowerUpper * (1 - upperAlpha) + rUpperUpper * upperAlpha;
         const typename D::P upper = lowerUpper * (1 - upperAlpha) + upperUpper * upperAlpha;
  
         double alpha = (p - lower).get(dimension2) / (upper - lower).get(dimension2);
         return rLower * (1 - alpha) + rUpper * alpha;
     }

◆ isFinite()

template<typename R , typename D >

virtual bool inet::math::BilinearFunction< R, D >::isFinite ( const typename D::I & i ) const

inlineoverridevirtual

Returns true if the function value is finite in the given domain.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                                {
         return std::isfinite(toDouble(rLowerLower)) && std::isfinite(toDouble(rLowerUpper)) && std::isfinite(toDouble(rUpperLower)) && std::isfinite(toDouble(rUpperUpper));
     }

◆ isNonZero()

template<typename R , typename D >

virtual bool inet::math::BilinearFunction< R, D >::isNonZero ( const typename D::I & i ) const

inlineoverridevirtual

Returns true if the function value is non-zero in the given domain.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                                 {
         return rLowerLower != R(0) || rLowerUpper != R(0) || rUpperLower != R(0) || rUpperUpper != R(0);
     }

◆ partition()

template<typename R , typename D >

virtual void inet::math::BilinearFunction< R, D >::partition	(	const typename D::I &	i,
		const std::function< void(const typename D::I &, const IFunction< R, D > *)>	f
	)		const

inlineoverridevirtual

Subdivides the provided domain and calls back f with the subdomains and the corresponding potentially simpler domain limited functions.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                                                                                                                {
         callback(i, this);
     }

◆ printPartition()

template<typename R , typename D >

virtual void inet::math::BilinearFunction< R, D >::printPartition	(	std::ostream &	os,
		const typename D::I &	i,
		int	level = `0`
	)		const

inlineoverridevirtual

Prints a single partition of this function in a human readable form to the provided stream for the given domain.

Reimplemented from inet::math::FunctionBase< R, D >.

                                                                                                     {
         os << "bilinear in dims. " << dimension1 << ", " << dimension2 << " over " << i << "\n"
            << std::string(level + 2, ' ') << "→ " << getValue(i.getLower()) << " … " << getValue(i.getUpper()) << std::endl;
     }

Member Data Documentation

◆ dimension1

template<typename R , typename D >

const int inet::math::BilinearFunction< R, D >::dimension1

protected

◆ dimension2

template<typename R , typename D >

const int inet::math::BilinearFunction< R, D >::dimension2

protected

◆ lowerLower

template<typename R , typename D >

const D::P inet::math::BilinearFunction< R, D >::lowerLower

protected

◆ lowerUpper

template<typename R , typename D >

const D::P inet::math::BilinearFunction< R, D >::lowerUpper

protected

◆ rLowerLower

template<typename R , typename D >

const R inet::math::BilinearFunction< R, D >::rLowerLower

protected

◆ rLowerUpper

template<typename R , typename D >

const R inet::math::BilinearFunction< R, D >::rLowerUpper

protected

◆ rUpperLower

template<typename R , typename D >

const R inet::math::BilinearFunction< R, D >::rUpperLower

protected

◆ rUpperUpper

template<typename R , typename D >

const R inet::math::BilinearFunction< R, D >::rUpperUpper

protected

◆ upperLower

template<typename R , typename D >

const D::P inet::math::BilinearFunction< R, D >::upperLower

protected

◆ upperUpper

template<typename R , typename D >

const D::P inet::math::BilinearFunction< R, D >::upperUpper

protected

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

PrimitiveFunctions.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<typename R, typename D> class inet::math::BilinearFunction< R, D >

Constructor & Destructor Documentation

◆ BilinearFunction()

Member Function Documentation

◆ getDimension1()

◆ getDimension2()

◆ getLowerLower()

◆ getLowerUpper()

◆ getMax()

◆ getMean()

◆ getMin()

◆ getOtherInterval()

◆ getRange()

◆ getRLowerLower()

◆ getRLowerUpper()

◆ getRUpperLower()

◆ getRUpperUpper()

◆ getUpperLower()

◆ getUpperUpper()

◆ getValue()

◆ isFinite()

◆ isNonZero()

◆ partition()

◆ printPartition()

Member Data Documentation

◆ dimension1

◆ dimension2

◆ lowerLower

◆ lowerUpper

◆ rLowerLower

◆ rLowerUpper

◆ rUpperLower

◆ rUpperUpper

◆ upperLower

◆ upperUpper

template<typename R, typename D>
class inet::math::BilinearFunction< R, D >