inet::math Namespace Reference

Support functions for mathematical operations. More...

Namespaces
	internal

Classes
class	AddedFunction
class	ApproximatedFunction
	Approximates the values and partitioning of a multidimensional function along one of the dimensions. More...
class	AverageInterpolator
class	BilinearFunction
	Linear in two dimensions and constant in the others. More...
class	Boxcar1DFunction
	Some constant value r between lower and upper and zero otherwise. More...
class	Boxcar2DFunction
	Some constant value r between (lowerX, lowerY) and (upperX, upperY) and zero otherwise. More...
class	CloserInterpolator
class	Combined2DFunction
	Combines 2 one-dimensional functions into a two-dimensional function. More...
class	ConstantFunction
class	ConstantInterpolatorBase
class	DividedFunction
class	Domain
	This class represents the domain of a mathematical function. More...
class	DomainLimitedFunction
	Limits the domain of a multidimensional function. More...
class	DomainModulated2DFunction
	Modulates the domain of a two-dimensional function with the values of a one-dimensional function. More...
class	DomainShiftedFunction
	Shifts the domain of a multidimensional function. More...
class	EitherInterpolator
	Interpolation that can only be used if y1 == y2. More...
class	Extruded2DFunction
	Extrudes a one-dimensional function into a two-dimensional function. More...
class	FunctionBase
	Useful base class for most IFunction implementations with some default behavior. More...
class	FunctionChecker
	Verifies that partitioning on a domain is correct in the sense that the original function and the function over the partition return the same values at the corners and center of the subdomain. More...
class	GaussFunction
	The one-dimensional Gauss function. More...
class	IFunction
	This interface represents a mathematical function from domain D to range R. More...
class	IInterpolator
	This interface represents interpolation of values (y) between two points x1 and x2. More...
class	IntegratedFunction
class	IntegratedFunction< R, Domain< X, Y >, DIMS, RI, Domain< X > >
	Integrates a multidimensional function in one of the dimensions producing a function with one less number of dimensions. More...
