mirror of
https://gitlab.com/libeigen/eigen.git
synced 2026-04-10 11:34:33 +08:00
Reimplemented the Tensor stream output.
This commit is contained in:
cpp977
committed by
Rasmus Munk Larsen
Rasmus Munk Larsen
parent
2b9297196c
commit
f73c95c032
@@ -14,68 +14,361 @@
|
||||
|
||||
namespace Eigen {
|
||||
|
||||
struct TensorIOFormat;
|
||||
|
||||
namespace internal {
|
||||
|
||||
// Print the tensor as a 2d matrix
|
||||
template <typename Tensor, int Rank>
|
||||
struct TensorPrinter {
|
||||
static void run (std::ostream& os, const Tensor& tensor) {
|
||||
typedef typename internal::remove_const<typename Tensor::Scalar>::type Scalar;
|
||||
typedef typename Tensor::Index Index;
|
||||
const Index total_size = internal::array_prod(tensor.dimensions());
|
||||
if (total_size > 0) {
|
||||
const Index first_dim = Eigen::internal::array_get<0>(tensor.dimensions());
|
||||
static const int layout = Tensor::Layout;
|
||||
Map<const Array<Scalar, Dynamic, Dynamic, layout> > matrix(const_cast<Scalar*>(tensor.data()), first_dim, total_size/first_dim);
|
||||
os << matrix;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Print the tensor as a vector
|
||||
template <typename Tensor>
|
||||
struct TensorPrinter<Tensor, 1> {
|
||||
static void run (std::ostream& os, const Tensor& tensor) {
|
||||
typedef typename internal::remove_const<typename Tensor::Scalar>::type Scalar;
|
||||
typedef typename Tensor::Index Index;
|
||||
const Index total_size = internal::array_prod(tensor.dimensions());
|
||||
if (total_size > 0) {
|
||||
Map<const Array<Scalar, Dynamic, 1> > array(const_cast<Scalar*>(tensor.data()), total_size);
|
||||
os << array;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Print the tensor as a scalar
|
||||
template <typename Tensor>
|
||||
struct TensorPrinter<Tensor, 0> {
|
||||
static void run (std::ostream& os, const Tensor& tensor) {
|
||||
os << tensor.coeff(0);
|
||||
}
|
||||
};
|
||||
template <typename Tensor, std::size_t rank>
|
||||
struct TensorPrinter;
|
||||
}
|
||||
|
||||
struct TensorIOFormat {
|
||||
TensorIOFormat(const std::vector<std::string>& _separator, const std::vector<std::string>& _prefix,
|
||||
const std::vector<std::string>& _suffix, int _precision = StreamPrecision, int _flags = 0,
|
||||
const std::string& _tenPrefix = "", const std::string& _tenSuffix = "", const char _fill = ' ')
|
||||
: tenPrefix(_tenPrefix),
|
||||
tenSuffix(_tenSuffix),
|
||||
prefix(_prefix),
|
||||
suffix(_suffix),
|
||||
separator(_separator),
|
||||
fill(_fill),
|
||||
precision(_precision),
|
||||
flags(_flags) {
|
||||
init_spacer();
|
||||
}
|
||||
|
||||
TensorIOFormat(int _precision = StreamPrecision, int _flags = 0, const std::string& _tenPrefix = "",
|
||||
const std::string& _tenSuffix = "", const char _fill = ' ')
|
||||
: tenPrefix(_tenPrefix), tenSuffix(_tenSuffix), fill(_fill), precision(_precision), flags(_flags) {
|
||||
// default values of prefix, suffix and separator
|
||||
prefix = {"", "["};
|
||||
suffix = {"", "]"};
|
||||
separator = {", ", "\n"};
|
||||
|
||||
init_spacer();
|
||||
}
|
||||
|
||||
void init_spacer() {
|
||||
if ((flags & DontAlignCols)) return;
|
||||
spacer.resize(prefix.size());
|
||||
spacer[0] = "";
|
||||
int i = int(tenPrefix.length()) - 1;
|
||||
while (i >= 0 && tenPrefix[i] != '\n') {
|
||||
spacer[0] += ' ';
|
||||
i--;
|
||||
}
|
||||
|
||||
for (std::size_t k = 1; k < prefix.size(); k++) {
|
||||
int i = int(prefix[k].length()) - 1;
|
||||
while (i >= 0 && prefix[k][i] != '\n') {
|
||||
spacer[k] += ' ';
|
||||
i--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline const TensorIOFormat Numpy() {
|
||||
std::vector<std::string> prefix = {"", "["};
|
||||
std::vector<std::string> suffix = {"", "]"};
|
||||
std::vector<std::string> separator = {" ", "\n"};
|
||||
return TensorIOFormat(separator, prefix, suffix, StreamPrecision, 0, "[", "]");
|
||||
}
|
||||
|
||||
static inline const TensorIOFormat Plain() {
|
||||
std::vector<std::string> separator = {" ", "\n", "\n", ""};
|
||||
std::vector<std::string> prefix = {""};
|
||||
std::vector<std::string> suffix = {""};
|
||||
return TensorIOFormat(separator, prefix, suffix, StreamPrecision, 0, "", "", ' ');
|
||||
}
|
||||
|
||||
static inline const TensorIOFormat Native() {
|
||||
std::vector<std::string> separator = {", ", ",\n", "\n"};
|
||||
std::vector<std::string> prefix = {"", "{"};
|
||||
std::vector<std::string> suffix = {"", "}"};
|
||||
return TensorIOFormat(separator, prefix, suffix, StreamPrecision, 0, "{", "}", ' ');
|
||||
}
|
||||
|
||||
static inline const TensorIOFormat Legacy() {
|
||||
TensorIOFormat LegacyFormat(StreamPrecision, 0, "", "", ' ');
|
||||
LegacyFormat.legacy_bit = true;
|
||||
return LegacyFormat;
|
||||
}
|
||||
|
||||
std::string tenPrefix;
|
||||
std::string tenSuffix;
|
||||
std::vector<std::string> prefix;
|
||||
std::vector<std::string> suffix;
|
||||
std::vector<std::string> separator;
|
||||
char fill;
|
||||
int precision;
|
||||
int flags;
|
||||
std::vector<std::string> spacer{};
|
||||
bool legacy_bit = false;
|
||||
};
|
||||
|
||||
template <typename T, int Layout, int rank>
|
||||
class TensorWithFormat;
|
||||
// specialize for Layout=ColMajor, Layout=RowMajor and rank=0.
|
||||
template <typename T, int rank>
|
||||
class TensorWithFormat<T, RowMajor, rank> {
|
||||
public:
|
||||
TensorWithFormat(const T& tensor, const TensorIOFormat& format) : t_tensor(tensor), t_format(format) {}
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, RowMajor, rank>& wf) {
|
||||
// Evaluate the expression if needed
|
||||
typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
|
||||
TensorForcedEvalOp<const T> eval = wf.t_tensor.eval();
|
||||
Evaluator tensor(eval, DefaultDevice());
|
||||
tensor.evalSubExprsIfNeeded(NULL);
|
||||
internal::TensorPrinter<Evaluator, rank>::run(os, tensor, wf.t_format);
|
||||
// Cleanup.
|
||||
tensor.cleanup();
|
||||
return os;
|
||||
}
|
||||
|
||||
protected:
|
||||
T t_tensor;
|
||||
TensorIOFormat t_format;
|
||||
};
|
||||
|
||||
template <typename T, int rank>
|
||||
class TensorWithFormat<T, ColMajor, rank> {
|
||||
public:
|
||||
TensorWithFormat(const T& tensor, const TensorIOFormat& format) : t_tensor(tensor), t_format(format) {}
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, ColMajor, rank>& wf) {
|
||||
// Switch to RowMajor storage and print afterwards
|
||||
typedef typename T::Index Index;
|
||||
std::array<Index, rank> shuffle;
|
||||
std::array<Index, rank> id;
|
||||
std::iota(id.begin(), id.end(), Index(0));
|
||||
std::copy(id.begin(), id.end(), shuffle.rbegin());
|
||||
auto tensor_row_major = wf.t_tensor.swap_layout().shuffle(shuffle);
|
||||
|
||||
// Evaluate the expression if needed
|
||||
typedef TensorEvaluator<const TensorForcedEvalOp<const decltype(tensor_row_major)>, DefaultDevice> Evaluator;
|
||||
TensorForcedEvalOp<const decltype(tensor_row_major)> eval = tensor_row_major.eval();
|
||||
Evaluator tensor(eval, DefaultDevice());
|
||||
tensor.evalSubExprsIfNeeded(NULL);
|
||||
internal::TensorPrinter<Evaluator, rank>::run(os, tensor, wf.t_format);
|
||||
// Cleanup.
|
||||
tensor.cleanup();
|
||||
return os;
|
||||
}
|
||||
|
||||
protected:
|
||||
T t_tensor;
|
||||
TensorIOFormat t_format;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
std::ostream& operator << (std::ostream& os, const TensorBase<T, ReadOnlyAccessors>& expr) {
|
||||
typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
|
||||
typedef typename Evaluator::Dimensions Dimensions;
|
||||
class TensorWithFormat<T, ColMajor, 0> {
|
||||
public:
|
||||
TensorWithFormat(const T& tensor, const TensorIOFormat& format) : t_tensor(tensor), t_format(format) {}
|
||||
|
||||
// Evaluate the expression if needed
|
||||
TensorForcedEvalOp<const T> eval = expr.eval();
|
||||
Evaluator tensor(eval, DefaultDevice());
|
||||
tensor.evalSubExprsIfNeeded(NULL);
|
||||
friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, ColMajor, 0>& wf) {
|
||||
// Evaluate the expression if needed
|
||||
typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
|
||||
TensorForcedEvalOp<const T> eval = wf.t_tensor.eval();
|
||||
Evaluator tensor(eval, DefaultDevice());
|
||||
tensor.evalSubExprsIfNeeded(NULL);
|
||||
internal::TensorPrinter<Evaluator, 0>::run(os, tensor, wf.t_format);
|
||||
// Cleanup.
|
||||
tensor.cleanup();
|
||||
return os;
|
||||
}
|
||||
|
||||
// Print the result
|
||||
static const int rank = internal::array_size<Dimensions>::value;
|
||||
internal::TensorPrinter<Evaluator, rank>::run(os, tensor);
|
||||
protected:
|
||||
T t_tensor;
|
||||
TensorIOFormat t_format;
|
||||
};
|
||||
|
||||
// Cleanup.
|
||||
tensor.cleanup();
|
||||
return os;
|
||||
namespace internal {
|
||||
template <typename Tensor, std::size_t rank>
|
||||
struct TensorPrinter {
|
||||
static void run(std::ostream& s, const Tensor& _t, const TensorIOFormat& fmt) {
|
||||
typedef typename Tensor::Scalar Scalar;
|
||||
typedef typename Tensor::Index Index;
|
||||
static const int layout = Tensor::Layout;
|
||||
// backwards compatibility case: print tensor after reshaping to matrix of size dim(0) x
|
||||
// (dim(1)*dim(2)*...*dim(rank-1)).
|
||||
if (fmt.legacy_bit) {
|
||||
const Index total_size = internal::array_prod(_t.dimensions());
|
||||
if (total_size > 0) {
|
||||
const Index first_dim = Eigen::internal::array_get<0>(_t.dimensions());
|
||||
Map<const Array<Scalar, Dynamic, Dynamic, layout> > matrix(const_cast<Scalar*>(_t.data()), first_dim,
|
||||
total_size / first_dim);
|
||||
s << matrix;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
assert(layout == RowMajor);
|
||||
typedef typename conditional<is_same<Scalar, char>::value || is_same<Scalar, unsigned char>::value ||
|
||||
is_same<Scalar, numext::int8_t>::value || is_same<Scalar, numext::uint8_t>::value,
|
||||
int,
|
||||
typename conditional<is_same<Scalar, std::complex<char> >::value ||
|
||||
is_same<Scalar, std::complex<unsigned char> >::value ||
|
||||
is_same<Scalar, std::complex<numext::int8_t> >::value ||
|
||||
is_same<Scalar, std::complex<numext::uint8_t> >::value,
|
||||
std::complex<int>, const Scalar&>::type>::type PrintType;
|
||||
|
||||
const Index total_size = array_prod(_t.dimensions());
|
||||
|
||||
std::streamsize explicit_precision;
|
||||
if (fmt.precision == StreamPrecision) {
|
||||
explicit_precision = 0;
|
||||
} else if (fmt.precision == FullPrecision) {
|
||||
if (NumTraits<Scalar>::IsInteger) {
|
||||
explicit_precision = 0;
|
||||
} else {
|
||||
explicit_precision = significant_decimals_impl<Scalar>::run();
|
||||
}
|
||||
} else {
|
||||
explicit_precision = fmt.precision;
|
||||
}
|
||||
|
||||
std::streamsize old_precision = 0;
|
||||
if (explicit_precision) old_precision = s.precision(explicit_precision);
|
||||
|
||||
Index width = 0;
|
||||
|
||||
bool align_cols = !(fmt.flags & DontAlignCols);
|
||||
if (align_cols) {
|
||||
// compute the largest width
|
||||
for (Index i = 0; i < total_size; i++) {
|
||||
std::stringstream sstr;
|
||||
sstr.copyfmt(s);
|
||||
sstr << static_cast<PrintType>(_t.data()[i]);
|
||||
width = std::max<Index>(width, Index(sstr.str().length()));
|
||||
}
|
||||
}
|
||||
std::streamsize old_width = s.width();
|
||||
char old_fill_character = s.fill();
|
||||
|
||||
s << fmt.tenPrefix;
|
||||
for (Index i = 0; i < total_size; i++) {
|
||||
std::array<bool, rank> is_at_end{};
|
||||
std::array<bool, rank> is_at_begin{};
|
||||
|
||||
// is the ith element the end of an coeff (always true), of a row, of a matrix, ...?
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
if ((i + 1) % (std::accumulate(_t.dimensions().rbegin(), _t.dimensions().rbegin() + k, 1,
|
||||
std::multiplies<Index>())) ==
|
||||
0) {
|
||||
is_at_end[k] = true;
|
||||
}
|
||||
}
|
||||
|
||||
// is the ith element the begin of an coeff (always true), of a row, of a matrix, ...?
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
if (i % (std::accumulate(_t.dimensions().rbegin(), _t.dimensions().rbegin() + k, 1,
|
||||
std::multiplies<Index>())) ==
|
||||
0) {
|
||||
is_at_begin[k] = true;
|
||||
}
|
||||
}
|
||||
|
||||
// do we have a line break?
|
||||
bool is_at_begin_after_newline = false;
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
if (is_at_begin[k]) {
|
||||
std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
|
||||
if (fmt.separator[separator_index].find('\n') != std::string::npos) {
|
||||
is_at_begin_after_newline = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool is_at_end_before_newline = false;
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
if (is_at_end[k]) {
|
||||
std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
|
||||
if (fmt.separator[separator_index].find('\n') != std::string::npos) {
|
||||
is_at_end_before_newline = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::stringstream suffix, prefix, separator;
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
std::size_t suffix_index = (k < fmt.suffix.size()) ? k : fmt.suffix.size() - 1;
|
||||
if (is_at_end[k]) {
|
||||
suffix << fmt.suffix[suffix_index];
|
||||
}
|
||||
}
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
|
||||
if (is_at_end[k] and
|
||||
(!is_at_end_before_newline or fmt.separator[separator_index].find('\n') != std::string::npos)) {
|
||||
separator << fmt.separator[separator_index];
|
||||
}
|
||||
}
|
||||
for (std::size_t k = 0; k < rank; k++) {
|
||||
std::size_t spacer_index = (k < fmt.spacer.size()) ? k : fmt.spacer.size() - 1;
|
||||
if (i != 0 and is_at_begin_after_newline and (!is_at_begin[k] or k == 0)) {
|
||||
prefix << fmt.spacer[spacer_index];
|
||||
}
|
||||
}
|
||||
for (int k = rank - 1; k >= 0; k--) {
|
||||
std::size_t prefix_index = (static_cast<std::size_t>(k) < fmt.prefix.size()) ? k : fmt.prefix.size() - 1;
|
||||
if (is_at_begin[k]) {
|
||||
prefix << fmt.prefix[prefix_index];
|
||||
}
|
||||
}
|
||||
|
||||
s << prefix.str();
|
||||
if (width) {
|
||||
s.fill(fmt.fill);
|
||||
s.width(width);
|
||||
s << std::right;
|
||||
}
|
||||
s << _t.data()[i];
|
||||
s << suffix.str();
|
||||
if (i < total_size - 1) {
|
||||
s << separator.str();
|
||||
}
|
||||
}
|
||||
s << fmt.tenSuffix;
|
||||
if (explicit_precision) s.precision(old_precision);
|
||||
if (width) {
|
||||
s.fill(old_fill_character);
|
||||
s.width(old_width);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Tensor>
|
||||
struct TensorPrinter<Tensor, 0> {
|
||||
static void run(std::ostream& s, const Tensor& _t, const TensorIOFormat& fmt) {
|
||||
typedef typename Tensor::Scalar Scalar;
|
||||
|
||||
std::streamsize explicit_precision;
|
||||
if (fmt.precision == StreamPrecision) {
|
||||
explicit_precision = 0;
|
||||
} else if (fmt.precision == FullPrecision) {
|
||||
if (NumTraits<Scalar>::IsInteger) {
|
||||
explicit_precision = 0;
|
||||
} else {
|
||||
explicit_precision = significant_decimals_impl<Scalar>::run();
|
||||
}
|
||||
} else {
|
||||
explicit_precision = fmt.precision;
|
||||
}
|
||||
|
||||
std::streamsize old_precision = 0;
|
||||
if (explicit_precision) old_precision = s.precision(explicit_precision);
|
||||
|
||||
s << fmt.tenPrefix << _t.coeff(0) << fmt.tenSuffix;
|
||||
if (explicit_precision) s.precision(old_precision);
|
||||
}
|
||||
};
|
||||
|
||||
} // end namespace internal
|
||||
template <typename T>
|
||||
std::ostream& operator<<(std::ostream& s, const TensorBase<T, ReadOnlyAccessors>& t) {
|
||||
s << t.format(TensorIOFormat::Plain());
|
||||
return s;
|
||||
}
|
||||
} // end namespace Eigen
|
||||
|
||||
} // end namespace Eigen
|
||||
|
||||
#endif // EIGEN_CXX11_TENSOR_TENSOR_IO_H
|
||||
#endif // EIGEN_CXX11_TENSOR_TENSOR_IO_H
|
||||
|
||||
Reference in New Issue
Block a user