vector.h

/*  This file is part of the Vc library. {{{
Copyright © 2015 Matthias Kretz <kretz@kde.org>
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the names of contributing organizations nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
}}}*/
 
#ifndef VC_COMMON_VECTOR_H_
#define VC_COMMON_VECTOR_H_
 
#include <ratio>
#include "elementreference.h"
#include "types.h"
#include "vectorabi.h"
#include "vectortraits.h"
#include "simdarrayfwd.h"
#include "loadstoreflags.h"
#include "writemaskedvector.h"
#include "detail.h"
 
namespace Vc_VERSIONED_NAMESPACE
{
template <typename T, typename Abi,
          typename = enable_if<std::is_floating_point<T>::value &&
                               !detail::is_fixed_size_abi<Abi>::value>>
inline Vector<T, Abi> copysign(Vector<T, Abi> magnitude, Vector<T, Abi> sign);
 
template <typename T, typename Abi,
          typename = enable_if<std::is_floating_point<T>::value &&
                               !detail::is_fixed_size_abi<Abi>::value>>
inline Vector<T, Abi> exponent(Vector<T, Abi> x);
 
template <typename T, typename Abi>
Vc_INTRINSIC Vc_CONST typename Vector<T, detail::not_fixed_size_abi<Abi>>::MaskType
isnegative(Vector<T, Abi> x)
{
    return x < Vector<T, Abi>::Zero();
}
 
template<typename T, typename Abi = VectorAbi::Best<T>> class Vector
{
public:
    static constexpr size_t size() { return VectorTraits<T, Abi>::size(); }
 
    static constexpr size_t MemoryAlignment = VectorTraits<T, Abi>::memoryAlignment();
 
    using abi = Abi;
 
    using EntryType = typename VectorTraits<T, Abi>::EntryType;
    using value_type = EntryType;
 
    using VectorEntryType = typename VectorTraits<T, Abi>::VectorEntryType;
    using VectorType = typename VectorTraits<T, Abi>::VectorType;
    using vector_type = VectorType;
 
    using MaskType = Vc::Mask<T, Abi>;
    using mask_type = MaskType;
 
    using MaskArgument = MaskType;
    using VectorArgument = Vector;
 
    using IndexType = Vc::fixed_size_simd<int, VectorTraits<T, Abi>::size()>;
    using index_type = IndexType;
 
    using reference = Detail::ElementReference<Vector>;
 
 
    static inline Vector Zero();
 
    static inline Vector One();
 
    static inline Vector IndexesFromZero();
 
    static inline Vector Random();
 
    template <typename G> static inline Vector generate(G gen);
 
 
    inline Vector() = default;
 
    explicit inline Vector(VectorSpecialInitializerZero);
 
    explicit inline Vector(VectorSpecialInitializerOne);
 
    explicit inline Vector(VectorSpecialInitializerIndexesFromZero);
 
 
    template <typename U>
    inline Vector(Vector<U, abi> x,
                  enable_if<Traits::is_implicit_cast_allowed<U, T>::value> = nullarg);
 
#if Vc_IS_VERSION_1
    template <typename U>
    Vc_DEPRECATED("use simd_cast instead of explicit type casting to convert between "
                  "vector types") inline explicit Vector(
        Vector<U, abi> x,
        enable_if<!Traits::is_implicit_cast_allowed<U, T>::value> = nullarg);
#endif
 
    inline Vector(EntryType a);
    template <typename U>
    inline Vector(U a, enable_if<std::is_same<U, int>::value &&
                                 !std::is_same<U, EntryType>::value> = nullarg);
    inline explicit Vector(reference a);
 
#include "../common/loadinterface.h"
#include "../common/storeinterface.h"
 
    inline void setZero();
 
    inline void setZero(MaskType mask);
 
    inline void setZeroInverted(MaskType mask);
 
    inline void setQnan();
 
    inline void setQnan(MaskType mask);
 
#define Vc_CURRENT_CLASS_NAME Vector
#include "../common/gatherinterface.h"
#include "../common/scatterinterface.h"
#undef Vc_CURRENT_CLASS_NAME
 
 
    inline reference operator[](size_t index) noexcept;
    inline EntryType operator[](size_t index) const noexcept;
 
 
    inline MaskType operator!() const;
 
    inline Vector operator~() const;
 
    inline Vector operator-() const;
    inline Vector operator+() const;
 
    inline Vector &operator++();  // prefix
    inline Vector operator++(int);  // postfix
    inline Vector &operator--();  // prefix
    inline Vector operator--(int);  // postfix
 
#define Vc_OP(symbol)                                                                    \
    inline Vc_PURE Vector operator symbol(const Vector &x) const;
    Vc_ALL_ARITHMETICS(Vc_OP);
 
    Vc_ALL_BINARY(Vc_OP);
 
    Vc_ALL_SHIFTS(Vc_OP);
#undef Vc_OP
 
#define Vc_CMP_OP(symbol) inline Vc_PURE MaskType operator symbol(const Vector &x) const;
    Vc_ALL_COMPARES(Vc_CMP_OP);
#undef Vc_CMP_OP
 
    inline Common::WriteMaskedVector<Vector, MaskType> operator()(MaskType mask);
 
 
    inline EntryType min() const;
    inline EntryType max() const;
    inline EntryType product() const;
    inline EntryType sum() const;
    inline Vector partialSum() const;
    inline EntryType min(MaskType mask) const;
    inline EntryType max(MaskType mask) const;
    inline EntryType product(MaskType mask) const;
    inline EntryType sum(MaskType mask) const;
 
 
    inline Vector shifted(int amount) const;
    inline Vector shifted(int amount, Vector shiftIn) const;
    inline Vector rotated(int amount) const;
    inline Vector reversed() const;
 
    inline Vector sorted() const;
 
 
    template <typename F> void callWithValuesSorted(F &&f);
    template <typename F> inline void call(F &&f) const;
    template <typename F> inline void call(F &&f, MaskType mask) const;
 
    template <typename F> inline Vector apply(F &&f) const;
    template <typename F> inline Vector apply(F &&f, MaskType mask) const;
 
    template <typename IndexT> inline void fill(EntryType(&f)(IndexT));
    inline void fill(EntryType(&f)());
 
    inline Vector interleaveLow(Vector x) const;
    inline Vector interleaveHigh(Vector x) const;
 
    inline void assign(const Vector &v, const MaskType &m);
 
    inline VectorType &data();
    inline const VectorType &data() const;
 
 
    Vc_DEPRECATED("use exponent(x) instead") inline Vector exponent() const;
 
    Vc_DEPRECATED("use isnegative(x) instead") inline MaskType isNegative() const;
 
    static constexpr size_t Size = VectorTraits<T, Abi>::size();
 
    template <typename V2> inline V2 staticCast() const;
 
    template <typename V2>
    Vc_DEPRECATED("use reinterpret_components_cast instead") inline V2
        reinterpretCast() const;
 
    Vc_DEPRECATED("use copysign(x, y) instead") inline Vector
        copySign(Vector reference) const;
 
    Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(Vector));
 
private:
    VectorType d;
};
 
template <typename V, typename T, typename Abi>
Vc_ALWAYS_INLINE Vc_CONST enable_if<
    (V::size() == Vector<T, Abi>::size() &&
     sizeof(typename V::VectorEntryType) ==
         sizeof(typename Vector<T, Abi>::VectorEntryType) &&
     sizeof(V) == sizeof(Vector<T, Abi>) && alignof(V) <= alignof(Vector<T, Abi>)),
    V>
reinterpret_components_cast(const Vector<T, Abi> &x)
{
    return reinterpret_cast<const V &>(x);
}
 
#define Vc_OP(symbol)                                                                    \
    template <typename T, typename Abi>                                                  \
    inline Vector<T, Abi> &operator symbol##=(Vector<T, Abi> &,                          \
                                              const Vector<T, Abi> &x);
    //Vc_ALL_ARITHMETICS(Vc_OP);
    //Vc_ALL_BINARY(Vc_OP);
    //Vc_ALL_SHIFTS(Vc_OP);
#undef Vc_OP
 
}  // namespace Vc
 
#endif  // VC_COMMON_VECTOR_H_
 
// vim: foldmethod=marker