simplearray.h

Go to the documentation of this file.

// include guard
#ifndef AFF_SIMPLEARRAY_H_VERSION

#define AFF_SIMPLEARRAY_H_VERSION \
  "AFF_SIMPLEARRAY_H   V1.4"

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

using namespace aff::util;

  template<class T, Tsize N>
    class SimpleRigidArray {
      public:
        typedef T Telement;
        typedef T Tvalue;

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

        SimpleRigidArray() { }
        template<class TT>
        SimpleRigidArray(const SimpleRigidArray<TT, N>& array)
        { 
          aff::util::Inline2<TT, T, N>::copy(array.pointer(), Marray); 
        }
        explicit SimpleRigidArray(const T& value) 
        { 
          aff::util::Inline<T, N>::set(Marray, value); 
        }

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

        template<class TT>
        SimpleRigidArray& operator=(const TT& value)
        {
          aff::util::Inline2<T, TT, N>::set(Marray, value); 
          return(*this); 
        }
        template<class TT>
        SimpleRigidArray& operator=(const SimpleRigidArray<TT, N>& array)
        { 
          aff::util::Inline2<TT, T, N>::copy(array.pointer(), Marray); 
          return(*this); 
        }

        /*-----------------------------------------------------------------*/
        
        T& operator[](const Tsubscript& i) { return Marray[i]; }
        const T& operator[](const Tsubscript& i) const { return Marray[i]; }
        T* pointer() { return Marray; }
        const T* pointer() const { return Marray; }
        Tsize size() const { return N; }

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

      private:
        T Marray[N];
    }; // Simple Array

  /*======================================================================*/
  // inlined operations
   
  template<typename T, Tsize N>
    inline T inline_product(const SimpleRigidArray<T, N>& array)
    { return Inline<T, N>::product(array.pointer()); }

  template<typename T, Tsize N>
    inline T inline_sum(const SimpleRigidArray<T, N>& array)
    { return Inline<T, N>::sum(array.pointer()); }

  template<typename T, Tsize N>
    inline bool inline_anysmaller(const SimpleRigidArray<T, N>& A,
                                  const SimpleRigidArray<T, N>& B)
    { return Inline<T, N>::anysmaller(A.pointer(), B.pointer()); }

  template<typename T, Tsize N>
    inline bool inline_anylarger(const SimpleRigidArray<T, N>& A,
                                 const SimpleRigidArray<T, N>& B)
    { return Inline<T, N>::anylarger(A.pointer(), B.pointer()); }

  template<typename T1, typename T2, Tsize N>
    inline bool inline_anylarger(const SimpleRigidArray<T1, N>& A,
                                 const SimpleRigidArray<T2, N>& B)
    { return Inline2<T1, T2, N>::anylarger(A.pointer(), B.pointer()); }

  template<typename T, Tsize N>
    inline T inline_innerproduct(const SimpleRigidArray<T, N>& A,
                                 const SimpleRigidArray<T, N>& B)
    { return Inline<T, N>::innerproduct(A.pointer(), B.pointer()); }

  template<typename T1, typename T2, Tsize N>
    inline T1 inline_innerproduct(const SimpleRigidArray<T1, N>& A,
                                  const SimpleRigidArray<T2, N>& B)
    { return Inline2<T1, T2, N>::innerproduct(A.pointer(), B.pointer()); }

  template<typename T, Tsize N>
    inline T inline_strideproduct(const SimpleRigidArray<T, N>& A,
                                  const SimpleRigidArray<T, N>& B)
    { return Inline<T, N>::strideproduct(A.pointer(), B.pointer()); }

} // namespace aff

#endif // AFF_SIMPLEARRAY_H_VERSION (includeguard)

/* ----- END OF simplearray.h ----- */