// This file is part of the ustl library, an STL implementation.
//
// Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net>
// This file is free software, distributed under the MIT License.
//
// utuple.h
//
#ifndef UTUPLE_H_7324ADEC49B397CA74A56F6050FD5A6B
#define UTUPLE_H_7324ADEC49B397CA74A56F6050FD5A6B
#include "ualgo.h"
#if PLATFORM_ANDROID
#undef CPU_HAS_MMX
#endif
namespace ustl {
/// \class tuple utuple.h ustl.h
/// \ingroup Sequences
///
/// \brief A fixed-size array of \p N \p Ts.
///
template <size_t N, typename T>
class tuple {
public:
typedef T value_type;
typedef size_t size_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef pointer iterator;
typedef const_pointer const_iterator;
typedef ::ustl::reverse_iterator<iterator> reverse_iterator;
typedef ::ustl::reverse_iterator<const_iterator> const_reverse_iterator;
typedef pair<iterator,iterator> range_t;
typedef pair<const_iterator,const_iterator> const_range_t;
public:
template <typename T2>
inline tuple (const tuple<N,T2>& t);
inline tuple (const tuple<N,T>& t);
inline tuple (const_pointer v);
inline tuple (void) { for (uoff_t i = 0; i < N; ++ i) m_v[i] = T(); }
explicit inline tuple (const_reference v0, const_reference v1 = T(), const_reference v2 = T(), const_reference v3 = T());
inline iterator begin (void) { return (m_v); }
inline const_iterator begin (void) const { return (m_v); }
inline iterator end (void) { return (begin() + N); }
inline const_iterator end (void) const { return (begin() + N); }
inline size_type size (void) const { return (N); }
inline size_type max_size (void) const { return (N); }
inline bool empty (void) const { return (N == 0); }
inline const_reference at (size_type i) const { return (m_v[i]); }
inline reference at (size_type i) { return (m_v[i]); }
inline const_reference operator[] (size_type i) const { return (m_v[i]); }
inline reference operator[] (size_type i) { return (m_v[i]); }
template <typename T2>
inline const tuple& operator= (const tuple<N,T2>& src);
inline const tuple& operator= (const tuple<N,T>& src);
inline const tuple& operator+= (const_reference v)
{ for (uoff_t i = 0; i < N; ++ i) m_v[i] += v; return (*this); }
inline const tuple& operator-= (const_reference v)
{ for (uoff_t i = 0; i < N; ++ i) m_v[i] -= v; return (*this); }
inline const tuple& operator*= (const_reference v)
{ for (uoff_t i = 0; i < N; ++ i) m_v[i] *= v; return (*this); }
inline const tuple& operator/= (const_reference v)
{ for (uoff_t i = 0; i < N; ++ i) m_v[i] /= v; return (*this); }
inline const tuple operator+ (const_reference v) const
{ tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] + v; return (result); }
inline const tuple operator- (const_reference v) const
{ tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] - v; return (result); }
inline const tuple operator* (const_reference v) const
{ tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] * v; return (result); }
inline const tuple operator/ (const_reference v) const
{ tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] / v; return (result); }
inline void swap (tuple<N,T>& v)
{ for (uoff_t i = 0; i < N; ++ i) ::ustl::swap (m_v[i], v.m_v[i]); }
private:
T m_v [N];
};
} // namespace ustl
#include "simd.h"
namespace ustl {
template <size_t N, typename T>
template <typename T2>
inline tuple<N,T>::tuple (const tuple<N,T2>& t)
{ simd::pconvert (t, *this, simd::fcast<T2,T>()); }
template <size_t N, typename T>
inline tuple<N,T>::tuple (const tuple<N,T>& t)
{ simd::passign (t, *this); }
template <size_t N, typename T>
inline tuple<N,T>::tuple (const_pointer v)
{ simd::ipassign (v, *this); }
template <size_t N, typename T>
inline tuple<N,T>::tuple (const_reference v0, const_reference v1, const_reference v2, const_reference v3)
{
m_v[0] = v0;
if (N > 1) m_v[1] = v1;
if (N > 2) m_v[2] = v2;
if (N > 3) m_v[3] = v3;
if (N > 4) fill_n (m_v + 4, N - 4, T());
}
template <size_t N, typename T>
template <typename T2>
inline const tuple<N,T>& tuple<N,T>::operator= (const tuple<N,T2>& src)
{ simd::pconvert (src, *this, simd::fcast<T2,T>()); return (*this); }
template <size_t N, typename T>
inline const tuple<N,T>& tuple<N,T>::operator= (const tuple<N,T>& src)
{ simd::passign (src, *this); return (*this); }
template <size_t N, typename T1, typename T2>
inline bool operator== (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
{
for (uoff_t i = 0; i < N; ++ i)
if (t1[i] != t2[i])
return (false);
return (true);
}
template <size_t N, typename T1, typename T2>
inline bool operator< (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
{
for (uoff_t i = 0; i < N && t1[i] <= t2[i]; ++ i)
if (t1[i] < t2[i])
return (true);
return (false);
}
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1>& operator+= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
{ for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] + t2[i]); return (t1); }
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1>& operator-= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
{ for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] - t2[i]); return (t1); }
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1>& operator*= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
{ for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] * t2[i]); return (t1); }
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1>& operator/= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
{ for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] / t2[i]); return (t1); }
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1> operator+ (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
{
tuple<N,T1> result;
for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] + t2[i]);
return (result);
}
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1> operator- (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
{
tuple<N,T1> result;
for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] - t2[i]);
return (result);
}
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1> operator* (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
{
tuple<N,T1> result;
for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] * t2[i]);
return (result);
}
template <size_t N, typename T1, typename T2>
inline const tuple<N,T1> operator/ (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
{
tuple<N,T1> result;
for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] / t2[i]);
return (result);
}
#if CPU_HAS_SSE
#define SSE_TUPLE_SPECS(n,type) \
template <> inline tuple<n,type>::tuple (void) \
{ asm ("xorps %%xmm0, %%xmm0\n\tmovups %%xmm0, %0"::"m"(m_v[0]):"xmm0","memory"); } \
template<> inline void tuple<n,type>::swap (tuple<n,type>& v) \
{ asm ("movups %0,%%xmm0\n\tmovups %1,%%xmm1\n\tmovups %%xmm0,%1\n\tmovups %%xmm1,%0"::"m"(m_v[0]),"m"(v.m_v[0]):"xmm0","xmm1","memory"); }
SSE_TUPLE_SPECS(4,float)
SSE_TUPLE_SPECS(4,int32_t)
SSE_TUPLE_SPECS(4,uint32_t)
#undef SSE_TUPLE_SPECS
#endif
#if CPU_HAS_MMX
#define MMX_TUPLE_SPECS(n,type) \
template <> inline tuple<n,type>::tuple (void) \
{ asm ("pxor %%mm0, %%mm0\n\tmovq %%mm0, %0"::"m"(m_v[0]):"mm0","memory"); simd::reset_mmx(); } \
template<> inline void tuple<n,type>::swap (tuple<n,type>& v) \
{ asm ("movq %0,%%mm0\n\tmovq %1,%%mm1\n\tmovq %%mm0,%1\n\tmovq %%mm1,%0"::"m"(m_v[0]),"m"(v.m_v[0]):"mm0","mm1","memory"); simd::reset_mmx(); }
MMX_TUPLE_SPECS(2,float)
MMX_TUPLE_SPECS(4,int16_t)
MMX_TUPLE_SPECS(4,uint16_t)
MMX_TUPLE_SPECS(2,int32_t)
MMX_TUPLE_SPECS(2,uint32_t)
MMX_TUPLE_SPECS(8,int8_t)
MMX_TUPLE_SPECS(8,uint8_t)
#undef MMX_TUPLE_SPECS
#endif
#define SIMD_TUPLE_PACKOP(N,T) \
template <> inline const tuple<N,T>& operator+= (tuple<N,T>& t1, const tuple<N,T>& t2) \
{ simd::padd (t2, t1); return (t1); } \
template <> inline const tuple<N,T>& operator-= (tuple<N,T>& t1, const tuple<N,T>& t2) \
{ simd::psub (t2, t1); return (t1); } \
template <> inline const tuple<N,T>& operator*= (tuple<N,T>& t1, const tuple<N,T>& t2) \
{ simd::pmul (t2, t1); return (t1); } \
template <> inline const tuple<N,T>& operator/= (tuple<N,T>& t1, const tuple<N,T>& t2) \
{ simd::pdiv (t2, t1); return (t1); } \
template <> inline const tuple<N,T> operator+ (const tuple<N,T>& t1, const tuple<N,T>& t2) \
{ tuple<N,T> result (t1); simd::padd (t2, result); return (result); } \
template <> inline const tuple<N,T> operator- (const tuple<N,T>& t1, const tuple<N,T>& t2) \
{ tuple<N,T> result (t1); simd::psub (t2, result); return (result); } \
template <> inline const tuple<N,T> operator* (const tuple<N,T>& t1, const tuple<N,T>& t2) \
{ tuple<N,T> result (t1); simd::pmul (t2, result); return (result); } \
template <> inline const tuple<N,T> operator/ (const tuple<N,T>& t1, const tuple<N,T>& t2) \
{ tuple<N,T> result (t1); simd::pdiv (t2, result); return (result); }
SIMD_TUPLE_PACKOP(4,float)
SIMD_TUPLE_PACKOP(2,float)
SIMD_TUPLE_PACKOP(2,double)
SIMD_TUPLE_PACKOP(4,int32_t)
SIMD_TUPLE_PACKOP(4,uint32_t)
SIMD_TUPLE_PACKOP(4,int16_t)
SIMD_TUPLE_PACKOP(4,uint16_t)
SIMD_TUPLE_PACKOP(2,int32_t)
SIMD_TUPLE_PACKOP(2,uint32_t)
SIMD_TUPLE_PACKOP(8,int8_t)
SIMD_TUPLE_PACKOP(8,uint8_t)
#undef SIMD_TUPLE_PACKOP
} // namespace ustl
#endif