pstatic_computation.h

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __PSTATIC_COMPUTATION_H__
#define __PSTATIC_COMPUTATION_H__

template<unsigned int N> struct pstatic_fact{
        enum {Value = N * pstatic_fact<N - 1>::Value};
};

template<> struct pstatic_fact<0>{
        enum {Value = 1};
};

template<unsigned int V, unsigned int N> struct PPower{
        enum {Value = V * PPower<V, N - 1>::Value};
};

template<unsigned int V> struct PPower<V, 1>{
        enum {Value = V};
};

template<unsigned int V> struct PPower<V, 0>{
        enum {Value = 1};
};
 
/*
 * Attention, cette version est 100% calculée à la compilation, elle ne servira donc qu'à calculer des constantes, et ne sera donc pas utilisée à l'exécution.
 * Voici la même mais en version "fonction inline", ce qui nous permettra de renvoyer un double et donc de manipuler des nombres beaucoup plus grands (on est limité à 12! avec la version ci-dessus)
*/ 


template <unsigned int I> inline double pstatic_factd(){
        return I * pstatic_factd<I - 1>();
}


template <> inline double pstatic_factd<0>(){
        return 1.0;
}


template <unsigned int I> inline float pstatic_factf(){
        return I * pstatic_factf<I - 1>();
}


template <> inline float pstatic_factf<0>(){
        return 1.0f;
}


template <int N> inline double pstatic_powd(double x){
        return x * pstatic_powd<N - 1>(x);
}


template <> inline double pstatic_powd<0>(double x){
        return 1.0;
}


template <int N> inline float pstatic_powf(float x){
        return x * pstatic_powf<N - 1>(x);
}


template <> inline float pstatic_powf<0>(float x){
        return 1.0f;
}


template <int I> inline double pstatic_expd_part(double x){
        return pstatic_expd_part<I - 1>(x) + pstatic_powd<I>(x) / pstatic_factd<I>();
}


template <> inline double pstatic_expd_part<0>(double x){
        return 0.0;
}


template <int N> inline double pstatic_expd(double x){
        return x < 0.0 ? 1.0 / pstatic_expd_part<N>(-x) : pstatic_expd_part<N>(x);
}


template <int I> inline float pstatic_expf_part(float x){
        return pstatic_expf_part<I - 1>(x) + pstatic_powf<I>(x) / pstatic_factf<I>();
}


template <> inline float pstatic_expf_part<0>(float x){
        return 0.0;
}


template <int N> inline float pstatic_expf(float x){
        return x < 0.0 ? 1.0 / pstatic_expf_part<N>(-x) : pstatic_expf_part<N>(x);
}


template <int N> inline double pstatic_cosd(double x){
        return pstatic_cosd<N - 1>(x) + (N % 2 ? -1 : 1) * pstatic_powd<2 * N>(x) / pstatic_factd<2 * N>();
}


template <> inline double pstatic_cosd<0>(double x){
        return 1.0;
}


template <int N> inline float pstatic_cosf(float x){
        return pstatic_cosf<N - 1>(x) + (N % 2 ? -1 : 1) * pstatic_powf<2 * N>(x) / pstatic_factf<2 * N>();
}


template <> inline float pstatic_cosf<0>(float x){
        return 1.0f;
}


template <int I> inline double pstatic_atanhd(double x){
        return pstatic_atanhd<I - 1>(x) + pstatic_powd<2 * I + 1>(x) / (2 * I + 1);
}


template <> inline double pstatic_atanhd<1>(double x){
        return x;
}


template <> inline double pstatic_atanhd<0>(double x){
        return 0.0;
}


template <int I> inline float pstatic_atanhf(float x){
        return pstatic_atanhf<I - 1>(x) + pstatic_powf<2 * I + 1>(x) / (2 * I + 1);
}


template <> inline float pstatic_atanhf<1>(float x){
        return x;
}


template <> inline float pstatic_atanhf<0>(float x){
        return 0.0f;
}
 
/* Pour conclure cette partie, je tiens à vous signaler que ces fonctions ne sont encore pas optimisées à fond.
 * En effet les fans de bricolage pourront s'en donner à cœur joie, pour notamment réduire la profondeur de récursion ou éliminer les branches de récursion inutiles.
 * De même en remaniant les formules mathématiques utilisées pour les rendre plus sympathiques pour nos templates, il y a encore là matière à optimiser. 
*/
 
#endif