mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-07-25 06:14:26 +08:00
Created additional tests for the tensor code.
This commit is contained in:
Benoit Steiner
parent
6fa6cdd2b9
commit
8998f4099e
@ -102,6 +102,8 @@ if(EIGEN_TEST_CXX11)
|
||||
ei_add_test(cxx11_tensor_simple "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_symmetry "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_assign "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_comparison "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_contraction "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_expr "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_map "-std=c++0x")
|
||||
ei_add_test(cxx11_tensor_device "-std=c++0x")
|
||||
|
||||
84
unsupported/test/cxx11_tensor_comparisons.cpp
Normal file
84
unsupported/test/cxx11_tensor_comparisons.cpp
Normal file
@ -0,0 +1,84 @@
|
||||
// This file is part of Eigen, a lightweight C++ template library
|
||||
// for linear algebra.
|
||||
//
|
||||
// Copyright (C) 2014 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/.
|
||||
|
||||
#include "main.h"
|
||||
|
||||
#include <Eigen/CXX11/Tensor>
|
||||
|
||||
using Eigen::Tensor;
|
||||
using Eigen::RowMajor;
|
||||
|
||||
static void test_orderings()
|
||||
{
|
||||
Tensor<float, 3> mat1(2,3,7);
|
||||
Tensor<float, 3> mat2(2,3,7);
|
||||
Tensor<bool, 3> lt(2,3,7);
|
||||
Tensor<bool, 3> le(2,3,7);
|
||||
Tensor<bool, 3> gt(2,3,7);
|
||||
Tensor<bool, 3> ge(2,3,7);
|
||||
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
|
||||
lt = mat1 < mat2;
|
||||
le = mat1 <= mat2;
|
||||
gt = mat1 > mat2;
|
||||
ge = mat1 >= mat2;
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_EQUAL(lt(i,j,k), mat1(i,j,k) < mat2(i,j,k));
|
||||
VERIFY_IS_EQUAL(le(i,j,k), mat1(i,j,k) <= mat2(i,j,k));
|
||||
VERIFY_IS_EQUAL(gt(i,j,k), mat1(i,j,k) > mat2(i,j,k));
|
||||
VERIFY_IS_EQUAL(ge(i,j,k), mat1(i,j,k) >= mat2(i,j,k));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void test_equality()
|
||||
{
|
||||
Tensor<float, 3> mat1(2,3,7);
|
||||
Tensor<float, 3> mat2(2,3,7);
|
||||
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
if (random() < 0.5) {
|
||||
mat2(i,j,k) = mat1(i,j,k);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Tensor<bool, 3> eq(2,3,7);
|
||||
Tensor<bool, 3> ne(2,3,7);
|
||||
eq = (mat1 == mat2);
|
||||
ne = (mat1 != mat2);
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_EQUAL(eq(i,j,k), mat1(i,j,k) == mat2(i,j,k));
|
||||
VERIFY_IS_EQUAL(ne(i,j,k), mat1(i,j,k) != mat2(i,j,k));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void test_cxx11_tensor_comparisons()
|
||||
{
|
||||
CALL_SUBTEST(test_orderings());
|
||||
CALL_SUBTEST(test_equality());
|
||||
}
|
||||
163
unsupported/test/cxx11_tensor_contraction.cpp
Normal file
163
unsupported/test/cxx11_tensor_contraction.cpp
Normal file
@ -0,0 +1,163 @@
|
||||
// This file is part of Eigen, a lightweight C++ template library
|
||||
// for linear algebra.
|
||||
//
|
||||
// Copyright (C) 2014 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/.
|
||||
|
||||
#include "main.h"
|
||||
|
||||
#include <Eigen/CXX11/Tensor>
|
||||
|
||||
using Eigen::Tensor;
|
||||
|
||||
typedef Tensor<float, 1>::DimensionPair DimPair;
|
||||
|
||||
|
||||
static void test_evals()
|
||||
{
|
||||
Tensor<float, 2> mat1(2, 3);
|
||||
Tensor<float, 2> mat2(2, 3);
|
||||
Tensor<float, 2> mat3(3, 2);
|
||||
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
mat3.setRandom();
|
||||
|
||||
Tensor<float, 2> mat4(3,3);
|
||||
mat4.setZero();
|
||||
Eigen::array<DimPair, 1> dims3({{DimPair(0, 0)}});
|
||||
TensorEvaluator<decltype(mat1.contract(mat2, dims3))> eval(mat1.contract(mat2, dims3));
|
||||
eval.evalTo(mat4.data());
|
||||
EIGEN_STATIC_ASSERT(TensorEvaluator<decltype(mat1.contract(mat2, dims3))>::NumDims==2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
|
||||
VERIFY_IS_EQUAL(eval.dimensions()[0], 3);
|
||||
VERIFY_IS_EQUAL(eval.dimensions()[1], 3);
|
||||
|
||||
VERIFY_IS_APPROX(mat4(0,0), mat1(0,0)*mat2(0,0) + mat1(1,0)*mat2(1,0));
|
||||
VERIFY_IS_APPROX(mat4(0,1), mat1(0,0)*mat2(0,1) + mat1(1,0)*mat2(1,1));
|
||||
VERIFY_IS_APPROX(mat4(0,2), mat1(0,0)*mat2(0,2) + mat1(1,0)*mat2(1,2));
|
||||
VERIFY_IS_APPROX(mat4(1,0), mat1(0,1)*mat2(0,0) + mat1(1,1)*mat2(1,0));
|
||||
VERIFY_IS_APPROX(mat4(1,1), mat1(0,1)*mat2(0,1) + mat1(1,1)*mat2(1,1));
|
||||
VERIFY_IS_APPROX(mat4(1,2), mat1(0,1)*mat2(0,2) + mat1(1,1)*mat2(1,2));
|
||||
VERIFY_IS_APPROX(mat4(2,0), mat1(0,2)*mat2(0,0) + mat1(1,2)*mat2(1,0));
|
||||
VERIFY_IS_APPROX(mat4(2,1), mat1(0,2)*mat2(0,1) + mat1(1,2)*mat2(1,1));
|
||||
VERIFY_IS_APPROX(mat4(2,2), mat1(0,2)*mat2(0,2) + mat1(1,2)*mat2(1,2));
|
||||
|
||||
Tensor<float, 2> mat5(2,2);
|
||||
mat5.setZero();
|
||||
Eigen::array<DimPair, 1> dims4({{DimPair(1, 1)}});
|
||||
TensorEvaluator<decltype(mat1.contract(mat2, dims4))> eval2(mat1.contract(mat2, dims4));
|
||||
eval2.evalTo(mat5.data());
|
||||
EIGEN_STATIC_ASSERT(TensorEvaluator<decltype(mat1.contract(mat2, dims4))>::NumDims==2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
|
||||
VERIFY_IS_EQUAL(eval2.dimensions()[0], 2);
|
||||
VERIFY_IS_EQUAL(eval2.dimensions()[1], 2);
|
||||
|
||||
VERIFY_IS_APPROX(mat5(0,0), mat1(0,0)*mat2(0,0) + mat1(0,1)*mat2(0,1) + mat1(0,2)*mat2(0,2));
|
||||
VERIFY_IS_APPROX(mat5(0,1), mat1(0,0)*mat2(1,0) + mat1(0,1)*mat2(1,1) + mat1(0,2)*mat2(1,2));
|
||||
VERIFY_IS_APPROX(mat5(1,0), mat1(1,0)*mat2(0,0) + mat1(1,1)*mat2(0,1) + mat1(1,2)*mat2(0,2));
|
||||
VERIFY_IS_APPROX(mat5(1,1), mat1(1,0)*mat2(1,0) + mat1(1,1)*mat2(1,1) + mat1(1,2)*mat2(1,2));
|
||||
|
||||
Tensor<float, 2> mat6(2,2);
|
||||
mat6.setZero();
|
||||
Eigen::array<DimPair, 1> dims6({{DimPair(1, 0)}});
|
||||
TensorEvaluator<decltype(mat1.contract(mat3, dims6))> eval3(mat1.contract(mat3, dims6));
|
||||
eval3.evalTo(mat6.data());
|
||||
EIGEN_STATIC_ASSERT(TensorEvaluator<decltype(mat1.contract(mat3, dims6))>::NumDims==2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
|
||||
VERIFY_IS_EQUAL(eval3.dimensions()[0], 2);
|
||||
VERIFY_IS_EQUAL(eval3.dimensions()[1], 2);
|
||||
|
||||
VERIFY_IS_APPROX(mat6(0,0), mat1(0,0)*mat3(0,0) + mat1(0,1)*mat3(1,0) + mat1(0,2)*mat3(2,0));
|
||||
VERIFY_IS_APPROX(mat6(0,1), mat1(0,0)*mat3(0,1) + mat1(0,1)*mat3(1,1) + mat1(0,2)*mat3(2,1));
|
||||
VERIFY_IS_APPROX(mat6(1,0), mat1(1,0)*mat3(0,0) + mat1(1,1)*mat3(1,0) + mat1(1,2)*mat3(2,0));
|
||||
VERIFY_IS_APPROX(mat6(1,1), mat1(1,0)*mat3(0,1) + mat1(1,1)*mat3(1,1) + mat1(1,2)*mat3(2,1));
|
||||
}
|
||||
|
||||
|
||||
static void test_scalar()
|
||||
{
|
||||
Tensor<float, 1> vec1({6});
|
||||
Tensor<float, 1> vec2({6});
|
||||
|
||||
vec1.setRandom();
|
||||
vec2.setRandom();
|
||||
|
||||
Tensor<float, 1> scalar(1);
|
||||
scalar.setZero();
|
||||
Eigen::array<DimPair, 1> dims({{DimPair(0, 0)}});
|
||||
TensorEvaluator<decltype(vec1.contract(vec2, dims))> eval(vec1.contract(vec2, dims));
|
||||
eval.evalTo(scalar.data());
|
||||
EIGEN_STATIC_ASSERT(TensorEvaluator<decltype(vec1.contract(vec2, dims))>::NumDims==1ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
|
||||
|
||||
float expected = 0.0f;
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
expected += vec1(i) * vec2(i);
|
||||
}
|
||||
VERIFY_IS_APPROX(scalar(0), expected);
|
||||
}
|
||||
|
||||
|
||||
static void test_multidims()
|
||||
{
|
||||
Tensor<float, 3> mat1(2, 2, 2);
|
||||
Tensor<float, 4> mat2(2, 2, 2, 2);
|
||||
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
|
||||
Tensor<float, 3> mat3(2, 2, 2);
|
||||
mat3.setZero();
|
||||
Eigen::array<DimPair, 2> dims({{DimPair(1, 2), DimPair(2, 3)}});
|
||||
TensorEvaluator<decltype(mat1.contract(mat2, dims))> eval(mat1.contract(mat2, dims));
|
||||
eval.evalTo(mat3.data());
|
||||
EIGEN_STATIC_ASSERT(TensorEvaluator<decltype(mat1.contract(mat2, dims))>::NumDims==3ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
|
||||
VERIFY_IS_EQUAL(eval.dimensions()[0], 2);
|
||||
VERIFY_IS_EQUAL(eval.dimensions()[1], 2);
|
||||
VERIFY_IS_EQUAL(eval.dimensions()[2], 2);
|
||||
|
||||
VERIFY_IS_APPROX(mat3(0,0,0), mat1(0,0,0)*mat2(0,0,0,0) + mat1(0,1,0)*mat2(0,0,1,0) +
|
||||
mat1(0,0,1)*mat2(0,0,0,1) + mat1(0,1,1)*mat2(0,0,1,1));
|
||||
VERIFY_IS_APPROX(mat3(0,0,1), mat1(0,0,0)*mat2(0,1,0,0) + mat1(0,1,0)*mat2(0,1,1,0) +
|
||||
mat1(0,0,1)*mat2(0,1,0,1) + mat1(0,1,1)*mat2(0,1,1,1));
|
||||
VERIFY_IS_APPROX(mat3(0,1,0), mat1(0,0,0)*mat2(1,0,0,0) + mat1(0,1,0)*mat2(1,0,1,0) +
|
||||
mat1(0,0,1)*mat2(1,0,0,1) + mat1(0,1,1)*mat2(1,0,1,1));
|
||||
VERIFY_IS_APPROX(mat3(0,1,1), mat1(0,0,0)*mat2(1,1,0,0) + mat1(0,1,0)*mat2(1,1,1,0) +
|
||||
mat1(0,0,1)*mat2(1,1,0,1) + mat1(0,1,1)*mat2(1,1,1,1));
|
||||
VERIFY_IS_APPROX(mat3(1,0,0), mat1(1,0,0)*mat2(0,0,0,0) + mat1(1,1,0)*mat2(0,0,1,0) +
|
||||
mat1(1,0,1)*mat2(0,0,0,1) + mat1(1,1,1)*mat2(0,0,1,1));
|
||||
VERIFY_IS_APPROX(mat3(1,0,1), mat1(1,0,0)*mat2(0,1,0,0) + mat1(1,1,0)*mat2(0,1,1,0) +
|
||||
mat1(1,0,1)*mat2(0,1,0,1) + mat1(1,1,1)*mat2(0,1,1,1));
|
||||
VERIFY_IS_APPROX(mat3(1,1,0), mat1(1,0,0)*mat2(1,0,0,0) + mat1(1,1,0)*mat2(1,0,1,0) +
|
||||
mat1(1,0,1)*mat2(1,0,0,1) + mat1(1,1,1)*mat2(1,0,1,1));
|
||||
VERIFY_IS_APPROX(mat3(1,1,1), mat1(1,0,0)*mat2(1,1,0,0) + mat1(1,1,0)*mat2(1,1,1,0) +
|
||||
mat1(1,0,1)*mat2(1,1,0,1) + mat1(1,1,1)*mat2(1,1,1,1));
|
||||
}
|
||||
|
||||
|
||||
static void test_expr()
|
||||
{
|
||||
Tensor<float, 2> mat1(2, 3);
|
||||
Tensor<float, 2> mat2(3, 2);
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
|
||||
Tensor<float, 2> mat3(2,2);
|
||||
|
||||
Eigen::array<DimPair, 1> dims({{DimPair(1, 0)}});
|
||||
mat3 = mat1.contract(mat2, dims);
|
||||
|
||||
VERIFY_IS_APPROX(mat3(0,0), mat1(0,0)*mat2(0,0) + mat1(0,1)*mat2(1,0) + mat1(0,2)*mat2(2,0));
|
||||
VERIFY_IS_APPROX(mat3(0,1), mat1(0,0)*mat2(0,1) + mat1(0,1)*mat2(1,1) + mat1(0,2)*mat2(2,1));
|
||||
VERIFY_IS_APPROX(mat3(1,0), mat1(1,0)*mat2(0,0) + mat1(1,1)*mat2(1,0) + mat1(1,2)*mat2(2,0));
|
||||
VERIFY_IS_APPROX(mat3(1,1), mat1(1,0)*mat2(0,1) + mat1(1,1)*mat2(1,1) + mat1(1,2)*mat2(2,1));
|
||||
}
|
||||
|
||||
|
||||
void test_cxx11_tensor_contraction()
|
||||
{
|
||||
CALL_SUBTEST(test_evals());
|
||||
CALL_SUBTEST(test_scalar());
|
||||
CALL_SUBTEST(test_multidims());
|
||||
CALL_SUBTEST(test_expr());
|
||||
}
|
||||
@ -15,7 +15,7 @@
|
||||
|
||||
|
||||
#include "main.h"
|
||||
#include <Eigen/CXX11/Tensor>
|
||||
#include <unsupported/Eigen/CXX11/Tensor>
|
||||
|
||||
using Eigen::Tensor;
|
||||
using Eigen::RowMajor;
|
||||
@ -39,8 +39,12 @@ struct CPUContext {
|
||||
|
||||
// Context for evaluation on GPU
|
||||
struct GPUContext {
|
||||
GPUContext(const Eigen::TensorMap<Eigen::Tensor<float, 3> >& in1, Eigen::TensorMap<Eigen::Tensor<float, 3> >& in2, Eigen::TensorMap<Eigen::Tensor<float, 3> >& out) : in1_(in1), in2_(in2), out_(out) { }
|
||||
|
||||
GPUContext(const Eigen::TensorMap<Eigen::Tensor<float, 3> >& in1, Eigen::TensorMap<Eigen::Tensor<float, 3> >& in2, Eigen::TensorMap<Eigen::Tensor<float, 3> >& out) : in1_(in1), in2_(in2), out_(out), gpu_device_(&stream_) {
|
||||
cudaStreamCreate(&stream_);
|
||||
}
|
||||
~GPUContext() {
|
||||
cudaStreamDestroy(stream_);
|
||||
}
|
||||
const Eigen::TensorMap<Eigen::Tensor<float, 3> >& in1() const { return in1_; }
|
||||
const Eigen::TensorMap<Eigen::Tensor<float, 3> >& in2() const { return in2_; }
|
||||
Eigen::TensorDevice<Eigen::TensorMap<Eigen::Tensor<float, 3> >, Eigen::GpuDevice> out() { return TensorDevice<Eigen::TensorMap<Eigen::Tensor<float, 3> >, Eigen::GpuDevice>(gpu_device_, out_); }
|
||||
@ -49,6 +53,7 @@ struct GPUContext {
|
||||
const Eigen::TensorMap<Eigen::Tensor<float, 3> >& in1_;
|
||||
const Eigen::TensorMap<Eigen::Tensor<float, 3> >& in2_;
|
||||
Eigen::TensorMap<Eigen::Tensor<float, 3> >& out_;
|
||||
cudaStream_t stream_;
|
||||
Eigen::GpuDevice gpu_device_;
|
||||
};
|
||||
|
||||
@ -57,7 +62,7 @@ struct GPUContext {
|
||||
template <typename Context>
|
||||
static void test_contextual_eval(Context* context)
|
||||
{
|
||||
context->out() = context->in1() + context->in2() * 3.14f;
|
||||
context->out() = context->in1() + context->in2() * 3.14f + context->in1().constant(2.718f);
|
||||
}
|
||||
|
||||
static void test_cpu() {
|
||||
@ -73,7 +78,7 @@ static void test_cpu() {
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(out(Eigen::array<int, 3>(i,j,k)), in1(Eigen::array<int, 3>(i,j,k)) + in2(Eigen::array<int, 3>(i,j,k)) * 3.14f);
|
||||
VERIFY_IS_APPROX(out(Eigen::array<int, 3>(i,j,k)), in1(Eigen::array<int, 3>(i,j,k)) + in2(Eigen::array<int, 3>(i,j,k)) * 3.14f + 2.718f);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -111,7 +116,7 @@ static void test_gpu() {
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(out(Eigen::array<int, 3>(i,j,k)), in1(Eigen::array<int, 3>(i,j,k)) + in2(Eigen::array<int, 3>(i,j,k)) * 3.14f);
|
||||
VERIFY_IS_APPROX(out(Eigen::array<int, 3>(i,j,k)), in1(Eigen::array<int, 3>(i,j,k)) + in2(Eigen::array<int, 3>(i,j,k)) * 3.14f + 2.718f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -28,10 +28,10 @@ static void test_1d()
|
||||
|
||||
float data3[6];
|
||||
TensorMap<Tensor<float, 1>> vec3(data3, 6);
|
||||
vec3 = vec1.cwiseSqrt();
|
||||
vec3 = vec1.sqrt();
|
||||
float data4[6];
|
||||
TensorMap<Tensor<float, 1, RowMajor>> vec4(data4, 6);
|
||||
vec4 = vec2.cwiseSqrt();
|
||||
vec4 = vec2.square();
|
||||
|
||||
VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
|
||||
VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
|
||||
@ -40,12 +40,12 @@ static void test_1d()
|
||||
VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
|
||||
VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
|
||||
|
||||
VERIFY_IS_APPROX(vec4(0), sqrtf(0.0));
|
||||
VERIFY_IS_APPROX(vec4(1), sqrtf(1.0));
|
||||
VERIFY_IS_APPROX(vec4(2), sqrtf(2.0));
|
||||
VERIFY_IS_APPROX(vec4(3), sqrtf(3.0));
|
||||
VERIFY_IS_APPROX(vec4(4), sqrtf(4.0));
|
||||
VERIFY_IS_APPROX(vec4(5), sqrtf(5.0));
|
||||
VERIFY_IS_APPROX(vec4(0), 0.0f);
|
||||
VERIFY_IS_APPROX(vec4(1), 1.0f);
|
||||
VERIFY_IS_APPROX(vec4(2), 2.0f * 2.0f);
|
||||
VERIFY_IS_APPROX(vec4(3), 3.0f * 3.0f);
|
||||
VERIFY_IS_APPROX(vec4(4), 4.0f * 4.0f);
|
||||
VERIFY_IS_APPROX(vec4(5), 5.0f * 5.0f);
|
||||
|
||||
vec3 = vec1 + vec2;
|
||||
VERIFY_IS_APPROX(vec3(0), 4.0f + 0.0f);
|
||||
@ -79,8 +79,8 @@ static void test_2d()
|
||||
|
||||
Tensor<float, 2> mat3(2,3);
|
||||
Tensor<float, 2, RowMajor> mat4(2,3);
|
||||
mat3 = mat1.cwiseAbs();
|
||||
mat4 = mat2.cwiseAbs();
|
||||
mat3 = mat1.abs();
|
||||
mat4 = mat2.abs();
|
||||
|
||||
VERIFY_IS_APPROX(mat3(0,0), 0.0f);
|
||||
VERIFY_IS_APPROX(mat3(0,1), 1.0f);
|
||||
@ -102,7 +102,7 @@ static void test_3d()
|
||||
Tensor<float, 3> mat1(2,3,7);
|
||||
Tensor<float, 3, RowMajor> mat2(2,3,7);
|
||||
|
||||
float val = 0.0;
|
||||
float val = 1.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
@ -118,28 +118,147 @@ static void test_3d()
|
||||
Tensor<float, 3, RowMajor> mat4(2,3,7);
|
||||
mat4 = mat2 * 3.14f;
|
||||
Tensor<float, 3> mat5(2,3,7);
|
||||
mat5 = mat1.cwiseSqrt().cwiseSqrt();
|
||||
mat5 = mat1.inverse().log();
|
||||
Tensor<float, 3, RowMajor> mat6(2,3,7);
|
||||
mat6 = mat2.cwiseSqrt() * 3.14f;
|
||||
mat6 = mat2.pow(0.5f) * 3.14f;
|
||||
Tensor<float, 3> mat7(2,3,7);
|
||||
mat7 = mat1.cwiseMax(mat5 * 2.0f).exp();
|
||||
Tensor<float, 3, RowMajor> mat8(2,3,7);
|
||||
mat8 = (-mat2).exp() * 3.14f;
|
||||
|
||||
val = 0.0;
|
||||
val = 1.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(mat3(i,j,k), val + val);
|
||||
VERIFY_IS_APPROX(mat4(i,j,k), val * 3.14f);
|
||||
VERIFY_IS_APPROX(mat5(i,j,k), sqrtf(sqrtf(val)));
|
||||
VERIFY_IS_APPROX(mat5(i,j,k), logf(1.0f/val));
|
||||
VERIFY_IS_APPROX(mat6(i,j,k), sqrtf(val) * 3.14f);
|
||||
VERIFY_IS_APPROX(mat7(i,j,k), expf((std::max)(val, mat5(i,j,k) * 2.0f)));
|
||||
VERIFY_IS_APPROX(mat8(i,j,k), expf(-val) * 3.14f);
|
||||
val += 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void test_constants()
|
||||
{
|
||||
Tensor<float, 3> mat1(2,3,7);
|
||||
Tensor<float, 3> mat2(2,3,7);
|
||||
Tensor<float, 3> mat3(2,3,7);
|
||||
|
||||
float val = 1.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
mat1(i,j,k) = val;
|
||||
val += 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
mat2 = mat1.constant(3.14f);
|
||||
mat3 = mat1.cwiseMax(7.3f).exp();
|
||||
|
||||
val = 1.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(mat2(i,j,k), 3.14f);
|
||||
VERIFY_IS_APPROX(mat3(i,j,k), expf((std::max)(val, 7.3f)));
|
||||
val += 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void test_functors()
|
||||
{
|
||||
Tensor<float, 3> mat1(2,3,7);
|
||||
Tensor<float, 3> mat2(2,3,7);
|
||||
Tensor<float, 3> mat3(2,3,7);
|
||||
|
||||
float val = 1.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
mat1(i,j,k) = val;
|
||||
val += 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
mat2 = mat1.inverse().unaryExpr(&asinf);
|
||||
mat3 = mat1.unaryExpr(&tanhf);
|
||||
|
||||
val = 1.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(mat2(i,j,k), asinf(1.0f / mat1(i,j,k)));
|
||||
VERIFY_IS_APPROX(mat3(i,j,k), tanhf(mat1(i,j,k)));
|
||||
val += 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void test_type_casting()
|
||||
{
|
||||
Tensor<bool, 3> mat1(2,3,7);
|
||||
Tensor<float, 3> mat2(2,3,7);
|
||||
Tensor<double, 3> mat3(2,3,7);
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
|
||||
mat3 = mat1.template cast<double>();
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(mat3(i,j,k), mat1(i,j,k) ? 1.0 : 0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mat3 = mat2.template cast<double>();
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(mat3(i,j,k), static_cast<double>(mat2(i,j,k)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void test_select()
|
||||
{
|
||||
Tensor<float, 3> selector(2,3,7);
|
||||
Tensor<float, 3> mat1(2,3,7);
|
||||
Tensor<float, 3> mat2(2,3,7);
|
||||
Tensor<float, 3> result(2,3,7);
|
||||
|
||||
selector.setRandom();
|
||||
mat1.setRandom();
|
||||
mat2.setRandom();
|
||||
result = (selector > selector.constant(0.5f)).select(mat1, mat2);
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
for (int k = 0; k < 7; ++k) {
|
||||
VERIFY_IS_APPROX(result(i,j,k), (selector(i,j,k) > 0.5f) ? mat1(i,j,k) : mat2(i,j,k));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void test_cxx11_tensor_expr()
|
||||
{
|
||||
CALL_SUBTEST(test_1d());
|
||||
CALL_SUBTEST(test_2d());
|
||||
CALL_SUBTEST(test_3d());
|
||||
CALL_SUBTEST(test_constants());
|
||||
CALL_SUBTEST(test_functors());
|
||||
CALL_SUBTEST(test_type_casting());
|
||||
CALL_SUBTEST(test_select());
|
||||
}
|
||||
|
||||
@ -33,10 +33,10 @@ static void test_1d()
|
||||
|
||||
float data3[6];
|
||||
TensorMap<TensorFixedSize<float, Sizes<6> > > vec3(data3, 6);
|
||||
vec3 = vec1.cwiseSqrt();
|
||||
vec3 = vec1.sqrt();
|
||||
float data4[6];
|
||||
TensorMap<TensorFixedSize<float, Sizes<6>, RowMajor> > vec4(data4, 6);
|
||||
vec4 = vec2.cwiseSqrt();
|
||||
vec4 = vec2.sqrt();
|
||||
|
||||
VERIFY_IS_EQUAL((vec3.size()), 6);
|
||||
// VERIFY_IS_EQUAL((vec3.dimensions()[0]), 6);
|
||||
@ -92,8 +92,8 @@ static void test_2d()
|
||||
|
||||
TensorFixedSize<float, Sizes<2, 3>> mat3;
|
||||
TensorFixedSize<float, Sizes<2, 3>, RowMajor> mat4;
|
||||
mat3 = mat1.cwiseAbs();
|
||||
mat4 = mat2.cwiseAbs();
|
||||
mat3 = mat1.abs();
|
||||
mat4 = mat2.abs();
|
||||
|
||||
VERIFY_IS_EQUAL((mat3.size()), 2*3);
|
||||
// VERIFY_IS_EQUAL((mat3.dimension(0)), 2);
|
||||
@ -136,9 +136,9 @@ static void test_3d()
|
||||
}
|
||||
|
||||
TensorFixedSize<float, Sizes<2, 3, 7> > mat3;
|
||||
mat3 = mat1.cwiseSqrt();
|
||||
mat3 = mat1.sqrt();
|
||||
TensorFixedSize<float, Sizes<2, 3, 7>, RowMajor> mat4;
|
||||
mat4 = mat2.cwiseSqrt();
|
||||
mat4 = mat2.sqrt();
|
||||
|
||||
VERIFY_IS_EQUAL((mat3.size()), 2*3*7);
|
||||
// VERIFY_IS_EQUAL((mat3.dimension(0)), 2);
|
||||
@ -173,7 +173,7 @@ static void test_array()
|
||||
}
|
||||
|
||||
TensorFixedSize<float, Sizes<2, 3, 7> > mat3;
|
||||
mat3 = mat1.cwisePow(3.5f);
|
||||
mat3 = mat1.pow(3.5f);
|
||||
|
||||
val = 0.0;
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
|
||||
#include "main.h"
|
||||
#include <Eigen/CXX11/Tensor>
|
||||
#include "thread/threadpool.h"
|
||||
|
||||
using Eigen::Tensor;
|
||||
|
||||
@ -24,8 +25,10 @@ void test_cxx11_tensor_thread_pool()
|
||||
in1.setRandom();
|
||||
in2.setRandom();
|
||||
|
||||
Eigen::ThreadPoolDevice thread_pool_device(3);
|
||||
out.device(thread_pool_device) = in1 + in2 * 3.14;
|
||||
ThreadPool thread_pool(2);
|
||||
thread_pool.StartWorkers();
|
||||
Eigen::ThreadPoolDevice thread_pool_device(&thread_pool, 3);
|
||||
out.device(thread_pool_device) = in1 + in2 * 3.14f;
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user