Provides several utility methods for Mappings. More...

#include <MappingUtils.h>

Public Types
typedef std::list< const ConstMapping * >	MappingBuffer

Static Public Member Functions
static Mapping *	createMapping (const DimensionSet &domain=DimensionSet(Dimension::time), Mapping::InterpolationMethod intpl=Mapping::LINEAR)
	Returns an appropriate changeable Mapping with the specified domain and the specified interpolation method. More...

static Mapping *	createMapping (Mapping::argument_value_cref_t outOfRangeValue, const DimensionSet &domain=DimensionSet(Dimension::time), Mapping::InterpolationMethod intpl=Mapping::LINEAR)
	Returns an appropriate changeable Mapping with the specified domain and the specified interpolation method. More...

template<class Operator >
static Mapping *	applyElementWiseOperator (const ConstMapping &f1, const ConstMapping &f2, const Argument &intvlStart, const Argument &intvlEnd, Operator op)

template<class Operator >
static Mapping *	applyElementWiseOperator (const ConstMapping &f1, const ConstMapping &f2, Operator op, Mapping::argument_value_cref_t outOfRangeVal=Argument::MappedZero, bool contOutOfRange=true)

static Mapping *	multiply (const ConstMapping &f1, const ConstMapping &f2)
	Multiplies the passed functions element-wise with each other and returns the result in a new Function. More...

static Mapping *	add (const ConstMapping &f1, const ConstMapping &f2)

static Mapping *	subtract (const ConstMapping &f1, const ConstMapping &f2)

static Mapping *	divide (const ConstMapping &f1, const ConstMapping &f2)

static Mapping *	multiply (const ConstMapping &f1, const ConstMapping &f2, Mapping::argument_value_cref_t outOfRangeVal)

static Mapping *	add (const ConstMapping &f1, const ConstMapping &f2, Mapping::argument_value_cref_t outOfRangeVal)

static Mapping *	subtract (const ConstMapping &f1, const ConstMapping &f2, Mapping::argument_value_cref_t outOfRangeVal)

static Mapping *	divide (const ConstMapping &f1, const ConstMapping &f2, Mapping::argument_value_cref_t outOfRangeVal)

static Argument::mapped_type	findMax (const ConstMapping &m, Argument::mapped_type_cref cRetNotFound=cMaxNotFound)
	Iterates over the passed mapping and returns value at the key entry with the highest value. More...

static Argument::mapped_type	findMax (const ConstMapping &m, const Argument &min, const Argument &max, Argument::mapped_type_cref cRetNotFound=cMaxNotFound)
	Iterates over the passed mapping and returns the value at the key entry with the highest value in the range defined by the passed min and max parameter. More...

static Argument::mapped_type	findMin (const ConstMapping &m, Argument::mapped_type_cref cRetNotFound=cMinNotFound)
	Iterates over the passed mapping and returns value at the key entry with the smallest value. More...

static Argument::mapped_type	findMin (const ConstMapping &m, const Argument &min, const Argument &max, Argument::mapped_type_cref cRetNotFound=cMinNotFound)
	Iterates over the passed mapping and returns the value at the key entry with the smallest value in the range defined by the passed min and max parameter. More...

static void	addDiscontinuity (Mapping *m, const Argument &pos, Argument::mapped_type_cref value, simtime_t_cref limitTime, Argument::mapped_type_cref limitValue)
	Adds a discontinuity in time-dimension, i.e. More...

static simtime_t	pre (simtime_t_cref t)
	returns the closest value of simtime before passed value More...

static simtime_t	post (simtime_t_cref t)
	returns the closest value of simtime after passed values More...

static simtime_t	incNextPosition (simtime_t_cref t)
	returns the incremented position point (used in RSAMConstMappingIterator::setNextPosition). More...

Static Public Attributes
static const Argument::mapped_type	cMinNotFound = std::numeric_limits<Argument::mapped_type>::infinity()
	The default value for findMin() functions if it does not find a minimum element. More...

static const Argument::mapped_type	cMaxNotFound = -std::numeric_limits<Argument::mapped_type>::infinity()
	The default value for findMax() functions if it does not find a maximum element. More...

