TensorMeta.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_CXX11_TENSOR_TENSOR_META_H
11 #define EIGEN_CXX11_TENSOR_TENSOR_META_H
12 
13 namespace Eigen {
14 
15 template<bool cond> struct Cond {};
16 
17 template<typename T1, typename T2> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
18 const T1& choose(Cond<true>, const T1& first, const T2&) {
19  return first;
20 }
21 
22 template<typename T1, typename T2> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
23 const T2& choose(Cond<false>, const T1&, const T2& second) {
24  return second;
25 }
26 
27 
28 template <typename T, typename X, typename Y>
29 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
30 T divup(const X x, const Y y) {
31  return static_cast<T>((x + y - 1) / y);
32 }
33 
34 template <typename T>
35 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
36 T divup(const T x, const T y) {
37  return static_cast<T>((x + y - 1) / y);
38 }
39 
40 template <size_t n> struct max_n_1 {
41  static const size_t size = n;
42 };
43 template <> struct max_n_1<0> {
44  static const size_t size = 1;
45 };
46 
47 
48 // Default packet types
49 template <typename Scalar, typename Device>
52 };
53 
54 // For CUDA packet types when using a GpuDevice
55 #if defined(EIGEN_USE_GPU) && defined(__CUDACC__) && defined(EIGEN_HAS_CUDA_FP16)
56 template <>
57 struct PacketType<half, GpuDevice> {
58  typedef half2 type;
59  static const int size = 2;
60  enum {
61  HasAdd = 1,
62  HasSub = 1,
63  HasMul = 1,
64  HasNegate = 1,
65  HasAbs = 1,
66  HasArg = 0,
67  HasAbs2 = 0,
68  HasMin = 1,
69  HasMax = 1,
70  HasConj = 0,
71  HasSetLinear = 0,
72  HasBlend = 0,
73 
74  HasDiv = 1,
75  HasSqrt = 1,
76  HasRsqrt = 1,
77  HasExp = 1,
78  HasLog = 1,
79  HasLog1p = 0,
80  HasLog10 = 0,
81  HasPow = 1,
82  };
83 };
84 #endif
85 
86 #if defined(EIGEN_USE_SYCL)
87 template <typename T>
88  struct PacketType<T, SyclDevice> {
89  typedef T type;
90  static const int size = 1;
91  enum {
92  HasAdd = 0,
93  HasSub = 0,
94  HasMul = 0,
95  HasNegate = 0,
96  HasAbs = 0,
97  HasArg = 0,
98  HasAbs2 = 0,
99  HasMin = 0,
100  HasMax = 0,
101  HasConj = 0,
102  HasSetLinear = 0,
103  HasBlend = 0
104  };
105 };
106 #endif
107 
108 
109 // Tuple mimics std::pair but works on e.g. nvcc.
110 template <typename U, typename V> struct Tuple {
111  public:
114 
115  typedef U first_type;
116  typedef V second_type;
117 
118  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
119  Tuple() : first(), second() {}
120 
121  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
122  Tuple(const U& f, const V& s) : first(f), second(s) {}
123 
124  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
125  Tuple& operator= (const Tuple& rhs) {
126  if (&rhs == this) return *this;
127  first = rhs.first;
128  second = rhs.second;
129  return *this;
130  }
131 
132  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
133  void swap(Tuple& rhs) {
134  using numext::swap;
135  swap(first, rhs.first);
136  swap(second, rhs.second);
137  }
138 };
139 
140 template <typename U, typename V>
141 EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
142 bool operator==(const Tuple<U, V>& x, const Tuple<U, V>& y) {
143  return (x.first == y.first && x.second == y.second);
144 }
145 
146 template <typename U, typename V>
147 EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
148 bool operator!=(const Tuple<U, V>& x, const Tuple<U, V>& y) {
149  return !(x == y);
150 }
151 
152 
153 // Can't use std::pairs on cuda devices
154 template <typename Idx> struct IndexPair {
155  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair() : first(0), second(0) {}
156  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair(Idx f, Idx s) : first(f), second(s) {}
157 
158  EIGEN_DEVICE_FUNC void set(IndexPair<Idx> val) {
159  first = val.first;
160  second = val.second;
161  }
162 
163  Idx first;
164  Idx second;
165 };
166 
167 
168 #ifdef EIGEN_HAS_SFINAE
169 namespace internal {
170 
171  template<typename IndexType, Index... Is>
172  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
173  array<Index, sizeof...(Is)> customIndices2Array(IndexType& idx, numeric_list<Index, Is...>) {
174  return { idx[Is]... };
175  }
176  template<typename IndexType>
177  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
178  array<Index, 0> customIndices2Array(IndexType&, numeric_list<Index>) {
179  return array<Index, 0>();
180  }
181 
183  template<typename Index, std::size_t NumIndices, typename IndexType>
184  EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
185  array<Index, NumIndices> customIndices2Array(IndexType& idx) {
186  return customIndices2Array(idx, typename gen_numeric_list<Index, NumIndices>::type{});
187  }
188 
189 
190  template <typename B, typename D>
191  struct is_base_of
192  {
193 
194  typedef char (&yes)[1];
195  typedef char (&no)[2];
196 
197  template <typename BB, typename DD>
198  struct Host
199  {
200  operator BB*() const;
201  operator DD*();
202  };
203 
204  template<typename T>
205  static yes check(D*, T);
206  static no check(B*, int);
207 
208  static const bool value = sizeof(check(Host<B,D>(), int())) == sizeof(yes);
209  };
210 
211 }
212 #endif
213 
214 
215 
216 } // namespace Eigen
217 
218 #endif // EIGEN_CXX11_TENSOR_TENSOR_META_H
#define EIGEN_ALWAYS_INLINE
Definition: Macros.h:509
#define EIGEN_STRONG_INLINE
Definition: Macros.h:494
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const Tuple< U, V > &x, const Tuple< U, V > &y)
Definition: TensorMeta.h:142
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1 & choose(Cond< true >, const T1 &first, const T2 &)
Definition: TensorMeta.h:18
int n
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
Pose2 T2(M_PI/2.0, Point2(0.0, 2.0))
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
EIGEN_STRONG_INLINE void swap(T &a, T &b)
Definition: Meta.h:493
int EIGEN_BLAS_FUNC() swap(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
Definition: level1_impl.h:152
constexpr int first(int i)
Implementation details for constexpr functions.
#define EIGEN_CONSTEXPR
Definition: TensorMacros.h:50
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair(Idx f, Idx s)
Definition: TensorMeta.h:156
Point2(* f)(const Point3 &, OptionalJacobian< 2, 3 >)
RealScalar s
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair()
Definition: TensorMeta.h:155
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(Tuple &rhs)
Definition: TensorMeta.h:133
void check(bool b, bool ref)
Definition: fastmath.cpp:12
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tuple(const U &f, const V &s)
Definition: TensorMeta.h:122
Pose2 T1(M_PI/4.0, Point2(sqrt(0.5), sqrt(0.5)))
#define X
Definition: icosphere.cpp:20
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator!=(const Tuple< U, V > &x, const Tuple< U, V > &y)
Definition: TensorMeta.h:148
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tuple()
Definition: TensorMeta.h:119
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T divup(const X x, const Y y)
Definition: TensorMeta.h:30
internal::packet_traits< Scalar >::type type
Definition: TensorMeta.h:51
const T & y


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:45:33