• Sign in

• Home
• Projects
• Help

Search:

NemoMath

• Overview
• Activity
• Roadmap
• Issues
• News
• Wiki
• Repository
• Documentation

nemo/ScalarMappings.h

Go to the documentation of this file.

#ifndef _NEMO_SCALAR_MAPPINGS_H_
#define _NEMO_SCALAR_MAPPINGS_H_

#include <cmath>

#include "Mapping.h"
#include "detail/nemo-cpp11.h"


namespace nemo {


#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Cos(){
    // compiler expects a function pointer T(*func)(T), it will pick out the correct 'overload'
    return Mapping<T,T>(std::cos, std::acos);
}

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Sin(){
    return Mapping<T,T>(std::sin, std::asin);
}

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Tan(){
    return Mapping<T,T>(std::tan, std::atan);
}

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Exp(){
    return Mapping<T,T>(std::exp, std::log);
}

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Log(){
    return Mapping<T,T>(std::log, std::exp);
}


namespace detail {
template <typename ValueType, typename ExponentType>
class PowMappingDefinition : public MappingDefinition<ValueType,ValueType> {
public:
    ValueType evaluate(ValueType value) const {
        return pow(value, exponent);
    }

    MappingDefinition<ValueType,ValueType>* getInverse() const {
        if(expIsIntegral){
            // ExponentType needs to be changed!!!
            return new PowMappingDefinition<ValueType,double>(1.0/(double)exponent);
        }
        return new PowMappingDefinition<ValueType,ExponentType>(1.0/exponent);
    }

    PowMappingDefinition(ExponentType exponentP) : exponent(exponentP) {}

private:
    ExponentType exponent;
    static bool expIsIntegral;
};
template <typename ValueType, typename ExponentType>
bool PowMappingDefinition<ValueType,ExponentType>::expIsIntegral = ( (ExponentType)(ExponentType()+0.5) == ExponentType() );
} // end namespace

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double,typename ExpType=double> 
#else
template <typename T,typename ExpType> 
#endif
static inline Mapping<T,T> Pow(ExpType exponent){
    return Mapping<T,T>(new detail::PowMappingDefinition<T,ExpType>(exponent));
}



#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Sqrt(){
    return Pow<T>(0.5);
}



namespace detail {
// MSVC even tries to compile the 'fabs(value)' below when T is integral
// consequence: ambiguous overload. Provide dummy implementations that let it compile:
//static inline short fabs(short){_NEMO_LOGIC_ERROR("");}
//static inline int fabs(int){_NEMO_LOGIC_ERROR("");}
//static inline long int fabs(long int){_NEMO_LOGIC_ERROR("");}

static inline long int nemo_abs(long int x){ return abs(x); }
static inline int nemo_abs(int x){ return abs(x); }
static inline short nemo_abs(short x){ return abs(x); }

static inline float nemo_abs(float x){ return fabs(x); }
static inline double nemo_abs(double x){ return fabs(x); }
static inline long double nemo_abs(long double x){ return fabs(x); }

template <typename T>
class AbsMappingDefinition : public MappingDefinition<T,T> {
public:
    T evaluate(T value) const {
        return nemo_abs(value);
        /*if(isIntegral){
            return abs(value);
        }
        else{
            using std::fabs; // use stdlib version if correct type is available
            return fabs(value);
        }*/
    }
private:
    //static bool isIntegral;


};
//template <typename T>
//bool AbsMappingDefinition<T>::isIntegral = ( (T)(T()+0.5) == T() );
} // end namespace

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Abs(){
    return Mapping<T,T>(new detail::AbsMappingDefinition<T>());
}



namespace detail {
// these function shall be used by ModMappingDefinition
static inline long int nemo_mod(long int x, long int y){ return x%y; }
static inline int nemo_mod(int x, int y){ return x%y; }
static inline short nemo_mod(short x, short y){ return x%y; }

static inline float nemo_mod(float x, float y){ return fmod(x,y); }
static inline double nemo_mod(double x, double y){ return fmod(x,y); }
static inline long double nemo_mod(long double x, long double y){ return fmod(x,y); }

template <typename T>
class ModMappingDefinition : public MappingDefinition<T,T> {
public:
    T evaluate(T value) const {
        return nemo_mod(value, modValue);
        /*if(isIntegral){
            // note: direct use of % would give compiler error for floats
            return lmod(value, modValue);
        }
        else{
            using std::fmod;
            return fmod(value, modValue);
        }*/
    }

    ModMappingDefinition(T modValueP) : modValue(modValueP) {}
private:
    T modValue;
    //static bool isIntegral;
};
//template <typename T>
//bool ModMappingDefinition<T>::isIntegral = ( (T)(T()+0.5) == T() );
} // end namespace

#ifdef _NEMO_HAS_FUNCTION_TEMPLATE_DEFAULTS_
template <typename T=double> 
#else
template <typename T> 
#endif
static inline Mapping<T,T> Mod(T modValue){
    return Mapping<T,T>(new detail::ModMappingDefinition<T>(modValue));
}


} // end namespace

#endif

---

Loading...

Powered by Redmine © 2006-2014 Jean-Philippe Lang