Static Private Member Functions
static const ConstMapping *	createCompatibleMapping (const ConstMapping &src, const ConstMapping &dst)

static bool	iterateToNext (ConstMappingIterator it1, ConstMappingIterator it2)

Detailed Description

Provides several utility methods for Mappings.

Author: Karl Wessel

Member Typedef Documentation

typedef std::list<const ConstMapping *> inet::physicallayer::MappingUtils::MappingBuffer

Member Function Documentation

Mapping * inet::physicallayer::MappingUtils::add	(	const ConstMapping &	f1,
		const ConstMapping &	f2
	)

static

Referenced by inet::physicallayer::operator+().

 {
     return applyElementWiseOperator(f1, f2, std::plus<Mapping::argument_value_t>());
 }

Mapping * inet::physicallayer::MappingUtils::add	(	const ConstMapping &	f1,
		const ConstMapping &	f2,
		Mapping::argument_value_cref_t	outOfRangeVal
	)

static

 {
     return applyElementWiseOperator(f1, f2, std::plus<Mapping::argument_value_t>(), outOfRangeVal, false);
 }

void inet::physicallayer::MappingUtils::addDiscontinuity	(	Mapping *	m,
		const Argument &	pos,
		Argument::mapped_type_cref	value,
		simtime_t_cref	limitTime,
		Argument::mapped_type_cref	limitValue
	)

static

Adds a discontinuity in time-dimension, i.e.

its representation, to a passed mapping.

This is done by setting a regular entry and a limit-entry. The limit-entry shall be very close to the regular entry (on its left or right).

The implementation works simply by adding the limit-value as a separate entry at the position of the limit-time. This means that this methods adds a total of two entries to the passed mapping.

Note: One should use the methods 'pre' or 'post' provided by MappingUtils to calculate the limit-time for the discontinuity.

Parameters

m	The mapping the discontinuity will be added to.
pos	The position of the regular entry.
value	The value of the regular entry.
limitTime	The time-point of the limit-entry.
limitValue	The value of the limit-entry.

 {
     // asserts/preconditions
     // make sure the time really differs at the discontinuity
     assert(limitTime != pos.getTime());
 
     // add (pos, value) to mapping
     m->setValue(pos, value);
 
     // create Argument limitPos for the limit-position, i.e. copy pos and set limitTime as its time
     Argument limitPos = pos;
     limitPos.setTime(limitTime);
 
     // add (limitPos, limitValue) to mapping
     m->setValue(limitPos, limitValue);
 }

template<class Operator >

static Mapping* inet::physicallayer::MappingUtils::applyElementWiseOperator	(	const ConstMapping &	f1,
		const ConstMapping &	f2,
		const Argument &	intvlStart,
		const Argument &	intvlEnd,
		Operator	op
	)

inlinestatic

Referenced by inet::physicallayer::ConcatConstMapping< Operator >::createConcatenatedMapping().

     {
         return 0;
     }

template<class Operator >

static Mapping* inet::physicallayer::MappingUtils::applyElementWiseOperator	(	const ConstMapping &	f1,
		const ConstMapping &	f2,
		Operator	op,
		Mapping::argument_value_cref_t	outOfRangeVal = `Argument::MappedZero`,
		bool	contOutOfRange = `true`
	)

