GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-08-14 12:46:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix shadow warnings in Tensor module

Browse Source
This commit is contained in:
Gael Guennebaud 2015-06-16 14:43:46 +02:00
parent e2e66930c6
commit 38874b1651
4 changed files with 77 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
unsupported/Eigen/CXX11/src/Tensor/TensorConcatenation.h
View File

@ -135,6 +135,7 @@ struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgTy
eigen_assert(0 <= m_axis && m_axis < NumDims);
const Dimensions& lhs_dims = m_leftImpl.dimensions();
const Dimensions& rhs_dims = m_rightImpl.dimensions();
{
int i = 0;
for (; i < m_axis; ++i) {
eigen_assert(lhs_dims[i] > 0);
@ -149,6 +150,7 @@ struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgTy
eigen_assert(lhs_dims[i] == rhs_dims[i]);
m_dimensions[i] = lhs_dims[i];
}
}
if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
m_leftStrides[0] = 1;

4
unsupported/Eigen/CXX11/src/Tensor/TensorPadding.h
View File

@ -185,11 +185,13 @@ struct TensorEvaluator<const TensorPaddingOp<PaddingDimensions, ArgType>, Device
{
Index inputIndex;
if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
{
const Index idx = coords[0];
if (idx < m_padding[0].first || idx >= m_dimensions[0] - m_padding[0].second) {
return Scalar(0);
}
inputIndex = idx - m_padding[0].first;
}
for (int i = 1; i < NumDims; ++i) {
const Index idx = coords[i];
if (idx < m_padding[i].first || idx >= m_dimensions[i] - m_padding[i].second) {
@ -198,11 +200,13 @@ struct TensorEvaluator<const TensorPaddingOp<PaddingDimensions, ArgType>, Device
inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
}
} else {
{
const Index idx = coords[NumDims-1];
if (idx < m_padding[NumDims-1].first || idx >= m_dimensions[NumDims-1] - m_padding[NumDims-1].second) {
return Scalar(0);
}
inputIndex = idx - m_padding[NumDims-1].first;
}
for (int i = NumDims - 2; i >= 0; --i) {
const Index idx = coords[i];
if (idx < m_padding[i].first || idx >= m_dimensions[i] - m_padding[i].second) {

8
unsupported/Eigen/CXX11/src/Tensor/TensorRef.h
View File

@ -197,15 +197,15 @@ template<typename PlainObjectType> class TensorRef : public TensorBase<TensorRef
template<typename... IndexTypes> EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar operator()(Index firstIndex, IndexTypes... otherIndices) const
{
const std::size_t NumIndices = (sizeof...(otherIndices) + 1);
const array<Index, NumIndices> indices{{firstIndex, otherIndices...}};
const std::size_t num_indices = (sizeof...(otherIndices) + 1);
const array<Index, num_indices> indices{{firstIndex, otherIndices...}};
return coeff(indices);
}
template<typename... IndexTypes> EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices)
{
const std::size_t NumIndices = (sizeof...(otherIndices) + 1);
const array<Index, NumIndices> indices{{firstIndex, otherIndices...}};
const std::size_t num_indices = (sizeof...(otherIndices) + 1);
const array<Index, num_indices> indices{{firstIndex, otherIndices...}};
return coeffRef(indices);
}
#else

92
unsupported/test/cxx11_tensor_reduction.cpp
View File

@ -17,11 +17,11 @@ template <int DataLayout>
static void test_simple_reductions() {
Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
tensor.setRandom();
array<ptrdiff_t, 2> reduction_axis;
reduction_axis[0] = 1;
reduction_axis[1] = 3;
array<ptrdiff_t, 2> reduction_axis2;
reduction_axis2[0] = 1;
reduction_axis2[1] = 3;
Tensor<float, 2, DataLayout> result = tensor.sum(reduction_axis);
Tensor<float, 2, DataLayout> result = tensor.sum(reduction_axis2);
VERIFY_IS_EQUAL(result.dimension(0), 2);
VERIFY_IS_EQUAL(result.dimension(1), 5);
for (int i = 0; i < 2; ++i) {
@ -40,20 +40,20 @@ static void test_simple_reductions() {
Tensor<float, 1, DataLayout> sum1 = tensor.sum();
VERIFY_IS_EQUAL(sum1.dimension(0), 1);
array<ptrdiff_t, 4> reduction_axis;
reduction_axis[0] = 0;
reduction_axis[1] = 1;
reduction_axis[2] = 2;
reduction_axis[3] = 3;
Tensor<float, 1, DataLayout> sum2 = tensor.sum(reduction_axis);
array<ptrdiff_t, 4> reduction_axis4;
reduction_axis4[0] = 0;
reduction_axis4[1] = 1;
reduction_axis4[2] = 2;
reduction_axis4[3] = 3;
Tensor<float, 1, DataLayout> sum2 = tensor.sum(reduction_axis4);
VERIFY_IS_EQUAL(sum2.dimension(0), 1);
VERIFY_IS_APPROX(sum1(0), sum2(0));
}
reduction_axis[0] = 0;
reduction_axis[1] = 2;
result = tensor.prod(reduction_axis);
reduction_axis2[0] = 0;
reduction_axis2[1] = 2;
result = tensor.prod(reduction_axis2);
VERIFY_IS_EQUAL(result.dimension(0), 3);
VERIFY_IS_EQUAL(result.dimension(1), 7);
for (int i = 0; i < 3; ++i) {
@ -72,20 +72,20 @@ static void test_simple_reductions() {
Tensor<float, 1, DataLayout> prod1 = tensor.prod();
VERIFY_IS_EQUAL(prod1.dimension(0), 1);
array<ptrdiff_t, 4> reduction_axis;
reduction_axis[0] = 0;
reduction_axis[1] = 1;
reduction_axis[2] = 2;
reduction_axis[3] = 3;
Tensor<float, 1, DataLayout> prod2 = tensor.prod(reduction_axis);
array<ptrdiff_t, 4> reduction_axis4;
reduction_axis4[0] = 0;
reduction_axis4[1] = 1;
reduction_axis4[2] = 2;
reduction_axis4[3] = 3;
Tensor<float, 1, DataLayout> prod2 = tensor.prod(reduction_axis4);
VERIFY_IS_EQUAL(prod2.dimension(0), 1);
VERIFY_IS_APPROX(prod1(0), prod2(0));
}
reduction_axis[0] = 0;
reduction_axis[1] = 2;
result = tensor.maximum(reduction_axis);
reduction_axis2[0] = 0;
reduction_axis2[1] = 2;
result = tensor.maximum(reduction_axis2);
VERIFY_IS_EQUAL(result.dimension(0), 3);
VERIFY_IS_EQUAL(result.dimension(1), 7);
for (int i = 0; i < 3; ++i) {
@ -104,20 +104,20 @@ static void test_simple_reductions() {
Tensor<float, 1, DataLayout> max1 = tensor.maximum();
VERIFY_IS_EQUAL(max1.dimension(0), 1);
array<ptrdiff_t, 4> reduction_axis;
reduction_axis[0] = 0;
reduction_axis[1] = 1;
reduction_axis[2] = 2;
reduction_axis[3] = 3;
Tensor<float, 1, DataLayout> max2 = tensor.maximum(reduction_axis);
array<ptrdiff_t, 4> reduction_axis4;
reduction_axis4[0] = 0;
reduction_axis4[1] = 1;
reduction_axis4[2] = 2;
reduction_axis4[3] = 3;
Tensor<float, 1, DataLayout> max2 = tensor.maximum(reduction_axis4);
VERIFY_IS_EQUAL(max2.dimension(0), 1);
VERIFY_IS_APPROX(max1(0), max2(0));
}
reduction_axis[0] = 0;
reduction_axis[1] = 1;
result = tensor.minimum(reduction_axis);
reduction_axis2[0] = 0;
reduction_axis2[1] = 1;
result = tensor.minimum(reduction_axis2);
VERIFY_IS_EQUAL(result.dimension(0), 5);
VERIFY_IS_EQUAL(result.dimension(1), 7);
for (int i = 0; i < 5; ++i) {
@ -136,20 +136,20 @@ static void test_simple_reductions() {
Tensor<float, 1, DataLayout> min1 = tensor.minimum();
VERIFY_IS_EQUAL(min1.dimension(0), 1);
array<ptrdiff_t, 4> reduction_axis;
reduction_axis[0] = 0;
reduction_axis[1] = 1;
reduction_axis[2] = 2;
reduction_axis[3] = 3;
Tensor<float, 1, DataLayout> min2 = tensor.minimum(reduction_axis);
array<ptrdiff_t, 4> reduction_axis4;
reduction_axis4[0] = 0;
reduction_axis4[1] = 1;
reduction_axis4[2] = 2;
reduction_axis4[3] = 3;
Tensor<float, 1, DataLayout> min2 = tensor.minimum(reduction_axis4);
VERIFY_IS_EQUAL(min2.dimension(0), 1);
VERIFY_IS_APPROX(min1(0), min2(0));
}
reduction_axis[0] = 0;
reduction_axis[1] = 1;
result = tensor.mean(reduction_axis);
reduction_axis2[0] = 0;
reduction_axis2[1] = 1;
result = tensor.mean(reduction_axis2);
VERIFY_IS_EQUAL(result.dimension(0), 5);
VERIFY_IS_EQUAL(result.dimension(1), 7);
for (int i = 0; i < 5; ++i) {
@ -170,12 +170,12 @@ static void test_simple_reductions() {
Tensor<float, 1, DataLayout> mean1 = tensor.mean();
VERIFY_IS_EQUAL(mean1.dimension(0), 1);
array<ptrdiff_t, 4> reduction_axis;
reduction_axis[0] = 0;
reduction_axis[1] = 1;
reduction_axis[2] = 2;
reduction_axis[3] = 3;
Tensor<float, 1, DataLayout> mean2 = tensor.mean(reduction_axis);
array<ptrdiff_t, 4> reduction_axis4;
reduction_axis4[0] = 0;
reduction_axis4[1] = 1;
reduction_axis4[2] = 2;
reduction_axis4[3] = 3;
Tensor<float, 1, DataLayout> mean2 = tensor.mean(reduction_axis4);
VERIFY_IS_EQUAL(mean2.dimension(0), 1);
VERIFY_IS_APPROX(mean1(0), mean2(0));