blob: 378a7b1f6de6e22124e25564139da251a4c9dfd7 [file]
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2019 Joel Holdsworth <joel.holdsworth@vcatechnology.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/.
// SPDX-License-Identifier: MPL-2.0
#include <sstream>
#include "main.h"
namespace stream_precision_test {
struct Rational {
int numerator;
int denominator;
Rational(int n = 0, int d = 1) : numerator(n), denominator(d) {}
};
struct BinaryScalar {
double value;
};
double log2(const BinaryScalar& value) { return std::log2(value.value); }
struct IncompleteScalar {};
struct UnsupportedLog {};
UnsupportedLog log2(const IncompleteScalar&) { return {}; }
struct ExplicitPrecision {};
struct MetadataReal {};
struct MetadataScalar {
double value;
MetadataScalar(double x = 0) : value(x) {}
};
std::ostream& operator<<(std::ostream& stream, const MetadataScalar& value) { return stream << value.value; }
std::ostream& operator<<(std::ostream& stream, const Rational& value) {
return stream << (std::to_string(value.numerator) + '/' + std::to_string(value.denominator));
}
} // namespace stream_precision_test
namespace std {
template <>
class numeric_limits<stream_precision_test::MetadataReal> : public numeric_limits<double> {};
} // namespace std
namespace Eigen {
template <>
struct NumTraits<stream_precision_test::Rational> : GenericNumTraits<stream_precision_test::Rational> {};
template <>
struct NumTraits<stream_precision_test::BinaryScalar> : GenericNumTraits<stream_precision_test::BinaryScalar> {
static stream_precision_test::BinaryScalar epsilon() { return {1.0 / 1024}; }
};
template <>
struct NumTraits<stream_precision_test::ExplicitPrecision>
: GenericNumTraits<stream_precision_test::ExplicitPrecision> {
static constexpr int digits() { return 11; }
static constexpr int digits10() { return 3; }
static constexpr int max_digits10() { return 5; }
};
template <>
struct NumTraits<stream_precision_test::MetadataScalar> : GenericNumTraits<stream_precision_test::MetadataScalar> {
using Real = stream_precision_test::MetadataReal;
};
} // namespace Eigen
void check_custom_scalar_precision() {
using MetadataScalar = stream_precision_test::MetadataScalar;
VERIFY_IS_EQUAL(NumTraits<MetadataScalar>::digits10(), 15);
VERIFY_IS_EQUAL(NumTraits<MetadataScalar>::max_digits10(), 17);
Matrix<MetadataScalar, 1, 1> decimal;
decimal(0) = MetadataScalar(1.2345678901234567);
std::ostringstream full_precision;
full_precision << decimal.format(IOFormat(FullPrecision));
VERIFY(full_precision.str() == "1.2345678901234567");
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::BinaryScalar>::digits(), 11);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::BinaryScalar>::digits10(), 3);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::BinaryScalar>::max_digits10(), 5);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::IncompleteScalar>::digits10(), 0);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::IncompleteScalar>::max_digits10(), 0);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::ExplicitPrecision>::digits(), 11);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::ExplicitPrecision>::digits10(), 3);
VERIFY_IS_EQUAL(NumTraits<stream_precision_test::ExplicitPrecision>::max_digits10(), 5);
VERIFY_IS_EQUAL(NumTraits<double>::max_digits10(), std::numeric_limits<double>::max_digits10);
using Scalar = stream_precision_test::Rational;
VERIFY_IS_EQUAL(NumTraits<Scalar>::digits10(), 0);
VERIFY_IS_EQUAL(NumTraits<Scalar>::max_digits10(), 0);
Matrix<Scalar, 2, 1> values;
values << Scalar(1, 2), Scalar(3, 4);
const int precisions[] = {StreamPrecision, FullPrecision, 4};
for (int precision : precisions) {
std::ostringstream stream;
stream.precision(7);
stream << values.format(IOFormat(precision));
VERIFY(stream.str() == "1/2\n3/4");
VERIFY_IS_EQUAL(stream.precision(), 7);
}
std::ostringstream stream;
stream << values;
VERIFY(stream.str() == "1/2\n3/4");
}
template <typename Scalar>
struct check_ostream_impl {
static void run() {
const Array<Scalar, 1, 1> array(123);
std::ostringstream ss;
ss << array;
VERIFY(ss.str() == "123");
check_ostream_impl<std::complex<Scalar> >::run();
};
};
template <>
struct check_ostream_impl<bool> {
static void run() {
const Array<bool, 1, 2> array(1, 0);
std::ostringstream ss;
ss << array;
VERIFY(ss.str() == "1 0");
};
};
template <typename Scalar>
struct check_ostream_impl<std::complex<Scalar> > {
static void run() {
const Array<std::complex<Scalar>, 1, 1> array(std::complex<Scalar>(12, 34));
std::ostringstream ss;
ss << array;
VERIFY(ss.str() == "(12,34)");
};
};
template <typename Scalar>
static void check_ostream() {
check_ostream_impl<Scalar>::run();
}
EIGEN_DECLARE_TEST(io) {
CALL_SUBTEST(check_custom_scalar_precision());
CALL_SUBTEST(check_ostream<bool>());
CALL_SUBTEST(check_ostream<float>());
CALL_SUBTEST(check_ostream<double>());
CALL_SUBTEST(check_ostream<Eigen::numext::int8_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::uint8_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::int16_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::uint16_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::int32_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::uint32_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::int64_t>());
CALL_SUBTEST(check_ostream<Eigen::numext::uint64_t>());
}