utuple.h

   1 // This file is part of the ustl library, an STL implementation.
   2 //
   3 // Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net>
   4 // This file is free software, distributed under the MIT License.
   5 //
   6 // utuple.h
   7 //
   8
   9 #ifndef UTUPLE_H_7324ADEC49B397CA74A56F6050FD5A6B
  10 #define UTUPLE_H_7324ADEC49B397CA74A56F6050FD5A6B
  11
  12 #include "ualgo.h"
  13 #include "metamac.h"
  14
  15 namespace ustl {
  16
  17 /// \class tuple utuple.h ustl.h
  18 /// \ingroup Sequences
  19 ///
  20 /// \brief A fixed-size array of \p N \p Ts.
  21 ///
  22 template <size_t N, typename T>
  23 class tuple {
  24 public:
  25     typedef T                                           value_type;
  26     typedef size_t                                      size_type;
  27     typedef value_type*                                 pointer;
  28     typedef const value_type*                           const_pointer;
  29     typedef value_type&                                 reference;
  30     typedef const value_type&                           const_reference;
  31     typedef pointer                                     iterator;
  32     typedef const_pointer                               const_iterator;
  33     typedef ::ustl::reverse_iterator<iterator>          reverse_iterator;
  34     typedef ::ustl::reverse_iterator<const_iterator>    const_reverse_iterator;
  35     typedef pair<iterator,iterator>                     range_t;
  36     typedef pair<const_iterator,const_iterator>         const_range_t;
  37 public:
  38     template <typename T2>
  39     inline                      tuple (const tuple<N,T2>& t);
  40     inline                      tuple (const tuple<N,T>& t);
  41     inline                      tuple (const_pointer v);
  42     inline                      tuple (void);
  43     explicit inline             tuple (const_reference v0, const_reference v1 = T(), const_reference v2 = T(), const_reference v3 = T());
  44     inline iterator             begin (void)                    { return (m_v); }
  45     inline const_iterator       begin (void) const              { return (m_v); }
  46     inline iterator             end (void)                      { return (begin() + N); }
  47     inline const_iterator       end (void) const                { return (begin() + N); }
  48     inline size_type            size (void) const               { return (N); }
  49     inline size_type            max_size (void) const           { return (N); }
  50     inline bool                 empty (void) const              { return (N == 0); }
  51     inline const_reference      at (size_type i) const          { return (m_v[i]); }
  52     inline reference            at (size_type i)                { return (m_v[i]); }
  53     inline const_reference      operator[] (size_type i) const  { return (m_v[i]); }
  54     inline reference            operator[] (size_type i)        { return (m_v[i]); }
  55     template <typename T2>
  56     inline const tuple&         operator= (const tuple<N,T2>& src);
  57     inline const tuple&         operator= (const tuple<N,T>& src);
  58     inline const tuple&         operator+= (const_reference v)
  59                                     { for (uoff_t i = 0; i < N; ++ i) m_v[i] += v; return (*this); }
  60     inline const tuple&         operator-= (const_reference v)
  61                                     { for (uoff_t i = 0; i < N; ++ i) m_v[i] -= v; return (*this); }
  62     inline const tuple&         operator*= (const_reference v)
  63                                     { for (uoff_t i = 0; i < N; ++ i) m_v[i] *= v; return (*this); }
  64     inline const tuple&         operator/= (const_reference v)
  65                                     { for (uoff_t i = 0; i < N; ++ i) m_v[i] /= v; return (*this); }
  66     inline const tuple          operator+ (const_reference v) const
  67                                     { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] + v; return (result); }
  68     inline const tuple          operator- (const_reference v) const
  69                                     { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] - v; return (result); }
  70     inline const tuple          operator* (const_reference v) const
  71                                     { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] * v; return (result); }
  72     inline const tuple          operator/ (const_reference v) const
  73                                     { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] / v; return (result); }
  74     inline void                 swap (tuple<N,T>& v)
  75                                     { for (uoff_t i = 0; i < N; ++ i) ::ustl::swap (m_v[i], v.m_v[i]); }
  76     inline void                 read (istream& is)                      { nr_container_read (is, *this); }
  77     inline void                 write (ostream& os) const               { nr_container_write (os, *this); }
  78     inline void                 text_write (ostringstream& os) const    { container_text_write (os, *this); }
  79     inline size_t               stream_size (void) const                { return (nr_container_stream_size (*this)); }
  80 private:
  81     T                           m_v [N];
  82 };
  83
  84 } // namespace ustl
  85
  86 #include "simd.h"
  87
  88 namespace ustl {
  89
  90 template <size_t N, typename T>
  91 template <typename T2>
  92 inline tuple<N,T>::tuple (const tuple<N,T2>& t)
  93 { simd::pconvert (t, *this, simd::fcast<T2,T>()); }
  94
  95 template <size_t N, typename T>
  96 inline tuple<N,T>::tuple (const tuple<N,T>& t)
  97 { simd::passign (t, *this); }
  98
  99 template <size_t N, typename T>
 100 inline tuple<N,T>::tuple (const_pointer v)
 101 { simd::ipassign (v, *this); }
 102
 103 template <size_t N, typename T>
 104 inline tuple<N,T>::tuple (void)
 105 {
 106     const T v = T();
 107     if (N > 4 || !numeric_limits<T>::is_integral)
 108         fill_n (m_v, N, v);
 109     else {
 110         m_v[0] = v;
 111         if (N > 1) m_v[1] = v;
 112         if (N > 2) m_v[2] = v;
 113         if (N > 3) m_v[3] = v;
 114     }
 115 }
 116
 117 template <size_t N, typename T>
 118 inline tuple<N,T>::tuple (const_reference v0, const_reference v1, const_reference v2, const_reference v3)
 119 {
 120     m_v[0] = v0;
 121     if (N > 1) m_v[1] = v1;
 122     if (N > 2) m_v[2] = v2;
 123     if (N > 3) m_v[3] = v3;
 124     if (N > 4) fill_n (m_v + 4, N - 4, T());
 125 }
 126
 127 template <size_t N, typename T>
 128 template <typename T2>
 129 inline const tuple<N,T>& tuple<N,T>::operator= (const tuple<N,T2>& src)
 130 { simd::pconvert (src, *this, simd::fcast<T2,T>()); return (*this); }
 131
 132 template <size_t N, typename T>
 133 inline const tuple<N,T>& tuple<N,T>::operator= (const tuple<N,T>& src)
 134 { simd::passign (src, *this); return (*this); }
 135
 136 template <size_t N, typename T1, typename T2>
 137 inline bool operator== (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
 138 {
 139     for (uoff_t i = 0; i < N; ++ i)
 140         if (t1[i] != t2[i])
 141             return (false);
 142     return (true);
 143 }
 144
 145 template <size_t N, typename T1, typename T2>
 146 inline bool operator< (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
 147 {
 148     for (uoff_t i = 0; i < N && t1[i] <= t2[i]; ++ i)
 149         if (t1[i] < t2[i])
 150             return (true);
 151     return (false);
 152 }
 153
 154 template <size_t N, typename T1, typename T2>
 155 inline const tuple<N,T1>& operator+= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
 156     { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] + t2[i]); return (t1); }
 157
 158 template <size_t N, typename T1, typename T2>
 159 inline const tuple<N,T1>& operator-= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
 160     { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] - t2[i]); return (t1); }
 161
 162 template <size_t N, typename T1, typename T2>
 163 inline const tuple<N,T1>& operator*= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
 164     { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] * t2[i]); return (t1); }
 165
 166 template <size_t N, typename T1, typename T2>
 167 inline const tuple<N,T1>& operator/= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
 168     { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] / t2[i]); return (t1); }
 169
 170 template <size_t N, typename T1, typename T2>
 171 inline const tuple<N,T1> operator+ (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
 172 {
 173     tuple<N,T1> result;
 174     for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] + t2[i]);
 175     return (result);
 176 }
 177
 178 template <size_t N, typename T1, typename T2>
 179 inline const tuple<N,T1> operator- (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
 180 {
 181     tuple<N,T1> result;
 182     for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] - t2[i]);
 183     return (result);
 184 }
 185
 186 template <size_t N, typename T1, typename T2>
 187 inline const tuple<N,T1> operator* (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
 188 {
 189     tuple<N,T1> result;
 190     for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] * t2[i]);
 191     return (result);
 192 }
 193
 194 template <size_t N, typename T1, typename T2>
 195 inline const tuple<N,T1> operator/ (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
 196 {
 197     tuple<N,T1> result;
 198     for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] / t2[i]);
 199     return (result);
 200 }
 201
 202 //----------------------------------------------------------------------
 203 // Define SIMD specializations for member functions.
 204
 205 #if CPU_HAS_SSE
 206 #define SSE_TUPLE_SPECS(n,type)                                                 \
 207 template <> inline tuple<n,type>::tuple (void)                                  \
 208 { asm("xorps %%xmm0, %%xmm0\n\tmovups %%xmm0, %0":"+m"(m_v[0])::"xmm0","memory"); } \
 209 template<> inline void tuple<n,type>::swap (tuple<n,type>& v)                   \
 210 {                                                                               \
 211     asm ("movups %0,%%xmm0\n\tmovups %1,%%xmm1\n\t"                             \
 212         "movups %%xmm0,%1\n\tmovups %%xmm1,%0"                                  \
 213         : "+m"(m_v[0]), "+m"(v.m_v[0]) :: "xmm0","xmm1","memory");              \
 214 }
 215 SSE_TUPLE_SPECS(4,float)
 216 SSE_TUPLE_SPECS(4,int32_t)
 217 SSE_TUPLE_SPECS(4,uint32_t)
 218 #undef SSE_TUPLE_SPECS
 219 #endif
 220 #if SIZE_OF_LONG == 8 && __GNUC__
 221 #define LONG_TUPLE_SPECS(n,type)                \
 222 template <> inline tuple<n,type>::tuple (void)  \
 223 { asm("":"+m"(m_v[0])::"memory");               \
 224   *noalias_cast<long*>(m_v) = 0; }                              \
 225 template<> inline void tuple<n,type>::swap (tuple<n,type>& v)   \
 226 { asm("":"+m"(m_v[0]),"+m"(v.m_v[0])::"memory");                        \
 227   iter_swap (noalias_cast<long*>(m_v), noalias_cast<long*>(v.m_v));     \
 228   asm("":"+m"(m_v[0]),"+m"(v.m_v[0])::"memory");                        \
 229 }
 230 LONG_TUPLE_SPECS(2,float)
 231 LONG_TUPLE_SPECS(4,int16_t)
 232 LONG_TUPLE_SPECS(4,uint16_t)
 233 LONG_TUPLE_SPECS(2,int32_t)
 234 LONG_TUPLE_SPECS(2,uint32_t)
 235 LONG_TUPLE_SPECS(8,int8_t)
 236 LONG_TUPLE_SPECS(8,uint8_t)
 237 #undef LONG_TUPLE_SPECS
 238 #elif CPU_HAS_MMX
 239 #define MMX_TUPLE_SPECS(n,type)         \
 240 template <> inline tuple<n,type>::tuple (void)  \
 241 {  asm ("pxor %%mm0, %%mm0\n\tmovq %%mm0, %0"   \
 242         :"+m"(m_v[0])::"mm0","st","memory"); simd::reset_mmx(); }       \
 243 template<> inline void tuple<n,type>::swap (tuple<n,type>& v)           \
 244 {  asm ("movq %0,%%mm0\n\tmovq %1,%%mm1\n\t"                            \
 245         "movq %%mm0,%1\n\tmovq %%mm1,%0"                                \
 246         :"+m"(m_v[0]),"+m"(v.m_v[0])::"mm0","mm1","st","st(1)","memory"); \
 247    simd::reset_mmx();                                                   \
 248 }
 249 MMX_TUPLE_SPECS(2,float)
 250 MMX_TUPLE_SPECS(4,int16_t)
 251 MMX_TUPLE_SPECS(4,uint16_t)
 252 MMX_TUPLE_SPECS(2,int32_t)
 253 MMX_TUPLE_SPECS(2,uint32_t)
 254 MMX_TUPLE_SPECS(8,int8_t)
 255 MMX_TUPLE_SPECS(8,uint8_t)
 256 #undef MMX_TUPLE_SPECS
 257 #endif
 258
 259 #if __i386__ || __x86_64__
 260 #define UINT32_TUPLE_SPECS(type,otype)          \
 261 template <> inline tuple<2,type>::tuple (void)  \
 262 { asm("":"+m"(m_v[0]),"+m"(m_v[1])::"memory");  \
 263   *noalias_cast<uint32_t*>(m_v) = 0;            \
 264   asm("":"+m"(m_v[0]),"+m"(m_v[1])::"memory"); }\
 265 template <> inline const tuple<2,type>& tuple<2,type>::operator= (const tuple<2,type>& v)\
 266 { asm ("mov %3, %0"                                                     \
 267        :"=m"(*noalias_cast<uint32_t*>(m_v)),"=m"(m_v[0]),"=m"(m_v[1])   \
 268        :"r"(*noalias_cast<const uint32_t*>(v.begin())),"m"(v[0]),"m"(v[1]):"memory");   \
 269   return (*this); }                                                     \
 270 template <> template <>                                                 \
 271 inline const tuple<2,type>& tuple<2,type>::operator= (const tuple<2,otype>& v)\
 272 { asm ("mov %3, %0"                                                     \
 273        :"=m"(*noalias_cast<uint32_t*>(m_v)),"=m"(m_v[0]),"=m"(m_v[1])   \
 274        :"r"(*noalias_cast<const uint32_t*>(v.begin())),"m"(v[0]),"m"(v[1]):"memory");   \
 275   return (*this); }                                                     \
 276 template <> inline tuple<2,type>::tuple (const tuple<2,type>& v)        \
 277 { operator= (v); }                                                      \
 278 template <> template <>                                                 \
 279 inline tuple<2,type>::tuple (const tuple<2,otype>& v)                   \
 280 { operator= (v); }                                                      \
 281 template<> inline void tuple<2,type>::swap (tuple<2,type>& v)           \
 282 { asm(""::"m"(m_v[0]),"m"(m_v[1]),"m"(v.m_v[0]),"m"(v.m_v[1]):"memory");\
 283   iter_swap (noalias_cast<uint32_t*>(m_v), noalias_cast<uint32_t*>(v.m_v));                     \
 284   asm("":"=m"(m_v[0]),"=m"(m_v[1]),"=m"(v.m_v[0]),"=m"(v.m_v[1])::"memory"); }                          \
 285 template <> inline const tuple<2,type>& operator+= (tuple<2,type>& t1, const tuple<2,type>& t2) \
 286     { t1[0] += t2[0]; t1[1] += t2[1]; return (t1); }                                            \
 287 template <> inline const tuple<2,type>& operator-= (tuple<2,type>& t1, const tuple<2,type>& t2) \
 288     { t1[0] -= t2[0]; t1[1] -= t2[1]; return (t1); }                                            \
 289 template <> inline const tuple<2,type> operator+ (const tuple<2,type>& t1, const tuple<2,type>& t2) \
 290     { return (tuple<2,type> (t1[0] + t2[0], t1[1] + t2[1])); }                                  \
 291 template <> inline const tuple<2,type> operator- (const tuple<2,type>& t1, const tuple<2,type>& t2) \
 292     { return (tuple<2,type> (t1[0] - t2[0], t1[1] - t2[1])); }
 293 UINT32_TUPLE_SPECS(int16_t,uint16_t)
 294 UINT32_TUPLE_SPECS(uint16_t,int16_t)
 295 #undef UINT32_TUPLE_SPECS
 296 #endif
 297
 298 #undef TUPLEV_R1
 299 #undef TUPLEV_R2
 300 #undef TUPLEV_W1
 301 #undef TUPLEV_W2
 302
 303 #define SIMD_TUPLE_PACKOP(N,T)  \
 304 template <> inline const tuple<N,T>& operator+= (tuple<N,T>& t1, const tuple<N,T>& t2)  \
 305     { simd::padd (t2, t1); return (t1); }                                               \
 306 template <> inline const tuple<N,T>& operator-= (tuple<N,T>& t1, const tuple<N,T>& t2)  \
 307     { simd::psub (t2, t1); return (t1); }                                               \
 308 template <> inline const tuple<N,T>& operator*= (tuple<N,T>& t1, const tuple<N,T>& t2)  \
 309     { simd::pmul (t2, t1); return (t1); }                                               \
 310 template <> inline const tuple<N,T>& operator/= (tuple<N,T>& t1, const tuple<N,T>& t2)  \
 311     { simd::pdiv (t2, t1); return (t1); }                                               \
 312 template <> inline const tuple<N,T> operator+ (const tuple<N,T>& t1, const tuple<N,T>& t2) \
 313     { tuple<N,T> result (t1); simd::padd (t2, result); return (result); }               \
 314 template <> inline const tuple<N,T> operator- (const tuple<N,T>& t1, const tuple<N,T>& t2) \
 315     { tuple<N,T> result (t1); simd::psub (t2, result); return (result); }               \
 316 template <> inline const tuple<N,T> operator* (const tuple<N,T>& t1, const tuple<N,T>& t2) \
 317     { tuple<N,T> result (t1); simd::pmul (t2, result); return (result); }               \
 318 template <> inline const tuple<N,T> operator/ (const tuple<N,T>& t1, const tuple<N,T>& t2) \
 319     { tuple<N,T> result (t1); simd::pdiv (t2, result); return (result); }
 320 SIMD_TUPLE_PACKOP(4,float)
 321 SIMD_TUPLE_PACKOP(2,float)
 322 SIMD_TUPLE_PACKOP(2,double)
 323 SIMD_TUPLE_PACKOP(4,int32_t)
 324 SIMD_TUPLE_PACKOP(4,uint32_t)
 325 SIMD_TUPLE_PACKOP(4,int16_t)
 326 SIMD_TUPLE_PACKOP(4,uint16_t)
 327 SIMD_TUPLE_PACKOP(2,int32_t)
 328 SIMD_TUPLE_PACKOP(2,uint32_t)
 329 SIMD_TUPLE_PACKOP(8,int8_t)
 330 SIMD_TUPLE_PACKOP(8,uint8_t)
 331 #undef SIMD_TUPLE_PACKOP
 332
 333 } // namespace ustl
 334
 335 #endif
 336