inlinestatic

     {
         using std::operator<<;
 
         const ConstMapping *const f2Comp = createCompatibleMapping(f2, f1);
         const ConstMapping *const f1Comp = createCompatibleMapping(f1, f2);
 
         const DimensionSet& domain = f1Comp->getDimensionSet();
         Mapping *const result = (contOutOfRange) ? MappingUtils::createMapping(domain) : MappingUtils::createMapping(outOfRangeVal, domain);
 
         ConstMappingIterator *const itF1 = f1Comp->createConstIterator();
         ConstMappingIterator *const itF2 = f2Comp->createConstIterator();
         const bool bF1InRange = itF1->inRange();
         const bool bF2InRange = itF2->inRange();
 
         if (!bF1InRange && !bF2InRange) {
             delete itF1;
             delete itF2;
             return result;
         }
 
         MappingIterator *itRes = 0;
 
         if (bF1InRange && (!bF2InRange || itF1->getPosition() < itF2->getPosition())) {
             itF2->jumpTo(itF1->getPosition());
         }
         else {
             itF1->jumpTo(itF2->getPosition());
         }
 
         itRes = result->createIterator(itF1->getPosition());
 
         while (itF1->inRange() || itF2->inRange()) {
 //            assert(itF1->getPosition().isSamePosition(itF2->getPosition()));
 
             Mapping::argument_value_cref_t prod = op(itF1->getValue(), itF2->getValue());
             //result->setValue(itF1->getPosition(), prod);
             itRes->setValue(prod);
 
             if (!iterateToNext(itF1, itF2))
                 break;
 
             itRes->iterateTo(itF1->getPosition());
         }
 
         delete itF1;
         delete itF2;
         delete itRes;
 
         if (&f2 != f2Comp)
             delete (f2Comp);
         if (&f1 != f1Comp)
             delete (f1Comp);
 
         return result;
     }

const ConstMapping * inet::physicallayer::MappingUtils::createCompatibleMapping	(	const ConstMapping &	src,
		const ConstMapping &	dst
	)

staticprivate

 {
     typedef FilledUpMapping::KeySet KeySet;
     typedef FilledUpMapping::KeyMap KeyMap;
 
     KeyMap DimensionIndizes;
 
     const DimensionSet& srcDims = src.getDimensionSet();
     const DimensionSet& dstDims = dst.getDimensionSet();
 
     const DimensionSet::const_iterator srcDimsEnd = srcDims.end();
     const DimensionSet::const_reverse_iterator dstDimsEnd = dstDims.rend();
     for (DimensionSet::const_reverse_iterator dstDimIt = dstDims.rbegin(); dstDimIt != dstDimsEnd; ++dstDimIt) {
         if (srcDims.find(*dstDimIt) == srcDimsEnd) {
             DimensionIndizes.insert(DimensionIndizes.end(), KeyMap::value_type(*dstDimIt, KeySet()));
         }
     }
 
     if (DimensionIndizes.empty())
         return &src;
 
     ConstMappingIterator *dstIt = dst.createConstIterator();
 
     if (!dstIt->inRange()) {
         delete dstIt;
         return &src;
     }
 
     const auto keysEnd = DimensionIndizes.end();
     do {
         for (auto keyDimIt = DimensionIndizes.begin(); keyDimIt != keysEnd; ++keyDimIt) {
             keyDimIt->second.insert(dstIt->getPosition().getArgValue(keyDimIt->first));
         }
 
         if (!dstIt->hasNext())
             break;
         dstIt->next();
     } while (true);
 
     delete dstIt;
 
     return new FilledUpMapping(&src, dstDims, DimensionIndizes);
 }

Mapping * inet::physicallayer::MappingUtils::createMapping	(	const DimensionSet &	domain = `DimensionSet(Dimension::time)`,
		Mapping::InterpolationMethod	intpl = `Mapping::LINEAR`
	)

static

Returns an appropriate changeable Mapping with the specified domain and the specified interpolation method.

Note: The interpolation method is always linear, at the moment.

Referenced by applyElementWiseOperator(), inet::physicallayer::DimensionalAnalogModelBase::computeNoise(), inet::physicallayer::IsotropicDimensionalBackgroundNoise::computeNoise(), inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower(), and inet::physicallayer::DimensionalTransmitterBase::createPowerMapping().

 {
     if (domain.size() == 1) {
         if (domain.hasDimension(Dimension::time)) {
             switch (intpl) {
                 case Mapping::LINEAR:
                     return new TimeMapping<Linear>();
                 case Mapping::NEAREST:
                     return new TimeMapping<Nearest>();
                 case Mapping::STEPS:
                     return new TimeMapping<NextSmaller>();
             }
         }
         else if (domain.hasDimension(Dimension::frequency)) {
             switch (intpl) {
                 case Mapping::LINEAR:
                     return new FrequencyMapping<Linear>();
                 case Mapping::NEAREST:
                     return new FrequencyMapping<Nearest>();
                 case Mapping::STEPS:
                     return new FrequencyMapping<NextSmaller>();
             }
         }
     }
     else {
         switch (intpl) {
             case Mapping::LINEAR:
                 return new MultiDimMapping<Linear>(domain);
             case Mapping::NEAREST:
                 return new MultiDimMapping<Nearest>(domain);
             case Mapping::STEPS:
                 return new MultiDimMapping<NextSmaller>(domain);
         }
     }
     throw cRuntimeError("Cannot create mapping");
 }

