chromium/third_party/eigen3/src/unsupported/Eigen/CXX11/src/Tensor/TensorMeta.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2015 Benoit Steiner <[email protected]>
//
// 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

// IWYU pragma: private
#include "./InternalHeaderCheck.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&) { … }

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

template <size_t n>
struct max_n_1 { … };
template <>
struct max_n_1<0> { … };

template <typename T>
EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr T divup(const T x, const T y) { … }

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

// For CUDA packet types when using a GpuDevice
#if defined(EIGEN_USE_GPU) && defined(EIGEN_HAS_GPU_FP16) && defined(EIGEN_GPU_COMPILE_PHASE)

typedef ulonglong2 Packet4h2;
template <>
struct PacketType<half, GpuDevice> {
  typedef Packet4h2 type;
  static const int size = 8;
  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,
    HasExpm1 = 0,
    HasLog = 1,
    HasLog1p = 0,
    HasLog10 = 0,
    HasPow = 1,
  };
};
#endif

#if defined(EIGEN_USE_SYCL)

namespace TensorSycl {
namespace internal {

template <typename Index, Index A, Index B>
struct PlusOp {
  static constexpr Index Value = A + B;
};

template <typename Index, Index A, Index B>
struct DivOp {
  static constexpr Index Value = A / B;
};

template <typename Index, Index start, Index end, Index step, template <class Indx, Indx...> class StepOp>
struct static_for {
  template <typename UnaryOperator>
  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void loop(UnaryOperator op) {
    op(start);
    static_for<Index, StepOp<Index, start, step>::Value, end, step, StepOp>::loop(op);
  }
};
template <typename Index, Index end, Index step, template <class Indx, Indx...> class StepOp>
struct static_for<Index, end, end, step, StepOp> {
  template <typename UnaryOperator>
  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void loop(UnaryOperator) {}
};

template <typename OutScalar, typename Device, bool Vectorizable>
struct Vectorise {
  static constexpr int PacketSize = 1;
  typedef OutScalar PacketReturnType;
};

template <typename OutScalar, typename Device>
struct Vectorise<OutScalar, Device, true> {
  static constexpr int PacketSize = Eigen::PacketType<OutScalar, Device>::size;
  typedef typename Eigen::PacketType<OutScalar, Device>::type PacketReturnType;
};

static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index roundUp(Index x, Index y) { return ((((x) + (y)-1) / (y)) * (y)); }

}  // namespace internal
}  // namespace TensorSycl

template <>
struct PacketType<half, SyclDevice> {
  typedef half 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
  };
};
template <typename Scalar>
struct PacketType<Scalar, SyclDevice> : internal::default_packet_traits {
  typedef Scalar type;
  typedef Scalar half;
  enum {
    Vectorizable = 0,
    size = 1,
    AlignedOnScalar = 0,
  };
  enum {
    HasAdd = 0,
    HasSub = 0,
    HasMul = 0,
    HasNegate = 0,
    HasAbs = 0,
    HasAbs2 = 0,
    HasMin = 0,
    HasMax = 0,
    HasConj = 0,
    HasSetLinear = 0
  };
};

template <typename Scalar>
struct PacketType<Scalar, const SyclDevice> : PacketType<Scalar, SyclDevice> {};

#ifndef EIGEN_DONT_VECTORIZE_SYCL
#define PACKET_TYPE …

PACKET_TYPE(const, float, 1, 4, SyclDevice)
PACKET_TYPE(, float, 1, 4, SyclDevice)
PACKET_TYPE(const, float, 1, 4, const SyclDevice)
PACKET_TYPE(, float, 1, 4, const SyclDevice)

PACKET_TYPE(const, double, 0, 2, SyclDevice)
PACKET_TYPE(, double, 0, 2, SyclDevice)
PACKET_TYPE(const, double, 0, 2, const SyclDevice)
PACKET_TYPE(, double, 0, 2, const SyclDevice)
#undef PACKET_TYPE

template <>
struct PacketType<half, const SyclDevice> : PacketType<half, SyclDevice> {};
template <>
struct PacketType<const half, const SyclDevice> : PacketType<half, SyclDevice> {};
#endif
#endif

// Pair mimics std::pair but works on e.g. nvcc.
template <typename U, typename V>
struct Pair { … };

template <typename U, typename V>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const Pair<U, V>& x, const Pair<U, V>& y) { … }

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

// Can't use std::pairs on cuda devices
template <typename Idx>
struct IndexPair { … };

namespace internal {

template <typename IndexType, typename Index, Index First, Index... Is>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, 1 + sizeof...(Is)> customIndices2Array(
    IndexType& idx, numeric_list<Index, First, Is...>) { … }
template <typename IndexType, typename Index>
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, 0> customIndices2Array(IndexType&,
                                                                                          numeric_list<Index>) { … }

/** 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) { … }

template <typename B, typename D>
struct is_base_of { … };

}  // namespace internal

}  // namespace Eigen

#endif  // EIGEN_CXX11_TENSOR_TENSOR_META_H