/usr/local/lib64/python3.6/site-packages/torch/include/c10/core
Edit: /usr/local/lib64/python3.6/site-packages/torch/include/c10/core/Scalar.h (6019B)
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace c10 {
/**
* Scalar represents a 0-dimensional tensor which contains a single element.
* Unlike a tensor, numeric literals (in C++) are implicitly convertible to
* Scalar (which is why, for example, we provide both add(Tensor) and
* add(Scalar) overloads for many operations). It may also be used in
* circumstances where you statically know a tensor is 0-dim and single size,
* but don't know its type.
*/
class C10_API Scalar {
public:
Scalar() : Scalar(int64_t(0)) {}
#define DEFINE_IMPLICIT_CTOR(type, name) \
Scalar(type vv) : Scalar(vv, true) {}
AT_FORALL_SCALAR_TYPES_AND2(Half, BFloat16, DEFINE_IMPLICIT_CTOR)
AT_FORALL_COMPLEX_TYPES(DEFINE_IMPLICIT_CTOR)
#undef DEFINE_IMPLICIT_CTOR
// Value* is both implicitly convertible to SymbolicVariable and bool which
// causes ambiguity error. Specialized constructor for bool resolves this
// problem.
template <
typename T,
typename std::enable_if::value, bool>::type* =
nullptr>
Scalar(T vv) : tag(Tag::HAS_b) {
v.i = convert(vv);
}
#define DEFINE_ACCESSOR(type, name) \
type to##name() const { \
if (Tag::HAS_d == tag) { \
return checked_convert(v.d, #type); \
} else if (Tag::HAS_z == tag) { \
return checked_convert>(v.z, #type); \
} \
if (Tag::HAS_b == tag) { \
return checked_convert(v.i, #type); \
} else { \
return checked_convert(v.i, #type); \
} \
}
// TODO: Support ComplexHalf accessor
AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(DEFINE_ACCESSOR)
// also support scalar.to();
// Deleted for unsupported types, but specialized below for supported types
template
T to() const = delete;
#undef DEFINE_ACCESSOR
bool isFloatingPoint() const {
return Tag::HAS_d == tag;
}
C10_DEPRECATED_MESSAGE(
"isIntegral is deprecated. Please use the overload with 'includeBool' parameter instead.")
bool isIntegral() const {
return Tag::HAS_i == tag;
}
bool isIntegral(bool includeBool) const {
return Tag::HAS_i == tag || (includeBool && isBoolean());
}
bool isComplex() const {
return Tag::HAS_z == tag;
}
bool isBoolean() const {
return Tag::HAS_b == tag;
}
Scalar operator-() const;
Scalar conj() const;
Scalar log() const;
template <
typename T,
typename std::enable_if::value, int>::type = 0>
bool equal(T num) const {
if (isComplex()) {
auto val = v.z;
return (val.real() == num) && (val.imag() == T());
} else if (isFloatingPoint()) {
return v.d == num;
} else if (isIntegral(/*includeBool=*/false)) {
return v.i == num;
} else {
// boolean scalar does not equal to a non boolean value
return false;
}
}
template <
typename T,
typename std::enable_if::value, int>::type = 0>
bool equal(T num) const {
if (isComplex()) {
return v.z == num;
} else if (isFloatingPoint()) {
return (v.d == num.real()) && (num.imag() == T());
} else if (isIntegral(/*includeBool=*/false)) {
return (v.i == num.real()) && (num.imag() == T());
} else {
// boolean scalar does not equal to a non boolean value
return false;
}
}
bool equal(bool num) const {
if (isBoolean()) {
return static_cast(v.i) == num;
} else {
return false;
}
}
ScalarType type() const {
if (isComplex()) {
return ScalarType::ComplexDouble;
} else if (isFloatingPoint()) {
return ScalarType::Double;
} else if (isIntegral(/*includeBool=*/false)) {
return ScalarType::Long;
} else if (isBoolean()) {
return ScalarType::Bool;
} else {
throw std::runtime_error("Unknown scalar type.");
}
}
private:
template <
typename T,
typename std::enable_if<
std::is_integral::value && !std::is_same::value,
bool>::type* = nullptr>
Scalar(T vv, bool) : tag(Tag::HAS_i) {
v.i = convert(vv);
}
template <
typename T,
typename std::enable_if<
!std::is_integral::value && !c10::is_complex::value,
bool>::type* = nullptr>
Scalar(T vv, bool) : tag(Tag::HAS_d) {
v.d = convert(vv);
}
template <
typename T,
typename std::enable_if::value, bool>::type* = nullptr>
Scalar(T vv, bool) : tag(Tag::HAS_z) {
v.z = convert(vv);
}
// We can't set v in the initializer list using the
// syntax v{ .member = ... } because it doesn't work on MSVC
enum class Tag { HAS_d, HAS_i, HAS_z, HAS_b };
Tag tag;
union v_t {
double d;
int64_t i;
c10::complex z;
v_t() {} // default constructor
} v;
};
using OptionalScalarRef = c10::OptionalRef;
// define the scalar.to() specializations
#define DEFINE_TO(T, name) \
template <> \
inline T Scalar::to() const { \
return to##name(); \
}
AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(DEFINE_TO)
#undef DEFINE_TO
} // namespace c10