Mapping * inet::physicallayer::MappingUtils::createMapping	(	Mapping::argument_value_cref_t	outOfRangeValue,
		const DimensionSet &	domain = `DimensionSet(Dimension::time)`,
		Mapping::InterpolationMethod	intpl = `Mapping::LINEAR`
	)

static

Returns an appropriate changeable Mapping with the specified domain and the specified interpolation method.

Note: The interpolation method is always linear, at the moment.

 {
     if (domain.size() == 1) {
         if (domain.hasDimension(Dimension::time)) {
             switch (intpl) {
                 case Mapping::LINEAR:
                     return new TimeMapping<Linear>(outOfRangeVal);
                 case Mapping::NEAREST:
                     return new TimeMapping<Nearest>(outOfRangeVal);
                 case Mapping::STEPS:
                     return new TimeMapping<NextSmaller>(outOfRangeVal);
             }
         }
         else if (domain.hasDimension(Dimension::frequency)) {
             switch (intpl) {
                 case Mapping::LINEAR:
                     return new FrequencyMapping<Linear>(outOfRangeVal);
                 case Mapping::NEAREST:
                     return new FrequencyMapping<Nearest>(outOfRangeVal);
                 case Mapping::STEPS:
                     return new FrequencyMapping<NextSmaller>(outOfRangeVal);
             }
         }
     }
     else {
         switch (intpl) {
             case Mapping::LINEAR:
                 return new MultiDimMapping<Linear>(domain, outOfRangeVal);
             case Mapping::NEAREST:
                 return new MultiDimMapping<Nearest>(domain, outOfRangeVal);
             case Mapping::STEPS:
                 return new MultiDimMapping<NextSmaller>(domain, outOfRangeVal);
         }
     }
     throw cRuntimeError("Cannot create mapping");
 }

Mapping * inet::physicallayer::MappingUtils::divide	(	const ConstMapping &	f1,
		const ConstMapping &	f2
	)

static

Referenced by inet::physicallayer::DimensionalSNIR::computeMin(), and inet::physicallayer::operator/().

 {
     return applyElementWiseOperator(f1, f2, std::divides<Mapping::argument_value_t>());
 }

Mapping * inet::physicallayer::MappingUtils::divide	(	const ConstMapping &	f1,
		const ConstMapping &	f2,
		Mapping::argument_value_cref_t	outOfRangeVal
	)

static

 {
     return applyElementWiseOperator(f1, f2, std::divides<Mapping::argument_value_t>(), outOfRangeVal, false);
 }

Mapping::argument_value_t inet::physicallayer::MappingUtils::findMax	(	const ConstMapping &	m,
		Argument::mapped_type_cref	cRetNotFound = `cMaxNotFound`
	)

static

Iterates over the passed mapping and returns value at the key entry with the highest value.

Parameters

m	The map where the maximum value shall be searched.
cRetNotFound	The value which shall be returned if no maximum was found (default MappingUtils::cMaxNotFound).

Returns: The value at the key entry with the highest value or cRetNotFound if map is empty.

Referenced by inet::physicallayer::DimensionalNoise::computeMaxPower(), inet::physicallayer::DimensionalTransmission::printToStream(), inet::physicallayer::DimensionalSignalAnalogModel::printToStream(), and inet::physicallayer::DimensionalNoise::printToStream().

 {
     ConstMappingIterator *it = m.createConstIterator();
     bool bIsFirst = true;
     Mapping::argument_value_t res;
 
     while (it->inRange()) {
         Mapping::argument_value_cref_t val = it->getValue();
         if (bIsFirst || val > res) {
             res = val;
             bIsFirst = false;
         }
 
         //std::cerr << "findMax(): " << val << " @ " << it->getPosition() << "; max is now: " << res << std::endl;
         if (!it->hasNext())
             break;
 
         it->next();
     }
     delete it;
     if (bIsFirst) {
         // no maximum available, maybe map is empty
         return cRetNotFound;
     }
     return res;
 }

