// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_CXX11_TENSOR_TENSOR_META_H
#define EIGEN_CXX11_TENSOR_TENSOR_META_H

namespace Eigen {

template<bool cond> struct Cond {};

template<typename T1, typename T2> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
const T1&
choose(Cond<true>, const T1& first, const T2&)
{
    return first;
}

template<typename T1, typename T2> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
const T2&
choose(Cond<false>, const T1&, const T2& second)
{
    return second;
}


template <typename T, typename X, typename Y>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
T
divup(const X x, const Y y)
{
    return static_cast<T>((x + y - 1) / y);
}

template <typename T>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
T
divup(const T x, const T y)
{
    return static_cast<T>((x + y - 1) / y);
}

template <size_t n> struct max_n_1
{
    static const size_t size = n;
};
template <> struct max_n_1<0>
{
    static const size_t size = 1;
};


// Default packet types
template <typename Scalar, typename Device>
struct PacketType : internal::packet_traits<Scalar>
{
    typedef typename internal::packet_traits<Scalar>::type type;
};

// For CUDA packet types when using a GpuDevice
#if defined(EIGEN_USE_GPU) && defined(__CUDACC__) && defined(EIGEN_HAS_CUDA_FP16)
template <>
struct PacketType<half, GpuDevice>
{
    typedef half2 type;
    static const int size = 2;
    enum
    {
        HasAdd    = 1,
        HasSub    = 1,
        HasMul    = 1,
        HasNegate = 1,
        HasAbs    = 1,
        HasArg    = 0,
        HasAbs2   = 0,
        HasMin    = 1,
        HasMax    = 1,
        HasConj   = 0,
        HasSetLinear = 0,
        HasBlend  = 0,

        HasDiv    = 1,
        HasSqrt   = 1,
        HasRsqrt  = 1,
        HasExp    = 1,
        HasLog    = 1,
        HasLog1p  = 0,
        HasLog10  = 0,
        HasPow    = 1,
    };
};
#endif

#if defined(EIGEN_USE_SYCL)
template <typename T>
struct PacketType<T, SyclDevice>
{
    typedef T type;
    static const int size = 1;
    enum
    {
        HasAdd    = 0,
        HasSub    = 0,
        HasMul    = 0,
        HasNegate = 0,
        HasAbs    = 0,
        HasArg    = 0,
        HasAbs2   = 0,
        HasMin    = 0,
        HasMax    = 0,
        HasConj   = 0,
        HasSetLinear = 0,
        HasBlend  = 0
    };
};
#endif


// Tuple mimics std::pair but works on e.g. nvcc.
template <typename U, typename V> struct Tuple
{
  public:
    U first;
    V second;

    typedef U first_type;
    typedef V second_type;

    EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    Tuple() : first(), second() {}

    EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    Tuple(const U& f, const V& s) : first(f), second(s) {}

    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    Tuple&
    operator= (const Tuple& rhs)
    {
        if (&rhs == this)
        {
            return *this;
        }

        first = rhs.first;
        second = rhs.second;
        return *this;
    }

    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    void
    swap(Tuple& rhs)
    {
        using numext::swap;
        swap(first, rhs.first);
        swap(second, rhs.second);
    }
};

template <typename U, typename V>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool
operator==(const Tuple<U, V>& x, const Tuple<U, V>& y)
{
    return (x.first == y.first && x.second == y.second);
}

template <typename U, typename V>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool
operator!=(const Tuple<U, V>& x, const Tuple<U, V>& y)
{
    return !(x == y);
}


// Can't use std::pairs on cuda devices
template <typename Idx> struct IndexPair
{
    EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
    IndexPair() : first(0), second(0) {}
    EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
    IndexPair(Idx f, Idx s) : first(f), second(s) {}

    EIGEN_DEVICE_FUNC void
    set(IndexPair<Idx> val)
    {
        first = val.first;
        second = val.second;
    }

    Idx first;
    Idx second;
};


#ifdef EIGEN_HAS_SFINAE
namespace internal {

template<typename IndexType, Index... Is>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
array<Index, sizeof...(Is)>
customIndices2Array(IndexType& idx, numeric_list<Index, Is...>)
{
    return { idx[Is]... };
}
template<typename IndexType>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
array<Index, 0>
customIndices2Array(IndexType&, numeric_list<Index>)
{
    return array<Index, 0>();
}

/** Make an array (for index/dimensions) out of a custom index */
template<typename Index, std::size_t NumIndices, typename IndexType>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
array<Index, NumIndices>
customIndices2Array(IndexType& idx)
{
    return customIndices2Array(idx, typename gen_numeric_list<Index, NumIndices>::type{});
}


template <typename B, typename D>
struct is_base_of
{

    typedef
    char (&yes)[1];
    typedef
    char (&no)[2];

    template <typename BB, typename DD>
    struct Host
    {
        operator BB*() const;
        operator DD*();
    };

    template<typename T>
    static yes
    check(D*, T);
    static no
    check(B*, int);

    static const bool value = sizeof(check(Host<B,D>(), int())) == sizeof(yes);
};

}
#endif



}  // namespace Eigen

#endif  // EIGEN_CXX11_TENSOR_TENSOR_META_H
