TensorConcatenation.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) 2014 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_CONCATENATION_H
11 #define EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
12 
13 namespace Eigen {
14 
22 namespace internal {
23 template<typename Axis, typename LhsXprType, typename RhsXprType>
24 struct traits<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >
25 {
26  // Type promotion to handle the case where the types of the lhs and the rhs are different.
27  typedef typename promote_storage_type<typename LhsXprType::Scalar,
33  typedef typename LhsXprType::Nested LhsNested;
34  typedef typename RhsXprType::Nested RhsNested;
37  static const int NumDimensions = traits<LhsXprType>::NumDimensions;
38  static const int Layout = traits<LhsXprType>::Layout;
39  enum { Flags = 0 };
42 };
43 
44 template<typename Axis, typename LhsXprType, typename RhsXprType>
45 struct eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, Eigen::Dense>
46 {
48 };
49 
50 template<typename Axis, typename LhsXprType, typename RhsXprType>
51 struct nested<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, 1, typename eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >::type>
52 {
54 };
55 
56 } // end namespace internal
57 
58 
59 template<typename Axis, typename LhsXprType, typename RhsXprType>
60 class TensorConcatenationOp : public TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors>
61 {
62  public:
68  typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
69  typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
71 
72  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConcatenationOp(const LhsXprType& lhs, const RhsXprType& rhs, Axis axis)
73  : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_axis(axis) {}
74 
77  lhsExpression() const { return m_lhs_xpr; }
78 
81  rhsExpression() const { return m_rhs_xpr; }
82 
83  EIGEN_DEVICE_FUNC const Axis& axis() const { return m_axis; }
84 
86  protected:
87  typename LhsXprType::Nested m_lhs_xpr;
88  typename RhsXprType::Nested m_rhs_xpr;
89  const Axis m_axis;
90 };
91 
92 
93 // Eval as rvalue
94 template<typename Axis, typename LeftArgType, typename RightArgType, typename Device>
95 struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
96 {
98  typedef typename XprType::Index Index;
102  typedef typename XprType::Scalar Scalar;
107  enum {
108  IsAligned = false,
111  BlockAccess = false,
115  RawAccess = false
116  };
117 
118  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
120  //===--------------------------------------------------------------------===//
121 
122  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
123  : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device), m_axis(op.axis())
124  {
125  EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) == static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) || NumDims == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
126  EIGEN_STATIC_ASSERT((NumDims == RightNumDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
127  EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
128 
129  eigen_assert(0 <= m_axis && m_axis < NumDims);
130  const Dimensions& lhs_dims = m_leftImpl.dimensions();
131  const Dimensions& rhs_dims = m_rightImpl.dimensions();
132  {
133  int i = 0;
134  for (; i < m_axis; ++i) {
135  eigen_assert(lhs_dims[i] > 0);
136  eigen_assert(lhs_dims[i] == rhs_dims[i]);
137  m_dimensions[i] = lhs_dims[i];
138  }
139  eigen_assert(lhs_dims[i] > 0); // Now i == m_axis.
140  eigen_assert(rhs_dims[i] > 0);
141  m_dimensions[i] = lhs_dims[i] + rhs_dims[i];
142  for (++i; i < NumDims; ++i) {
143  eigen_assert(lhs_dims[i] > 0);
144  eigen_assert(lhs_dims[i] == rhs_dims[i]);
145  m_dimensions[i] = lhs_dims[i];
146  }
147  }
148 
149  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
150  m_leftStrides[0] = 1;
151  m_rightStrides[0] = 1;
152  m_outputStrides[0] = 1;
153 
154  for (int j = 1; j < NumDims; ++j) {
155  m_leftStrides[j] = m_leftStrides[j-1] * lhs_dims[j-1];
156  m_rightStrides[j] = m_rightStrides[j-1] * rhs_dims[j-1];
157  m_outputStrides[j] = m_outputStrides[j-1] * m_dimensions[j-1];
158  }
159  } else {
160  m_leftStrides[NumDims - 1] = 1;
161  m_rightStrides[NumDims - 1] = 1;
162  m_outputStrides[NumDims - 1] = 1;
163 
164  for (int j = NumDims - 2; j >= 0; --j) {
165  m_leftStrides[j] = m_leftStrides[j+1] * lhs_dims[j+1];
166  m_rightStrides[j] = m_rightStrides[j+1] * rhs_dims[j+1];
167  m_outputStrides[j] = m_outputStrides[j+1] * m_dimensions[j+1];
168  }
169  }
170  }
171 
172  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
173 
174  // TODO(phli): Add short-circuit memcpy evaluation if underlying data are linear?
176  {
177  m_leftImpl.evalSubExprsIfNeeded(NULL);
178  m_rightImpl.evalSubExprsIfNeeded(NULL);
179  return true;
180  }
181 
183  {
184  m_leftImpl.cleanup();
185  m_rightImpl.cleanup();
186  }
187 
188  // TODO(phli): attempt to speed this up. The integer divisions and modulo are slow.
189  // See CL/76180724 comments for more ideas.
191  {
192  // Collect dimension-wise indices (subs).
194  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
195  for (int i = NumDims - 1; i > 0; --i) {
196  subs[i] = index / m_outputStrides[i];
197  index -= subs[i] * m_outputStrides[i];
198  }
199  subs[0] = index;
200  } else {
201  for (int i = 0; i < NumDims - 1; ++i) {
202  subs[i] = index / m_outputStrides[i];
203  index -= subs[i] * m_outputStrides[i];
204  }
205  subs[NumDims - 1] = index;
206  }
207 
208  const Dimensions& left_dims = m_leftImpl.dimensions();
209  if (subs[m_axis] < left_dims[m_axis]) {
210  Index left_index;
211  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
212  left_index = subs[0];
214  for (int i = 1; i < NumDims; ++i) {
215  left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
216  }
217  } else {
218  left_index = subs[NumDims - 1];
220  for (int i = NumDims - 2; i >= 0; --i) {
221  left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
222  }
223  }
224  return m_leftImpl.coeff(left_index);
225  } else {
226  subs[m_axis] -= left_dims[m_axis];
227  const Dimensions& right_dims = m_rightImpl.dimensions();
228  Index right_index;
229  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
230  right_index = subs[0];
232  for (int i = 1; i < NumDims; ++i) {
233  right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
234  }
235  } else {
236  right_index = subs[NumDims - 1];
238  for (int i = NumDims - 2; i >= 0; --i) {
239  right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
240  }
241  }
242  return m_rightImpl.coeff(right_index);
243  }
244  }
245 
246  // TODO(phli): Add a real vectorization.
247  template<int LoadMode>
249  {
250  const int packetSize = PacketType<CoeffReturnType, Device>::size;
251  EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
252  eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
253 
256  for (int i = 0; i < packetSize; ++i) {
257  values[i] = coeff(index+i);
258  }
259  PacketReturnType rslt = internal::pload<PacketReturnType>(values);
260  return rslt;
261  }
262 
264  costPerCoeff(bool vectorized) const {
265  const double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() +
266  2 * TensorOpCost::MulCost<Index>() +
267  TensorOpCost::DivCost<Index>() +
268  TensorOpCost::ModCost<Index>());
269  const double lhs_size = m_leftImpl.dimensions().TotalSize();
270  const double rhs_size = m_rightImpl.dimensions().TotalSize();
271  return (lhs_size / (lhs_size + rhs_size)) *
272  m_leftImpl.costPerCoeff(vectorized) +
273  (rhs_size / (lhs_size + rhs_size)) *
274  m_rightImpl.costPerCoeff(vectorized) +
275  TensorOpCost(0, 0, compute_cost);
276  }
277 
279 
280  #ifdef EIGEN_USE_SYCL
281  // binding placeholder accessors to a command group handler for SYCL
282  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(cl::sycl::handler &cgh) const {
283  m_leftImpl.bind(cgh);
284  m_rightImpl.bind(cgh);
285  }
286  #endif
287 
288  protected:
295  const Axis m_axis;
296 };
297 
298 // Eval as lvalue
299 template<typename Axis, typename LeftArgType, typename RightArgType, typename Device>
300  struct TensorEvaluator<TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
301  : public TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
302 {
305  typedef typename Base::Dimensions Dimensions;
306  enum {
307  IsAligned = false,
310  BlockAccess = false,
314  RawAccess = false
315  };
316 
317  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
319  //===--------------------------------------------------------------------===//
320 
321  EIGEN_STRONG_INLINE TensorEvaluator(XprType& op, const Device& device)
322  : Base(op, device)
323  {
324  EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
325  }
326 
327  typedef typename XprType::Index Index;
328  typedef typename XprType::Scalar Scalar;
331 
333  {
334  // Collect dimension-wise indices (subs).
336  for (int i = Base::NumDims - 1; i > 0; --i) {
337  subs[i] = index / this->m_outputStrides[i];
338  index -= subs[i] * this->m_outputStrides[i];
339  }
340  subs[0] = index;
341 
342  const Dimensions& left_dims = this->m_leftImpl.dimensions();
343  if (subs[this->m_axis] < left_dims[this->m_axis]) {
344  Index left_index = subs[0];
345  for (int i = 1; i < Base::NumDims; ++i) {
346  left_index += (subs[i] % left_dims[i]) * this->m_leftStrides[i];
347  }
348  return this->m_leftImpl.coeffRef(left_index);
349  } else {
350  subs[this->m_axis] -= left_dims[this->m_axis];
351  const Dimensions& right_dims = this->m_rightImpl.dimensions();
352  Index right_index = subs[0];
353  for (int i = 1; i < Base::NumDims; ++i) {
354  right_index += (subs[i] % right_dims[i]) * this->m_rightStrides[i];
355  }
356  return this->m_rightImpl.coeffRef(right_index);
357  }
358  }
359 
360  template <int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
361  void writePacket(Index index, const PacketReturnType& x)
362  {
363  const int packetSize = PacketType<CoeffReturnType, Device>::size;
364  EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
365  eigen_assert(index + packetSize - 1 < this->dimensions().TotalSize());
366 
368  internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
369  for (int i = 0; i < packetSize; ++i) {
370  coeffRef(index+i) = values[i];
371  }
372  }
373 };
374 
375 } // end namespace Eigen
376 
377 #endif // EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
Eigen::TensorEvaluator::dimensions
EIGEN_DEVICE_FUNC const EIGEN_STRONG_INLINE Dimensions & dimensions() const
Definition: TensorEvaluator.h:73
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_outputStrides
array< Index, NumDims > m_outputStrides
Definition: TensorConcatenation.h:290
EIGEN_DEVICE_FUNC
#define EIGEN_DEVICE_FUNC
Definition: Macros.h:976
Eigen::TensorConcatenationOp::Nested
internal::nested< TensorConcatenationOp >::type Nested
Definition: TensorConcatenation.h:67
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Storage
StorageMemory< CoeffReturnType, Device > Storage
Definition: TensorConcatenation.h:105
Eigen
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_axis
const Axis m_axis
Definition: TensorConcatenation.h:295
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_leftImpl
TensorEvaluator< LeftArgType, Device > m_leftImpl
Definition: TensorConcatenation.h:293
Eigen::internal::TensorBlockNotImplemented
Definition: TensorBlock.h:617
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_dimensions
Dimensions m_dimensions
Definition: TensorConcatenation.h:289
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::_RhsNested
remove_reference< RhsNested >::type _RhsNested
Definition: TensorConcatenation.h:36
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_leftStrides
array< Index, NumDims > m_leftStrides
Definition: TensorConcatenation.h:291
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::XprType
TensorConcatenationOp< Axis, LeftArgType, RightArgType > XprType
Definition: TensorConcatenation.h:97
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Dimensions
Base::Dimensions Dimensions
Definition: TensorConcatenation.h:305
Eigen::TensorConcatenationOp::Index
internal::traits< TensorConcatenationOp >::Index Index
Definition: TensorConcatenation.h:66
Eigen::array< Index, NumDims >
Eigen::internal::nested
Definition: TensorTraits.h:174
eigen_assert
#define eigen_assert(x)
Definition: Macros.h:1037
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::evalSubExprsIfNeeded
EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType)
Definition: TensorConcatenation.h:175
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::_LhsNested
remove_reference< LhsNested >::type _LhsNested
Definition: TensorConcatenation.h:35
x
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
Definition: gnuplot_common_settings.hh:12
ret
DenseIndex ret
Definition: level1_cplx_impl.h:44
Eigen::TensorEvaluator::Layout
@ Layout
Definition: TensorEvaluator.h:50
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::cleanup
EIGEN_STRONG_INLINE void cleanup()
Definition: TensorConcatenation.h:182
type
Definition: pytypes.h:1525
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_rightStrides
array< Index, NumDims > m_rightStrides
Definition: TensorConcatenation.h:292
different_sigmas::values
HybridValues values
Definition: testHybridBayesNet.cpp:245
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Index
XprType::Index Index
Definition: TensorConcatenation.h:98
Eigen::TensorConcatenationOp::Base
TensorBase< TensorConcatenationOp< Axis, LhsXprType, RhsXprType >, WriteAccessors > Base
Definition: TensorConcatenation.h:63
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Dimensions
DSizes< Index, NumDims > Dimensions
Definition: TensorConcatenation.h:101
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >
Definition: TensorConcatenation.h:95
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::coeffRef
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType & coeffRef(Index index)
Definition: TensorConcatenation.h:332
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Index
XprType::Index Index
Definition: TensorConcatenation.h:327
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::TensorEvaluator
EIGEN_STRONG_INLINE TensorEvaluator(const XprType &op, const Device &device)
Definition: TensorConcatenation.h:122
Eigen::DSizes< Index, NumDims >
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::PointerType
conditional< Pointer_type_promotion< typename LhsXprType::Scalar, Scalar >::val, typename traits< LhsXprType >::PointerType, typename traits< RhsXprType >::PointerType >::type PointerType
Definition: TensorConcatenation.h:41
EIGEN_ALIGN_MAX
#define EIGEN_ALIGN_MAX
Definition: ConfigureVectorization.h:157
Eigen::TensorConcatenationOp
Tensor concatenation class.
Definition: TensorConcatenation.h:60
Eigen::PacketType
Definition: TensorMeta.h:50
Eigen::TensorConcatenationOp::rhsExpression
const EIGEN_DEVICE_FUNC internal::remove_all< typename RhsXprType::Nested >::type & rhsExpression() const
Definition: TensorConcatenation.h:81
Eigen::internal::true_type
Definition: Meta.h:96
Eigen::TensorConcatenationOp::CoeffReturnType
internal::promote_storage_type< typename LhsXprType::CoeffReturnType, typename RhsXprType::CoeffReturnType >::ret CoeffReturnType
Definition: TensorConcatenation.h:69
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::XprType
TensorConcatenationOp< Axis, LeftArgType, RightArgType > XprType
Definition: TensorConcatenation.h:304
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::Index
promote_index_type< typename traits< LhsXprType >::Index, typename traits< RhsXprType >::Index >::type Index
Definition: TensorConcatenation.h:32
Eigen::TensorConcatenationOp::m_rhs_xpr
RhsXprType::Nested m_rhs_xpr
Definition: TensorConcatenation.h:88
Eigen::TensorConcatenationOp::m_lhs_xpr
LhsXprType::Nested m_lhs_xpr
Definition: TensorConcatenation.h:87
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Base
TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device > Base
Definition: TensorConcatenation.h:303
Eigen::internal::nested< TensorConcatenationOp< Axis, LhsXprType, RhsXprType >, 1, typename eval< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::type >::type
TensorConcatenationOp< Axis, LhsXprType, RhsXprType > type
Definition: TensorConcatenation.h:53
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::coeff
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
Definition: TensorConcatenation.h:190
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::Scalar
promote_storage_type< typename LhsXprType::Scalar, typename RhsXprType::Scalar >::ret Scalar
Definition: TensorConcatenation.h:28
EIGEN_STRONG_INLINE
#define EIGEN_STRONG_INLINE
Definition: Macros.h:917
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Scalar
XprType::Scalar Scalar
Definition: TensorConcatenation.h:102
EIGEN_UNROLL_LOOP
#define EIGEN_UNROLL_LOOP
Definition: Macros.h:1461
Eigen::TensorEvaluator::PreferBlockAccess
@ PreferBlockAccess
Definition: TensorEvaluator.h:49
Eigen::TensorConcatenationOp::lhsExpression
const EIGEN_DEVICE_FUNC internal::remove_all< typename LhsXprType::Nested >::type & lhsExpression() const
Definition: TensorConcatenation.h:77
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::StorageKind
promote_storage_type< typename traits< LhsXprType >::StorageKind, typename traits< RhsXprType >::StorageKind >::ret StorageKind
Definition: TensorConcatenation.h:30
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::CoeffReturnType
XprType::CoeffReturnType CoeffReturnType
Definition: TensorConcatenation.h:329
Eigen::internal::promote_storage_type
Definition: XprHelper.h:518
Eigen::Triplet< double >
Eigen::internal::eval< TensorConcatenationOp< Axis, LhsXprType, RhsXprType >, Eigen::Dense >::type
const typedef TensorConcatenationOp< Axis, LhsXprType, RhsXprType > & type
Definition: TensorConcatenation.h:47
Eigen::StorageMemory
Definition: TensorForwardDeclarations.h:37
Eigen::TensorBase
The tensor base class.
Definition: TensorBase.h:973
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::TensorBlock
internal::TensorBlockNotImplemented TensorBlock
Definition: TensorConcatenation.h:318
Eigen::internal::array_size
Definition: Meta.h:445
Eigen::TensorEvaluator::BlockAccess
@ BlockAccess
Definition: TensorEvaluator.h:48
Eigen::TensorEvaluator::coeffRef
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType & coeffRef(Index index)
Definition: TensorEvaluator.h:99
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::data
EIGEN_DEVICE_FUNC EvaluatorPointerType data() const
Definition: TensorConcatenation.h:278
Eigen::TensorConcatenationOp::Scalar
internal::traits< TensorConcatenationOp >::Scalar Scalar
Definition: TensorConcatenation.h:64
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::PacketReturnType
PacketType< CoeffReturnType, Device >::type PacketReturnType
Definition: TensorConcatenation.h:330
EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS
#define EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(Derived)
Definition: TensorMacros.h:94
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::TensorBlock
internal::TensorBlockNotImplemented TensorBlock
Definition: TensorConcatenation.h:119
Eigen::internal::traits
Definition: ForwardDeclarations.h:17
EIGEN_STATIC_ASSERT
#define EIGEN_STATIC_ASSERT(CONDITION, MSG)
Definition: StaticAssert.h:127
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::m_rightImpl
TensorEvaluator< RightArgType, Device > m_rightImpl
Definition: TensorConcatenation.h:294
Eigen::internal::conditional
Definition: Meta.h:109
Eigen::TensorEvaluator::coeff
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
Definition: TensorEvaluator.h:94
Eigen::TensorConcatenationOp::TensorConcatenationOp
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConcatenationOp(const LhsXprType &lhs, const RhsXprType &rhs, Axis axis)
Definition: TensorConcatenation.h:72
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::packet
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
Definition: TensorConcatenation.h:248
Eigen::TensorEvaluator
A cost model used to limit the number of threads used for evaluating tensor expression.
Definition: TensorEvaluator.h:28
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::LhsNested
LhsXprType::Nested LhsNested
Definition: TensorConcatenation.h:33
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::EvaluatorPointerType
Storage::Type EvaluatorPointerType
Definition: TensorConcatenation.h:106
Eigen::internal::traits< TensorConcatenationOp< Axis, LhsXprType, RhsXprType > >::RhsNested
RhsXprType::Nested RhsNested
Definition: TensorConcatenation.h:34
internal
Definition: BandTriangularSolver.h:13
NULL
#define NULL
Definition: ccolamd.c:609
Eigen::TensorConcatenationOp::RealScalar
NumTraits< Scalar >::Real RealScalar
Definition: TensorConcatenation.h:70
Eigen::ColMajor
@ ColMajor
Definition: Constants.h:319
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::Scalar
XprType::Scalar Scalar
Definition: TensorConcatenation.h:328
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::costPerCoeff
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const
Definition: TensorConcatenation.h:264
Eigen::TensorEvaluator::IsAligned
@ IsAligned
Definition: TensorEvaluator.h:46
Eigen::internal::promote_index_type
Definition: XprHelper.h:120
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::CoeffReturnType
XprType::CoeffReturnType CoeffReturnType
Definition: TensorConcatenation.h:103
Eigen::WriteAccessors
@ WriteAccessors
Definition: Constants.h:378
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::TensorEvaluator
EIGEN_STRONG_INLINE TensorEvaluator(XprType &op, const Device &device)
Definition: TensorConcatenation.h:321
Eigen::TensorConcatenationOp::axis
const EIGEN_DEVICE_FUNC Axis & axis() const
Definition: TensorConcatenation.h:83
Eigen::internal::eval
Definition: XprHelper.h:332
Eigen::TensorEvaluator::PacketAccess
@ PacketAccess
Definition: TensorEvaluator.h:47
Eigen::TensorConcatenationOp::StorageKind
internal::traits< TensorConcatenationOp >::StorageKind StorageKind
Definition: TensorConcatenation.h:65
Eigen::TensorConcatenationOp::m_axis
const Axis m_axis
Definition: TensorConcatenation.h:89
Eigen::TensorOpCost
Definition: TensorCostModel.h:25
Eigen::NumTraits
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:232
test_callbacks.value
value
Definition: test_callbacks.py:160
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::dimensions
EIGEN_DEVICE_FUNC const EIGEN_STRONG_INLINE Dimensions & dimensions() const
Definition: TensorConcatenation.h:172
Eigen::TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::writePacket
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType &x)
Definition: TensorConcatenation.h:361
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:46
Eigen::TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >::PacketReturnType
PacketType< CoeffReturnType, Device >::type PacketReturnType
Definition: TensorConcatenation.h:104
Eigen::Dense
Definition: Constants.h:507


gtsam
Author(s):
autogenerated on Sat Nov 16 2024 04:05:37