Mapping::argument_value_t inet::physicallayer::MappingUtils::findMax	(	const ConstMapping &	m,
		const Argument &	min,
		const Argument &	max,
		Argument::mapped_type_cref	cRetNotFound = `cMaxNotFound`
	)

static

Iterates over the passed mapping and returns the value at the key entry with the highest value in the range defined by the passed min and max parameter.

The area defined by the min and max parameter is the number of key entries which position in each dimension is bigger or equal than the value of the min parameter in that dimension and smaller or equal than max parameter in that dimension.

Parameters

m	The map where the maximum value shall be searched.
min	The beginning of search range.
max	The end of search range.
cRetNotFound	The value which shall be returned if no maximum was found (default MappingUtils::cMaxNotFound).

Returns: The value at the key entry with the highest value or cRetNotFound if map is empty or no element in range [min,max].

 {
     const DimensionSet& rDimSet = m.getDimensionSet();
     //the passed interval should define a value for every dimension
     //of the mapping.
     assert(pRangeFrom.getDimensions().isSubSet(rDimSet));
     assert(pRangeTo.getDimensions().isSubSet(rDimSet));
 
     ConstMappingIterator *it = m.createConstIterator(pRangeFrom);
     bool bIsFirst = true;
     Mapping::argument_value_t res;
 
     //std::cerr << "findMax(m, " << pRangeFrom << ", " << pRangeTo << "): Map is" << std::endl << m;
     if (it->inRange()) {
         res = it->getValue();
         bIsFirst = false;
         //std::cerr << "findMax(...):  " << " @ " << it->getPosition() << "; max is at beginning: " << res << std::endl;
     }
     while (it->hasNext() && it->getNextPosition().compare(pRangeTo, &rDimSet) < 0) {
         it->next();
 
         const Argument& next = it->getPosition();
         bool inRange = pRangeFrom.getTime() <= next.getTime() && next.getTime() <= pRangeTo.getTime();
         if (inRange) {
             const Argument::const_iterator itAEnd = next.end();
             for (Argument::const_iterator itA = next.begin(); itA != itAEnd; ++itA) {
                 if (pRangeFrom.getArgValue(itA->first) > itA->second || itA->second > pRangeTo.getArgValue(itA->first)) {
                     inRange = false;
                     break;
                 }
             }
         }
         if (inRange) {
             Mapping::argument_value_cref_t val = it->getValue();
             if (bIsFirst || val > res) {
                 res = val;
                 bIsFirst = false;
             }
             //std::cerr << "findMax(...): " << val << " @ " << it->getPosition() << "; max is now: " << res << std::endl;
         }
     }
     it->iterateTo(pRangeTo);
     if (it->inRange()) {
         Mapping::argument_value_cref_t val = it->getValue();
         if (bIsFirst || val > res) {
             res = val;
             bIsFirst = false;
         }
         //std::cerr << "findMax(...): " << val << " @ " << it->getPosition() << "; max is finally: " << res << std::endl;
     }
     delete it;
     if (bIsFirst) {
         // no minimum available
         return cRetNotFound;
     }
     return res;
 }

Mapping::argument_value_t inet::physicallayer::MappingUtils::findMin	(	const ConstMapping &	m,
		Argument::mapped_type_cref	cRetNotFound = `cMinNotFound`
	)

static

Iterates over the passed mapping and returns value at the key entry with the smallest value.

Parameters

m	The map where the minimum value shall be searched.
cRetNotFound	The value which shall be returned if no minimum was found (default MappingUtils::cMinNotFound).

Returns: The value at the key entry with the lowest value or cRetNotFound if map is empty.

