| // This file is part of Eigen, a lightweight C++ template library |
| // for linear algebra. |
| // |
| // Copyright (C) 2015 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> |
| |
| #if EIGEN_COMP_MSVC || !defined(__SIZEOF_INT128__) |
| #define EIGEN_NO_INT128 |
| #else |
| typedef __uint128_t uint128_t; |
| #endif |
| |
| // Only run the test on compilers that support 128bit integers natively |
| #ifndef EIGEN_NO_INT128 |
| |
| using Eigen::internal::static_val; |
| using Eigen::internal::TensorUInt128; |
| |
| void VERIFY_EQUAL(TensorUInt128<uint64_t, uint64_t> actual, uint128_t expected) { |
| bool matchl = actual.lower() == static_cast<uint64_t>(expected); |
| bool matchh = actual.upper() == static_cast<uint64_t>(expected >> 64); |
| if (!matchl || !matchh) { |
| const char* testname = g_test_stack.back().c_str(); |
| std::cerr << "Test " << testname << " failed in " << __FILE__ << " (" << __LINE__ << ")" << std::endl; |
| abort(); |
| } |
| } |
| |
| void test_add() { |
| uint64_t incr = internal::random<uint64_t>(1, 9999999999); |
| for (uint64_t i1 = 0; i1 < 100; ++i1) { |
| for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> i(i1, i2); |
| uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2); |
| for (uint64_t j1 = 0; j1 < 100; ++j1) { |
| for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> j(j1, j2); |
| uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2); |
| TensorUInt128<uint64_t, uint64_t> actual = i + j; |
| uint128_t expected = a + b; |
| VERIFY_EQUAL(actual, expected); |
| } |
| } |
| } |
| } |
| } |
| |
| void test_sub() { |
| uint64_t incr = internal::random<uint64_t>(1, 9999999999); |
| for (uint64_t i1 = 0; i1 < 100; ++i1) { |
| for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> i(i1, i2); |
| uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2); |
| for (uint64_t j1 = 0; j1 < 100; ++j1) { |
| for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> j(j1, j2); |
| uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2); |
| TensorUInt128<uint64_t, uint64_t> actual = i - j; |
| uint128_t expected = a - b; |
| VERIFY_EQUAL(actual, expected); |
| } |
| } |
| } |
| } |
| } |
| |
| void test_mul() { |
| uint64_t incr = internal::random<uint64_t>(1, 9999999999); |
| for (uint64_t i1 = 0; i1 < 100; ++i1) { |
| for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> i(i1, i2); |
| uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2); |
| for (uint64_t j1 = 0; j1 < 100; ++j1) { |
| for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> j(j1, j2); |
| uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2); |
| TensorUInt128<uint64_t, uint64_t> actual = i * j; |
| uint128_t expected = a * b; |
| VERIFY_EQUAL(actual, expected); |
| } |
| } |
| } |
| } |
| } |
| |
| void test_div() { |
| uint64_t incr = internal::random<uint64_t>(1, 9999999999); |
| for (uint64_t i1 = 0; i1 < 100; ++i1) { |
| for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> i(i1, i2); |
| uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2); |
| for (uint64_t j1 = 0; j1 < 100; ++j1) { |
| for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) { |
| TensorUInt128<uint64_t, uint64_t> j(j1, j2); |
| uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2); |
| TensorUInt128<uint64_t, uint64_t> actual = i / j; |
| uint128_t expected = a / b; |
| VERIFY_EQUAL(actual, expected); |
| } |
| } |
| } |
| } |
| } |
| |
| void test_misc1() { |
| uint64_t incr = internal::random<uint64_t>(1, 9999999999); |
| for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) { |
| TensorUInt128<static_val<0>, uint64_t> i(0, i2); |
| uint128_t a = static_cast<uint128_t>(i2); |
| for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) { |
| TensorUInt128<static_val<0>, uint64_t> j(0, j2); |
| uint128_t b = static_cast<uint128_t>(j2); |
| uint64_t actual = (i * j).upper(); |
| uint64_t expected = (a * b) >> 64; |
| VERIFY_IS_EQUAL(actual, expected); |
| } |
| } |
| } |
| |
| void test_misc2() { |
| int64_t incr = internal::random<int64_t>(1, 100); |
| for (int64_t log_div = 0; log_div < 63; ++log_div) { |
| for (int64_t divider = 1; divider <= 1000000 * incr; divider += incr) { |
| uint64_t expected = (static_cast<uint128_t>(1) << (64 + log_div)) / static_cast<uint128_t>(divider) - |
| (static_cast<uint128_t>(1) << 64) + 1; |
| uint64_t shift = 1ULL << log_div; |
| |
| TensorUInt128<uint64_t, uint64_t> result = |
| (TensorUInt128<uint64_t, static_val<0> >(shift, 0) / TensorUInt128<static_val<0>, uint64_t>(divider) - |
| TensorUInt128<static_val<1>, static_val<0> >(1, 0) + TensorUInt128<static_val<0>, static_val<1> >(1)); |
| uint64_t actual = static_cast<uint64_t>(result); |
| VERIFY_IS_EQUAL(actual, expected); |
| } |
| } |
| } |
| #endif |
| |
| EIGEN_DECLARE_TEST(cxx11_tensor_uint128) { |
| #ifdef EIGEN_NO_INT128 |
| // Skip the test on compilers that don't support 128bit integers natively |
| return; |
| #else |
| CALL_SUBTEST_1(test_add()); |
| CALL_SUBTEST_2(test_sub()); |
| CALL_SUBTEST_3(test_mul()); |
| CALL_SUBTEST_4(test_div()); |
| CALL_SUBTEST_5(test_misc1()); |
| CALL_SUBTEST_6(test_misc2()); |
| #endif |
| } |