class	Interpolated1DFunction
	One-dimensional interpolated (e.g. More...
class	InterpolatorBase
class	Interval
	N-dimensional interval (cuboid), given by its two opposite corners. More...
class	LeftCurryingFunction
	Fixes the parameters of a function from the left. More...
class	LeftInterpolator
class	LineardbInterpolator
class	LinearInterpolator
class	MaximumInterpolator
class	MemoizedFunction
	Truncates the values of a multidimensional function outside the given domain to 0. More...
class	MinimumInterpolator
class	MultipliedFunction
class	PeriodicallyInterpolated1DFunction
	One-dimensional interpolated (e.g. More...
class	PeriodicallyInterpolated2DFunction
class	Point
	N-dimensional point. More...
class	Rasterized2DFunction
	Rasterizes a function into a grid where each cell is a constant value with the mean of the original function. More...
class	RightCurryingFunction
	Fixes the parameters of a function from the right. More...
class	RightInterpolator
class	SawtoothFunction
	One-dimensional periodic function with a sawtooth shape. More...
class	SubtractedFunction
class	SummedFunction
class	UnilinearFunction
	Linear in one dimension and constant in the others. More...
class	UnireciprocalFunction
	Reciprocal in a given dimension and constant in the others. More...

Functions
double	mod (double dividend, double divisor)
	Returns the rest of a whole-numbered division. More...
double	div (double dividend, double divisor)
	Returns the result of a whole-numbered division. More...
double	modulo (double a, double n)
	Returns the remainder r on division of dividend a by divisor n, using floored division. More...
bool	close (double one, double two)
	Tests whether two doubles are close enough to be declared equal. More...
int	stepfunction (double i)
	Returns 0 if i is close to 0, 1 if i is positive and greater than epsilon, or -1 if it is negative and less than epsilon. More...
double	step (double a, double b)
double	clamp (double v, double l, double u)
int	sign (double v)
	Returns 1 if the parameter is greater than zero, -1 if less than zero, 0 otherwise. More...
int	round (double d)
	Returns an integer that corresponds to rounded double parameter. More...
double	floorToZero (double d)
	Discards the fractional part of the parameter, e.g. More...
double	dB2fraction (double dB)
	Converts a dB value to fraction. More...
double	fraction2dB (double fraction)
	Convert a fraction value to dB. More...
double	dBmW2mW (double dBm)
	Converts a dBmW value to mW. More...
double	mW2dBmW (double mW)
	Convert a mW value to dBmW. More...
double	dBmWpMHz2WpHz (double dBmWpMHz)
	Converts a dBmW/MHz value into W/Hz. More...
double	wpHz2dBmWpMHz (double wpHz)
	Convert a W/Hz value to dBmW/MHz. More...
double	deg2rad (double deg)
	Convert a degree value to radian. More...
double	rad2deg (double rad)
	Convert a radian value to degree. More...
double	n_choose_k (int n, int k)
	Implementation of the n choose k (binomial coefficient) function, from the MiXiM Framework Author Karl Wessel. More...
template<typename T >
const T	minnan (const T &a, const T &b)
	This function properly and symmetrically handles NaNs in contrast with std::min and std::fmin. More...
template<typename T >
const T	maxnan (const T &a, const T &b)
	This function properly and symmetrically handles NaNs in contrast with std::max and std::fmax. More...
template<typename R , typename D >
Ptr< const DomainLimitedFunction< R, D > >	makeFirstQuadrantLimitedFunction (const Ptr< const IFunction< R, D >> &f)
template<typename R , typename D , int DIMS, typename RI , typename DI >
Ptr< const IFunction< RI, DI > >	integrate (const Ptr< const IFunction< R, D >> &f)
template<typename... T>
std::ostream &	operator<< (std::ostream &os, const Domain< T ... > &d)
template<typename R , typename... T>
std::ostream &	operator<< (std::ostream &os, const IFunction< R, Domain< T ... >> &f)
template<typename X , typename Y >
const IInterpolator< X, Y > *	createInterpolator (const char *text)
void	iterateCorners (const Interval<> &i, const std::function< void(const Point<> &)> f)
template<typename T0 , typename... TS>
void	iterateCorners (const Interval< T0, TS ... > &i, const std::function< void(const Point< T0, TS ... > &)> f)
template<typename... T>
std::ostream &	operator<< (std::ostream &os, const Interval< T ... > &i)
template<typename T >
void	printUnit (std::ostream &os, T v)
template<>
void	printUnit (std::ostream &os, double v)
template<>
void	printUnit (std::ostream &os, simtime_t v)
template<>
void	printUnit (std::ostream &os, Quaternion v)
template<typename T >
double	toDouble (const T v)
template<>
double	toDouble (const simsec v)
template<>
double	toDouble (const double v)
template<>
double	toDouble (const simtime_t v)
template<typename T >
T	getLowerBound ()
template<>
simsec	getLowerBound ()
template<typename T >
T	getUpperBound ()
template<>
simsec	getUpperBound ()
template<typename T , typename... TS>
T	head (const Point< T, TS ... > &p)
	Returns the first coordinate of p. More...
template<typename T , typename... TS>
Point< TS ... >	tail (const Point< T, TS ... > &p)
	Returns all but the first coordinate of p. More...
template<typename... TS1, typename... TS2>
Point< TS1 ..., TS2 ... >	concat (const Point< TS1 ... > &p1, const Point< TS2 ... > &p2)
	Returns a point by concatenating the coordinates of p1 and p2. More...
template<typename T0 >
std::ostream &	operator<< (std::ostream &os, const Point< T0 > &p)
template<typename... T>
std::ostream &	operator<< (std::ostream &os, const Point< T ... > &p)
template<typename R , typename D >
void	simplifyAndCall (const typename D::I &i, const IFunction< R, D > *f, const std::function< void(const typename D::I &, const IFunction< R, D > *)> callback)
template<typename R , typename D >
void	simplifyAndCall (const typename D::I &i, const UnilinearFunction< R, D > *f, const std::function< void(const typename D::I &, const IFunction< R, D > *)> callback)
template<typename R , typename D >
void	simplifyAndCall (const typename D::I &i, const BilinearFunction< R, D > *f, const std::function< void(const typename D::I &, const IFunction< R, D > *)> callback)

Variables
template<typename R , typename D , int DIMS, typename RI , typename DI >
class INET_API	IntegratedFunction
template<typename R , typename D >
class INET_API	ConstantFunction
template<typename R , typename D >
class INET_API	AddedFunction
template<typename R , typename D >
class INET_API	SubtractedFunction
template<typename R , typename D >
class INET_API	MultipliedFunction
template<typename R , typename D >
class INET_API	DividedFunction

Detailed Description

Support functions for mathematical operations.

This namespace contains all kind of mathematical support functions

Function Documentation

clamp()

double inet::math::clamp ( double  v, double  l, double  u  )

inline

{ return v < l ? l : v > u ? u : v; }

Referenced by inet::Coord::clamp().

close()

bool inet::math::close ( double  one, double  two  )

inline

Tests whether two doubles are close enough to be declared equal.

Returns true if parameters are at most epsilon apart, false otherwise

{ return fabs(one - two) < EPSILON; }

Referenced by inet::PostureTransition::isMarkovian(), inet::RotationMatrix::RotationMatrix(), stepfunction(), and inet::NetworkNamespaceContext::~NetworkNamespaceContext().

concat()

template<typename... TS1, typename... TS2>

Point<TS1 ..., TS2 ...> inet::math::concat	(	const Point< TS1 ... > &	p1,
		const Point< TS2 ... > &	p2
	)

Returns a point by concatenating the coordinates of p1 and p2.

                                                                                   {
    return internal::concatImpl(p1, std::index_sequence_for<TS1 ...>{}, p2, std::index_sequence_for<TS2 ...>{});
}

Referenced by inet::math::LeftCurryingFunction< R, C, DIMSC, D, DIMSD, E >::getValue(), inet::math::RightCurryingFunction< R, C, DIMSC, D, DIMSD, E >::getValue(), iterateCorners(), inet::math::LeftCurryingFunction< R, C, DIMSC, D, DIMSD, E >::partition(), and inet::math::RightCurryingFunction< R, C, DIMSC, D, DIMSD, E >::partition().

createInterpolator()

template<typename X , typename Y >

const IInterpolator<X, Y>* inet::math::createInterpolator

(

const char *

text

)

                                                                {
    if (!strcmp("either", text))
        return &EitherInterpolator<X, Y>::singleton;
    else if (!strcmp("left", text))
        return &LeftInterpolator<X, Y>::singleton;
    else if (!strcmp("right", text))
        return &RightInterpolator<X, Y>::singleton;
    else if (!strcmp("average", text))
        return &AverageInterpolator<X, Y>::singleton;
    else if (!strcmp("closer", text))
        return &CloserInterpolator<X, Y>::singleton;
    else if (!strcmp("minimum", text))
        return &MinimumInterpolator<X, Y>::singleton;
    else if (!strcmp("maximum", text))
        return &MaximumInterpolator<X, Y>::singleton;
    else if (!strcmp("linear", text))
        return &LinearInterpolator<X, Y>::singleton;
    else if (!strcmp("lineardb", text))
        return &LineardbInterpolator<X, Y>::singleton;
    else
        throw cRuntimeError("Unknown interpolator: '%s'", text);
}

dB2fraction()

double inet::math::dB2fraction ( double  dB )

inline

Converts a dB value to fraction.

{ return pow(10.0, dB / 10.0); }

Referenced by inet::physicallayer::AxiallySymmetricAntenna::AntennaGain::AntennaGain(), inet::physicallayer::ParabolicAntenna::AntennaGain::computeGain(), inet::physicallayer::MediumLimitCache::computeMaxAntennaGain(), inet::physicallayer::UwbIrStochasticPathLoss::getGhassemzadehPathLoss(), inet::math::LineardbInterpolator< X, Y >::getMean(), inet::math::LineardbInterpolator< X, Y >::getValue(), inet::physicallayer::ConstantGainAntenna::initialize(), inet::physicallayer::CosineAntenna::initialize(), inet::physicallayer::BreakpointPathLoss::initialize(), inet::physicallayer::SnirReceiverBase::initialize(), inet::physicallayer::ParabolicAntenna::initialize(), inet::physicallayer::AxiallySymmetricAntenna::initialize(), inet::physicallayer::ErrorModelBase::initialize(), inet::physicallayer::DimensionalTransmitterBase::parseGains(), and inet::physicallayer::InterpolatingAntenna::AntennaGain::parseMap().

dBmW2mW()

double inet::math::dBmW2mW ( double  dBm )

inline

Converts a dBmW value to mW.

{ return pow(10.0, dBm / 10.0); }

Referenced by inet::physicallayer::MediumLimitCache::computeMinInterferencePower(), inet::physicallayer::MediumLimitCache::computeMinReceptionPower(), inet::physicallayer::IsotropicScalarBackgroundNoise::initialize(), inet::physicallayer::DimensionalBackgroundNoise::initialize(), inet::physicallayer::IsotropicDimensionalBackgroundNoise::initialize(), inet::physicallayer::Ieee802154NarrowbandDimensionalReceiver::initialize(), inet::physicallayer::Ieee802154NarrowbandScalarReceiver::initialize(), inet::physicallayer::FlatReceiverBase::initialize(), inet::physicallayer::ApskLayeredReceiver::initialize(), and inet::physicallayer::Ieee80211LayeredOfdmReceiver::initialize().

dBmWpMHz2WpHz()

double inet::math::dBmWpMHz2WpHz ( double  dBmWpMHz )

inline

Converts a dBmW/MHz value into W/Hz.

{ return pow(10.0, dBmWpMHz / 10.0) / 1000000.0 / 1000.0; }

Referenced by inet::physicallayer::IsotropicDimensionalBackgroundNoise::initialize().

deg2rad()

double inet::math::deg2rad ( double  deg )

inline

Convert a degree value to radian.

{ return deg * M_PI / 180; }

Referenced by inet::physicallayer::CosineAntenna::AntennaGain::computeGain(), and inet::StationaryMobility::updateMobilityStateFromDisplayString().

div()

double inet::math::div ( double  dividend, double  divisor  )

inline

Returns the result of a whole-numbered division.

{
    double i;
    modf(dividend / divisor, &i);
    return i;
}

Referenced by inet::Int128::operator%=(), and inet::Int128::operator/=().

floorToZero()

double inet::math::floorToZero ( double  d )

inline

Discards the fractional part of the parameter, e.g.

-3.8 becomes -3

{ return (d >= 0.0) ? floor(d) : ceil(d); }

fraction2dB()

double inet::math::fraction2dB ( double  fraction )

inline

Convert a fraction value to dB.

{ return 10 * log10(fraction); }

Referenced by inet::visualizer::TracingObstacleLossCanvasVisualizer::createObstacleLossVisualization(), inet::math::LineardbInterpolator< X, Y >::getMean(), and inet::math::LineardbInterpolator< X, Y >::getValue().

getLowerBound() [1/2]

template<typename T >

T inet::math::getLowerBound ( )

inline

{ return T(-INFINITY); }

getLowerBound() [2/2]

template<>

simtime_t inet::math::getLowerBound ( )

inline

{ return simsec(-SimTime::getMaxTime() / 2); }

getUpperBound() [1/2]

template<typename T >

T inet::math::getUpperBound ( )

inline

{ return T(INFINITY); }

getUpperBound() [2/2]

template<>

simtime_t inet::math::getUpperBound ( )

inline

{ return simsec(SimTime::getMaxTime() / 2); }

head()

template<typename T , typename... TS>

T inet::math::head

(

const Point< T, TS ... > &

p

)

Returns the first coordinate of p.

                                  {
    return std::get<0>(p);
}

Referenced by inet::Ipv6NeighbourCache::DefaultRouterList::begin(), inet::Ipv6NeighbourCache::DefaultRouterList::clear(), inet::Ipv6NeighbourCache::DefaultRouterList::getHead(), iterateCorners(), inet::ospfv2::Router::printAsExternalLsa(), inet::ospfv2::Ospfv2Area::printLSDB(), inet::ospfv2::Ospfv2Area::printSummaryLsa(), inet::Ipv6NeighbourCache::DefaultRouterList::remove(), and inet::Ipv6NeighbourCache::DefaultRouterList::setHead().

integrate()

template<typename R , typename D , int DIMS, typename RI , typename DI >

Ptr<const IFunction<RI, DI> > inet::math::integrate

(

const Ptr< const IFunction< R, D >> &

f

)

                                                                            {
    return makeShared<IntegratedFunction<R, D, DIMS, RI, DI>>(f);
}

iterateCorners() [1/2]

template<typename T0 , typename... TS>

void inet::math::iterateCorners ( const Interval< T0, TS ... > &  i, const std::function< void(const Point< T0, TS ... > &)>  f  )

inline

                                                                                                               {
    Interval<TS ...> i1(tail(i.getLower()), tail(i.getUpper()), i.getLowerClosed() >> 1, i.getUpperClosed() >> 1, i.getFixed() >> 1);
    iterateCorners(i1, std::function<void(const Point<TS ...>&)>([&] (const Point<TS ...>& q) {
        f(concat(Point<T0>(head(i.getLower())), q));
        f(concat(Point<T0>(head(i.getUpper())), q));
    }));
}

iterateCorners() [2/2]

void inet::math::iterateCorners ( const Interval<> &  i, const std::function< void(const Point<> &)>  f  )

inline

                                                                                           {
    f(Point<>());
}

Referenced by inet::math::FunctionChecker< R, D >::check(), iterateCorners(), and inet::math::FunctionBase< R, Domain< X > >::printPartition().

makeFirstQuadrantLimitedFunction()

template<typename R , typename D >

Ptr<const DomainLimitedFunction<R, D> > inet::math::makeFirstQuadrantLimitedFunction

(

const Ptr< const IFunction< R, D >> &

f

)

                                                                                                             {
    auto m = (1 << std::tuple_size<typename D::P::type>::value) - 1;
    typename D::I i(D::P::getZero(), D::P::getUpperBounds(), m, 0, 0);
    return makeShared<DomainLimitedFunction<R, D>>(f, i);
}

Referenced by inet::physicallayer::IsotropicDimensionalBackgroundNoise::computeNoise(), and inet::physicallayer::DimensionalTransmitterBase::createPowerFunction().

maxnan()

template<typename T >

const T inet::math::maxnan ( const T &  a, const T &  b  )

inline

This function properly and symmetrically handles NaNs in contrast with std::max and std::fmax.

For example, the maximum of NaN and 1 must be NaN independently of the argument order. See 'Not a number' section at https://2pi.dk/2016/05/ieee-min-max

                                              {
static_assert(!std::is_integral<T>::value, "maxnan() is only meant for doubles and double based units, use std::max() for integers");
    if (a > b)
        return a;
    else if (b > a)
        return b;
    else if (a == b)
        return a;
    else
        return T(NaN);
}

Referenced by inet::physicallayer::ParabolicAntenna::AntennaGain::computeGain(), inet::physicallayer::CosineAntenna::AntennaGain::computeGain(), inet::physicallayer::DipoleAntenna::AntennaGain::computeGain(), inet::physicallayer::AxiallySymmetricAntenna::AntennaGain::computeGain(), inet::Cuboid::computeIntersection(), inet::physicallayer::ConvolutionalCode::computeNetBitErrorRate(), inet::math::InterpolatorBase< X, Y >::getMax(), inet::math::FunctionBase< R, Domain< X > >::getMax(), inet::math::UnilinearFunction< R, D >::getMax(), inet::math::BilinearFunction< R, D >::getMax(), inet::math::UnireciprocalFunction< R, D >::getMax(), inet::math::UnilinearFunction< R, D >::getRange(), inet::math::BilinearFunction< R, D >::getRange(), inet::math::MaximumInterpolator< X, Y >::getValue(), inet::math::Interval< R >::intersectImpl(), and inet::Quaternion::toEulerAngles().

minnan()

template<typename T >

const T inet::math::minnan ( const T &  a, const T &  b  )

inline

This function properly and symmetrically handles NaNs in contrast with std::min and std::fmin.

For example, the minimum of NaN and 1 must be NaN independently of the argument order. See 'Not a number' section at https://2pi.dk/2016/05/ieee-min-max

                                              {
static_assert(!std::is_integral<T>::value, "minnan() is only meant for doubles and double based units, use std::min() for integers");
    if (a < b)
        return a;
    else if (b < a)
        return b;
    else if (a == b)
        return a;
    else
        return T(NaN);
}

Referenced by inet::physicallayer::ParabolicAntenna::AntennaGain::computeGain(), inet::physicallayer::CosineAntenna::AntennaGain::computeGain(), inet::physicallayer::AxiallySymmetricAntenna::AntennaGain::computeGain(), inet::physicallayer::DipoleAntenna::AntennaGain::computeGain(), inet::Cuboid::computeIntersection(), inet::physicallayer::ConvolutionalCode::computeNetBitErrorRate(), inet::physicallayer::Ieee80211NistErrorModel::getFec1024QamBer(), inet::physicallayer::Ieee80211NistErrorModel::getFec16QamBer(), inet::physicallayer::Ieee80211NistErrorModel::getFec256QamBer(), inet::physicallayer::Ieee80211NistErrorModel::getFec64QamBer(), inet::physicallayer::Ieee80211NistErrorModel::getFecBpskBer(), inet::physicallayer::Ieee80211YansErrorModel::getFecBpskBer(), inet::physicallayer::Ieee80211YansErrorModel::getFecQamBer(), inet::physicallayer::Ieee80211NistErrorModel::getFecQpskBer(), inet::math::InterpolatorBase< X, Y >::getMin(), inet::math::FunctionBase< R, Domain< X > >::getMin(), inet::math::UnilinearFunction< R, D >::getMin(), inet::math::BilinearFunction< R, D >::getMin(), inet::math::UnireciprocalFunction< R, D >::getMin(), inet::math::UnilinearFunction< R, D >::getRange(), inet::math::BilinearFunction< R, D >::getRange(), inet::math::MinimumInterpolator< X, Y >::getValue(), inet::math::ApproximatedFunction< R, D, DIMENSION, X >::getValue(), inet::math::Interval< R >::intersectImpl(), and inet::Quaternion::toEulerAngles().

mod()

double inet::math::mod ( double  dividend, double  divisor  )

inline

Returns the rest of a whole-numbered division.

{
    double i;
    return modf(dividend / divisor, &i) * divisor;
}

Referenced by inet::_isNetworkNode(), inet::Ted::calculateShortestPaths(), inet::Ipv6FlatNetworkConfigurator::configureAdvPrefixes(), inet::Topology::extractFromNetwork(), inet::Ipv4FlatNetworkConfigurator::extractTopology(), inet::L3AddressResolver::findHostWithAddress(), inet::L3AddressResolver::findInterfaceWithMacAddress(), inet::findModuleFromPar(), inet::findModuleSomewhereUp(), inet::Topology::findNetworks(), inet::L3AddressResolver::getIpv4RoutingTableOf(), inet::L3AddressResolver::getIpv6RoutingTableOf(), inet::getModuleFromPar(), inet::Topology::getNodeFor(), inet::ScenarioManager::getRequiredModule(), inet::Ted::initializeTED(), inet::L3AddressResolver::interfaceTableOf(), inet::queueing::isApplication(), inet::isNetworkNode(), inet::ScenarioManager::processModuleSpecificCommand(), inet::ScenarioManager::processSetParamCommand(), inet::RsvpTe::readTrafficSessionFromXML(), inet::RsvpTe::sendPathNotify(), and inet::L3AddressResolver::tryResolve().

modulo()

double inet::math::modulo ( double  a, double  n  )

inline

Returns the remainder r on division of dividend a by divisor n, using floored division.

The remainder r has the same sign as the divisor n.

{ return a - n * floor(a / n); }

Referenced by inet::EulerAngles::normalize().

mW2dBmW()

double inet::math::mW2dBmW ( double  mW )

inline

Convert a mW value to dBmW.

{ return 10.0 * log10(mW); }

Referenced by inet::visualizer::Ieee80211VisualizerBase::getIcon().

n_choose_k()

double inet::math::n_choose_k ( int  n, int  k  )

inline

Implementation of the n choose k (binomial coefficient) function, from the MiXiM Framework Author Karl Wessel.

                                       {
    if (n < k)
        return 0.0;
 
    const int iK = (k << 1) > n ? n - k : k;
    const double dNSubK = (n - iK);
    int i = 1;
    double dRes = i > iK ? 1.0 : (dNSubK + i);
 
    for (++i; i <= iK; ++i) {
        dRes *= dNSubK + i;
        dRes /= i;
    }
    return dRes;
}

Referenced by inet::physicallayer::DsssOqpsk16Modulation::calculateBER().

operator<<() [1/5]

template<typename... T>

std::ostream& inet::math::operator<< ( std::ostream &  os, const Domain< T ... > &  d  )

inline

                                                                      {
    os << "(";
    internal::print(os, d, std::index_sequence_for<T ...>{});
    os << ")";
    return os;
}

operator<<() [2/5]

template<typename R , typename... T>

std::ostream& inet::math::operator<< ( std::ostream &  os, const IFunction< R, Domain< T ... >> &  f  )

inline

                                                                                    {
    f.print(os);
    return os;
}

operator<<() [3/5]

template<typename... T>

std::ostream& inet::math::operator<< ( std::ostream &  os, const Interval< T ... > &  i  )

inline

                                                                        {
    internal::print(os, i, std::index_sequence_for<T ...>{});
    return os;
}

operator<<() [4/5]

template<typename... T>

std::ostream& inet::math::operator<< ( std::ostream &  os, const Point< T ... > &  p  )

inline

                                                                     {
    os << "(";
    internal::print(os, p, std::index_sequence_for<T ...>{});
    os << ")";
    return os;
}

operator<<() [5/5]

template<typename T0 >

std::ostream& inet::math::operator<< ( std::ostream &  os, const Point< T0 > &  p  )

inline

                                                                  {
    return os << std::get<0>(p);
}

printUnit() [1/4]

template<>

void inet::math::printUnit ( std::ostream &  os, double  v  )

inline

{ os << "unit"; }

printUnit() [2/4]

template<>

void inet::math::printUnit ( std::ostream &  os, Quaternion  v  )

inline

{ os << "quaternion"; }

printUnit() [3/4]

template<>

void inet::math::printUnit ( std::ostream &  os, simtime_t  v  )

inline

{ os << "s"; }

printUnit() [4/4]

template<typename T >

void inet::math::printUnit ( std::ostream &  os, T  v  )

inline

{ units::output_unit<typename T::unit>::fn(os); }

Referenced by inet::math::internal::print(), and inet::math::FunctionBase< R, Domain< X > >::print().

rad2deg()

double inet::math::rad2deg ( double  rad )

inline

Convert a radian value to degree.

{ return rad * 180 / M_PI; }

Referenced by inet::MobilityBase::updateDisplayStringFromMobilityState().

round()

int inet::math::round ( double  d )

inline

Returns an integer that corresponds to rounded double parameter.

{ return static_cast<int>(ceil(d - 0.5)); }

Referenced by inet::visualizer::Ieee80211VisualizerBase::getIcon(), inet::power::SimpleEpEnergyStorage::handleMessage(), inet::VoipStreamSender::initialize(), inet::ospfv2::Ospfv2ConfigReader::loadInterfaceParameters(), inet::power::SimpleCcBattery::resolveDirective(), and inet::power::SimpleEpEnergyStorage::resolveDirective().

sign()

int inet::math::sign ( double  v )

inline

Returns 1 if the parameter is greater than zero, -1 if less than zero, 0 otherwise.

{ return (0 < v) - (v < 0); };

Referenced by inet::visualizer::LineManager::getLineShift(), inet::MobilityBase::reflectIfOutside(), inet::TractorMobility::setTargetPosition(), and inet::Coord::sign().

simplifyAndCall() [1/3]

template<typename R , typename D >

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

                                                                                                                                                           {
    if (f->getRLowerLower() == f->getRLowerUpper() && f->getRLowerLower() == f->getRUpperLower() && f->getRLowerLower() == f->getRUpperUpper()) {
        ConstantFunction<R, D> g(f->getRLowerLower());
        callback(i, &g);
    }
    // TODO simplify to one dimensional linear functions?
    else
        callback(i, f);
}

simplifyAndCall() [2/3]

template<typename R , typename D >

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

                                                                                                                                                    {
    callback(i, f);
}

Referenced by inet::math::AddedFunction< R, D >::partition(), inet::math::SubtractedFunction< R, D >::partition(), inet::math::MultipliedFunction< R, D >::partition(), inet::math::Combined2DFunction< R, X, Y >::partition(), inet::math::DividedFunction< R, D >::partition(), inet::math::SummedFunction< R, D >::partition(), and inet::math::Interpolated1DFunction< R, X >::partition().

simplifyAndCall() [3/3]

template<typename R , typename D >

void inet::math::simplifyAndCall	(	const typename D::I &	i,
		const UnilinearFunction< R, D > *	f,
		const std::function< void(const typename D::I &, const IFunction< R, D > *)>	callback
	)

                                                                                                                                                            {
    if (f->getRLower() == f->getRUpper()) {
        ConstantFunction<R, D> g(f->getRLower());
        callback(i, &g);
    }
    else
        callback(i, f);
}

step()

double inet::math::step ( double  a, double  b  )

inline

{ return b < a ? 0.0 : 1.0; };

Referenced by inet::ieee80211::FrameSequenceHandler::abortFrameSequence(), inet::ieee80211::FrameSequenceContext::addStep(), inet::BonnMotionMobility::computeMaxSpeed(), inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower(), inet::ieee80211::RtsCtsFs::getHistory(), inet::ieee80211::FragFrameAckFs::getHistory(), inet::ieee80211::LastFrameAckFs::getHistory(), inet::ieee80211::BlockAckReqBlockAckFs::getHistory(), inet::ieee80211::OptionalFs::getStep(), inet::ieee80211::RepeatingFs::getStep(), inet::ieee80211::AlternativesFs::getStep(), inet::math::ApproximatedFunction< R, D, DIMENSION, X >::getValue(), inet::math::PeriodicallyInterpolated1DFunction< R, X >::getValue(), inet::SpatialGrid::LineSegmentIterator::operator++(), inet::math::PeriodicallyInterpolated1DFunction< R, X >::partition(), inet::Coord::step(), and inet::ieee80211::FrameSequenceContext::~FrameSequenceContext().

stepfunction()

int inet::math::stepfunction ( double  i )

inline

Returns 0 if i is close to 0, 1 if i is positive and greater than epsilon, or -1 if it is negative and less than epsilon.

{ return (i > EPSILON) ? 1 : close(i, 0) ? 0 : -1; };

tail()

template<typename T , typename... TS>

Point<TS ...> inet::math::tail

(

const Point< T, TS ... > &

p

)

Returns all but the first coordinate of p.

                                              {
    return internal::tailImpl(std::make_index_sequence<sizeof...(TS)>(), p);
}

Referenced by iterateCorners(), and inet::eigrp::EigrpDeviceConfigurator::Str2Int().

toDouble() [1/4]

template<>

double inet::math::toDouble ( const double  v )

inline

{ return v; }

toDouble() [2/4]

template<>

double inet::math::toDouble ( const simsec  v )

inline

{ return v.get().dbl(); }

toDouble() [3/4]

template<>

double inet::math::toDouble ( const simtime_t  v )

inline

{ return v.dbl(); }

toDouble() [4/4]

template<typename T >

double inet::math::toDouble ( const T  v )

inline

{ return v.get(); }

Referenced by inet::math::internal::copyTupleElements(), inet::math::UnilinearFunction< R, D >::getA(), inet::math::UnilinearFunction< R, D >::getB(), inet::math::Point< T ... >::getImpl(), inet::math::LinearInterpolator< X, Y >::getValue(), inet::math::LineardbInterpolator< X, Y >::getValue(), inet::math::ApproximatedFunction< R, D, DIMENSION, X >::getValue(), inet::math::GaussFunction< R, X >::getValue(), inet::math::SawtoothFunction< R, X >::getValue(), inet::math::PeriodicallyInterpolated1DFunction< R, X >::getValue(), inet::math::Rasterized2DFunction< R, X, Y >::getValue(), inet::math::PeriodicallyInterpolated2DFunction< R, X, Y >::getValue(), inet::math::IntegratedFunction< R, Domain< X, Y >, DIMS, RI, Domain< X > >::getValue(), inet::math::IntegratedFunction< R, D, DIMS, RI, DI >::getValue(), inet::math::Interval< R >::getVolumeImpl(), inet::math::ConstantFunction< R, D >::isFinite(), inet::math::UnilinearFunction< R, D >::isFinite(), inet::math::BilinearFunction< R, D >::isFinite(), inet::math::Boxcar1DFunction< R, X >::isFinite(), inet::math::Boxcar2DFunction< R, X, Y >::isFinite(), inet::Int128::operator double(), inet::math::AddedFunction< R, D >::partition(), inet::math::MultipliedFunction< R, D >::partition(), inet::math::DividedFunction< R, D >::partition(), inet::math::PeriodicallyInterpolated1DFunction< R, X >::partition(), inet::math::Rasterized2DFunction< R, X, Y >::partition(), inet::math::PeriodicallyInterpolated2DFunction< R, X, Y >::partition(), inet::math::IntegratedFunction< R, Domain< X, Y >, DIMS, RI, Domain< X > >::partition(), and inet::math::Point< T ... >::setImpl().

wpHz2dBmWpMHz()

double inet::math::wpHz2dBmWpMHz ( double  wpHz )

inline

Convert a W/Hz value to dBmW/MHz.

{ return 10.0 * log10(wpHz * 1000000.0 * 1000.0); }

Variable Documentation

AddedFunction

template<typename R , typename D >

class INET_API inet::math::AddedFunction

ConstantFunction

template<typename R , typename D >

class INET_API inet::math::ConstantFunction

DividedFunction

template<typename R , typename D >

class INET_API inet::math::DividedFunction

IntegratedFunction

template<typename R , typename D , int DIMS, typename RI , typename DI >

class INET_API inet::math::IntegratedFunction

MultipliedFunction

template<typename R , typename D >

class INET_API inet::math::MultipliedFunction

SubtractedFunction

template<typename R , typename D >

class INET_API inet::math::SubtractedFunction