Referenced by inet::physicallayer::DimensionalSNIR::computeMin(), inet::physicallayer::DimensionalReception::computeMinPower(), inet::physicallayer::DimensionalSignalAnalogModel::computeMinPower(), inet::physicallayer::DimensionalNoise::printToStream(), inet::physicallayer::DimensionalSignalAnalogModel::printToStream(), and inet::physicallayer::DimensionalTransmission::printToStream().

 {
     ConstMappingIterator *it = m.createConstIterator();
     bool bIsFirst = true;
     Mapping::argument_value_t res;
 
     while (it->inRange()) {
         Mapping::argument_value_cref_t val = it->getValue();
         if (bIsFirst || val < res) {
             res = val;
             bIsFirst = false;
         }
 
         //std::cerr << "findMin(): " << val << " @ " << it->getPosition() << "; min is now: " << res << std::endl;
         if (!it->hasNext())
             break;
 
         it->next();
     }
     delete it;
     if (bIsFirst) {
         // no minimum available, maybe map is empty
         return cRetNotFound;
     }
     return res;
 }

Mapping::argument_value_t inet::physicallayer::MappingUtils::findMin	(	const ConstMapping &	m,
		const Argument &	min,
		const Argument &	max,
		Argument::mapped_type_cref	cRetNotFound = `cMinNotFound`
	)

static

Iterates over the passed mapping and returns the value at the key entry with the smallest value in the range defined by the passed min and max parameter.

The area defined by the min and max parameter is the number of key entries which position in each dimension is bigger or equal than the value of the min parameter in that dimension and smaller or equal than max parameter in that dimension.

Parameters

m	The map where the minimum value shall be searched.
min	The beginning of search range.
max	The end of search range.
cRetNotFound	The value which shall be returned if no minimum was found (default MappingUtils::cMinNotFound).

Returns: The value at the key entry with the highest value or cRetNotFound if map is empty or no element in range [min,max].

 {
     const DimensionSet& rDimSet = m.getDimensionSet();
     //the passed interval should define a value for every dimension
     //of the mapping.
     assert(pRangeFrom.getDimensions().isSubSet(rDimSet));
     assert(pRangeTo.getDimensions().isSubSet(rDimSet));
 
     Mapping::argument_value_t res;
     bool bIsFirst = true;
     ConstMappingIterator *it = m.createConstIterator(pRangeFrom);
 
     //std::cerr << "findMin(m, " << pRangeFrom << ", " << pRangeTo << "): Map is" << std::endl << m;
     if (it->inRange()) {
         res = it->getValue();
         bIsFirst = false;
         //std::cerr << "findMin(...):  " << " @ " << it->getPosition() << "; min is at beginning: " << res << std::endl;
     }
     while (it->hasNext() && it->getNextPosition().compare(pRangeTo, &rDimSet) < 0) {
         it->next();
 
         const Argument& next = it->getPosition();
         bool inRange = pRangeFrom.getTime() <= next.getTime() && next.getTime() <= pRangeTo.getTime();
         if (inRange) {
             const Argument::const_iterator itAEnd = next.end();
             for (Argument::const_iterator itA = next.begin(); itA != itAEnd; ++itA) {
                 if (pRangeFrom.getArgValue(itA->first) > itA->second || itA->second > pRangeTo.getArgValue(itA->first)) {
                     inRange = false;
                     break;
                 }
             }
         }
         if (inRange) {
             Mapping::argument_value_cref_t val = it->getValue();
             if (bIsFirst || val < res) {
                 res = val;
                 bIsFirst = false;
             }
             //std::cerr << "findMin(...): " << val << " @ " << it->getPosition() << "; min is now: " << res << std::endl;
         }
     }
     it->iterateTo(pRangeTo);
     if (it->inRange()) {
         Mapping::argument_value_cref_t val = it->getValue();
         if (bIsFirst || val < res) {
             res = val;
             bIsFirst = false;
         }
         //std::cerr << "findMin(...): " << val << " @ " << it->getPosition() << "; min is finally: " << res << std::endl;
     }
     delete it;
     if (bIsFirst) {
         // no minimum available
         return cRetNotFound;
     }
     return res;
 }

simtime_t inet::physicallayer::MappingUtils::incNextPosition ( simtime_t_cref t )

static

