rawarfun.h

Go to the documentation of this file.

// include guard
#ifndef AFF_RAWARFUN_H_VERSION

#define AFF_RAWARFUN_H_VERSION \
  "AFF_RAWARFUN_H   V1.3"

#include<aff/lib/types.h>
 
namespace aff {

namespace util {

  template<typename T, int I>
    class Inline {
      public:
        static inline void copy(const T* source, T* target)
        { 
          target[I-1]=source[I-1]; 
          Inline<T,I-1>::copy(source, target); 
        }
        static inline T product(const T* array)
        { 
          return(array[I-1]*Inline<T,I-1>::product(array)); 
        }
        static inline T sum(const T* array)
        { 
          return(array[I-1]+Inline<T,I-1>::sum(array));
        }
        static inline void set(T* array, const T& value)
        { 
          array[I-1]=value; Inline<T,I-1>::set(array, value);
        }
        static inline bool anysmaller(const T* A, const T* B)
        {
          return (((*A) < (*B)) 
                  || Inline<T,I-1>::anysmaller(&(A[1]), &(B[1])));
        }
        static inline bool anylarger(const T* A, const T* B)
        {
          return (((*A) > (*B)) 
                  || Inline<T,I-1>::anylarger(&(A[1]), &(B[1])));
        }
        static inline T innerproduct(const T* A, const T* B)
        {
          return(A[I-1]*B[I-1]+Inline<T, I-1>::innerproduct(A,B));
        }
        static inline T strideproduct(const T* A, const T* B)
        {
          return((*A)+(*B)*Inline<T, I-1>::strideproduct(&(A[1]),&(B[1])));
        }
    }; // class Inline
  
  template<typename T>
    class Inline<T,1> {
      public:
        static inline void copy(const T* source, T* target) 
        { target[0]=source[0]; }
        static inline T product(const T* array) 
        { return (array[0]); }
        static inline T sum(const T* array) 
        { return (array[0]); }
        static inline void set(T* array, const T& value) 
        { array[0]=value; }
        static inline bool anysmaller(const T* A, const T* B)
        { return (((*A) < (*B))); }
        static inline bool anylarger(const T* A, const T* B)
        { return (((*A) > (*B))); }
        static inline T innerproduct(const T* A, const T* B)
        { return(A[0]*B[0]); }
        static inline T strideproduct(const T* A, const T* B)
        { return(A[0]+B[0]); }
    }; // class Inline<T, 1>

  /*----------------------------------------------------------------------*/

  template<typename T1, typename T2, int I>
    class Inline2 {
      public:
        static inline void copy(const T1* source, T2* target)
        { 
          target[I-1]=source[I-1]; 
          Inline2<T1, T2, I-1>::copy(source, target); 
        }
        static inline void set(T1* array, const T2& value)
        { 
          array[I-1]=value; Inline2<T1, T2 ,I-1>::set(array, value);
        }
        static inline bool anysmaller(const T1* A, const T2* B)
        {
          return (((*A) < (*B)) 
                  || Inline2<T1, T2, I-1>::anysmaller(&(A[1]), &(B[1])));
        }
        static inline bool anylarger(const T1* A, const T2* B)
        {
          return (((*A) > (*B)) 
                  || Inline2<T1, T2,I-1>::anylarger(&(A[1]), &(B[1])));
        }
        static inline T1 innerproduct(const T1* A, const T2* B)
        {
          return(A[I-1]*B[I-1]+Inline2<T1, T2, I-1>::innerproduct(A,B));
        }
        static inline T1 strideproduct(const T1* A, const T2* B)
        {
          return((*A)+(*B)*Inline2<T1, T2, I-1>::strideproduct(&(A[1]),&(B[1])));
        }
    }; // class Inline2
  
  template<typename T1, typename T2>
    class Inline2<T1, T2, 1> {
      public:
        static inline void copy(const T1* source, T2* target) 
        { target[0]=source[0]; }
        static inline void set(T1* array, const T2& value) 
        { array[0]=value; }
        static inline bool anysmaller(const T1* A, const T2* B)
        { return (((*A) < (*B))); }
        static inline bool anylarger(const T1* A, const T2* B)
        { return (((*A) > (*B))); }
        static inline T1 innerproduct(const T1* A, const T2* B)
        { return(A[0]*B[0]); }
        static inline T1 strideproduct(const T1* A, const T2* B)
        { return(A[0]+B[0]); }
    }; // class Inline2<T1, T2, 1>

} // namespace util

} // namespace aff

#endif // AFF_RAWARFUN_H_VERSION (includeguard)

/* ----- END OF rawarfun.h ----- */