returns the incremented position point (used in RSAMConstMappingIterator::setNextPosition).

 {
     //assert(SIMTIME_RAW(t) < SIMTIME_RAW(MAXTIME));
     // original it was following formula, but I do not know why
     // the '+1' is used here!? I think post should be enough!
     //return t + 1;
     return post(t);
 }

bool inet::physicallayer::MappingUtils::iterateToNext	(	ConstMappingIterator *	it1,
		ConstMappingIterator *	it2
	)

staticprivate

 {
     bool it1HasNext = it1->hasNext();
     bool it2HasNext = it2->hasNext();
 
     if (it1HasNext || it2HasNext) {
         if (it1HasNext && (!it2HasNext || it1->getNextPosition() < it2->getNextPosition())) {
             it1->next();
             it2->iterateTo(it1->getPosition());
         }
         else {
             it2->next();
             it1->iterateTo(it2->getPosition());
         }
 
         return true;
     }
     else {
         return false;
     }
 }

Mapping * inet::physicallayer::MappingUtils::multiply	(	const ConstMapping &	f1,
		const ConstMapping &	f2
	)

static

Multiplies the passed functions element-wise with each other and returns the result in a new Function.

The domain (DimensionSet) of the result is defined by the domain of the first operand. The domain of the second Mapping has to be a subset of the domain of the first mapping.

Referenced by inet::physicallayer::operator*().

 {
     return applyElementWiseOperator(f1, f2, std::multiplies<Mapping::argument_value_t>());
 }

Mapping * inet::physicallayer::MappingUtils::multiply	(	const ConstMapping &	f1,
		const ConstMapping &	f2,
		Mapping::argument_value_cref_t	outOfRangeVal
	)

static

 {
     return applyElementWiseOperator(f1, f2, std::multiplies<Mapping::argument_value_t>(), outOfRangeVal, false);
 }

simtime_t inet::physicallayer::MappingUtils::post ( simtime_t_cref t )

static

returns the closest value of simtime after passed values

 {
     assert(t < SIMTIME_MAX);
 
     simtime_t stPost;
     stPost.setRaw(t.raw() + 1);
 
     return stPost;
 }

simtime_t inet::physicallayer::MappingUtils::pre ( simtime_t_cref t )

static

returns the closest value of simtime before passed value

Referenced by inet::physicallayer::DimensionalSNIR::computeMin(), inet::physicallayer::DimensionalReception::computeMinPower(), and inet::physicallayer::DimensionalSignalAnalogModel::computeMinPower().

 {
     assert(t > SIMTIME_ZERO);
 
     simtime_t stPre;
     stPre.setRaw(t.raw() - 1);
 
     return stPre;
 }

Mapping * inet::physicallayer::MappingUtils::subtract	(	const ConstMapping &	f1,
		const ConstMapping &	f2
	)

static

Referenced by inet::physicallayer::operator-().

 {
     return applyElementWiseOperator(f1, f2, std::minus<Mapping::argument_value_t>());
 }

Mapping * inet::physicallayer::MappingUtils::subtract	(	const ConstMapping &	f1,
		const ConstMapping &	f2,
		Mapping::argument_value_cref_t	outOfRangeVal
	)

static

 {
     return applyElementWiseOperator(f1, f2, std::minus<Mapping::argument_value_t>(), outOfRangeVal, false);
 }

Member Data Documentation

const Argument::mapped_type inet::physicallayer::MappingUtils::cMaxNotFound = -std::numeric_limits<Argument::mapped_type>::infinity()

static

The default value for findMax() functions if it does not find a maximum element.

It will be initialized with the negative infinity value.

Referenced by inet::physicallayer::FilledUpMappingIterator::FilledUpMappingIterator().

const Argument::mapped_type inet::physicallayer::MappingUtils::cMinNotFound = std::numeric_limits<Argument::mapped_type>::infinity()

static

The default value for findMin() functions if it does not find a minimum element.

It will be initialized with the infinity value.

Referenced by inet::physicallayer::FilledUpMappingIterator::FilledUpMappingIterator().

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

Public Types

Static Public Member Functions

Static Public Attributes

Static Private Member Functions

Detailed Description

Member Typedef Documentation

Member Function Documentation

Member Data Documentation