PyTorch
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
c10 Namespace Reference

Namespaces

namespace  cuda
 
namespace  detail
 
namespace  detail_
 
namespace  ivalue
 
namespace  WarningUtils
 

Classes

class  ArrayRef
 ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e. More...
 
class  arrayref_optional_base
 
class  bad_optional_access
 
struct  Capsule
 
struct  complex< Half >
 
struct  constexpr_optional_base
 
union  constexpr_storage_t
 
struct  Device
 Represents a a compute device on which a tensor is located. More...
 
class  Dict
 
class  DistBackendError
 
class  EnforceFiniteError
 
class  Error
 The primary ATen error class. More...
 
struct  ExclusivelyOwnedTraits< at::Tensor >
 
struct  ExclusivelyOwnedTraits< at::TensorBase >
 
struct  Half
 
class  IListRef
 
class  IndexError
 
struct  IValue
 IValue (Interpreter Value) is a tagged union over the types supported by the TorchScript interpreter. More...
 
class  LinAlgError
 
class  List
 
struct  MaybeOwnedTraits< at::Tensor >
 
struct  MaybeOwnedTraits< at::TensorBase >
 
class  NotImplementedError
 
struct  nullopt_t
 
class  OnnxfiBackendSystemError
 
class  optional
 
class  optional< T & >
 
class  optional< T && >
 
struct  optional_base
 
struct  OptionalArray
 
class  OptionalArrayRef
 
class  OutOfMemoryError
 
union  storage_t
 
struct  StrongTypePtr
 
struct  trivial_init_t
 
struct  trivially_copyable_optimization_optional_base
 
class  TypeError
 
class  ValueError
 
class  Warning
 
class  WarningHandler
 
struct  WeakIValue
 
struct  WeakOrStrongCompilationUnit
 
struct  WeakOrStrongTypePtr
 
struct  WeakTypePtr
 

Typedefs

using ClassTypePtr = std::shared_ptr< ClassType >
 
typedef std::function< bool(const IValue &a, const IValue &b)> IValueComparator
 
using DeviceIndex = int8_t
 An index representing a specific device; e.g., the 1 in GPU 1. More...
 
using OptionalIntArrayRef = OptionalArrayRef< int64_t >
 
using UserWarning = Warning::UserWarning
 
using DeprecationWarning = Warning::DeprecationWarning
 
template<class T >
using OptionalBase = std::conditional_t< detail_::is_arrayref< T >::value, arrayref_optional_base< T >, std::conditional_t< std::is_trivially_destructible< T >::value &&std::is_trivially_copyable< T >::value &&std::is_copy_constructible< trivially_copyable_optimization_optional_base< T > >::value &&std::is_copy_assignable< trivially_copyable_optimization_optional_base< T > >::value, trivially_copyable_optimization_optional_base< T >, std::conditional_t< std::is_trivially_destructible< T >::value, constexpr_optional_base< std::remove_const_t< T > >, optional_base< std::remove_const_t< T > > > > >
 

Enumerations

enum class  DeviceType : int8_t {
  CPU = 0 , CUDA = 1 , MKLDNN = 2 , OPENGL = 3 ,
  OPENCL = 4 , IDEEP = 5 , HIP = 6 , FPGA = 7 ,
  ORT = 8 , XLA = 9 , Vulkan = 10 , Metal = 11 ,
  XPU = 12 , MPS = 13 , Meta = 14 , HPU = 15 ,
  VE = 16 , Lazy = 17 , IPU = 18 , MTIA = 19 ,
  PrivateUse1 = 20 , COMPILE_TIME_MAX_DEVICE_TYPES = 21
}
 

Functions

bool _fastEqualsForContainer (const IValue &lhs, const IValue &rhs)
 
torch::jit::Function * checkObjectSortSchema (const c10::ClassTypePtr &t, std::stringstream &why_not)
 
IValueComparator getLessThanComparator (const IValue &v)
 
IValueComparator getGreaterThanComparator (const IValue &v)
 
std::ostream & operator<< (std::ostream &stream, const Device &device)
 
std::string DeviceTypeName (DeviceType d, bool lower_case=false)
 
bool isValidDeviceType (DeviceType d)
 
std::ostream & operator<< (std::ostream &stream, DeviceType type)
 
void register_privateuse1_backend (std::string backend_name)
 
std::string get_privateuse1_backend (bool lower_case=true)
 
template<typename To , typename From >
std::enable_if< std::is_same< From, bool >::value, bool >::type overflows (From)
 
template<typename To , typename From >
std::enable_if< std::is_integral< From >::value &&!std::is_same< From, bool >::value, bool >::type overflows (From f)
 
template<typename To , typename From >
std::enable_if< std::is_floating_point< From >::value, bool >::type overflows (From f)
 
template<typename To , typename From >
std::enable_if< is_complex< From >::value, bool >::type overflows (From f)
 
std::ostream & operator<< (std::ostream &out, const Half &value)
 
template<typename T >
std::ostream & operator<< (std::ostream &out, ArrayRef< T > list)
 
bool operator== (const OptionalIntArrayRef &a1, const IntArrayRef &other)
 
bool operator== (const c10::IntArrayRef &a1, const c10::OptionalIntArrayRef &a2)
 
void warn (const Warning &warning)
 
std::string GetExceptionString (const std::exception &e)
 
template<class T >
constexpr T && constexpr_forward (typename std::remove_reference< T >::type &t) noexcept
 
template<class T >
constexpr T && constexpr_forward (typename std::remove_reference< T >::type &&t) noexcept
 
template<class T >
constexpr std::remove_reference< T >::type && constexpr_move (T &&t) noexcept
 
template<class T , class F >
constexpr T value_or_else (const optional< T > &v, F &&func)
 
template<class T , class F >
constexpr T value_or_else (optional< T > &&v, F &&func)
 
template<class T >
constexpr bool operator== (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator!= (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator< (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator> (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator<= (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator>= (const optional< T > &x, const optional< T > &y)
 
template<class T >
constexpr bool operator== (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator== (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator!= (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator!= (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator< (const optional< T > &, nullopt_t) noexcept
 
template<class T >
constexpr bool operator< (nullopt_t, const optional< T > &x) noexcept
 
template<class T >
constexpr bool operator<= (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator<= (nullopt_t, const optional< T > &) noexcept
 
template<class T >
constexpr bool operator> (const optional< T > &x, nullopt_t) noexcept
 
template<class T >
constexpr bool operator> (nullopt_t, const optional< T > &) noexcept
 
template<class T >
constexpr bool operator>= (const optional< T > &, nullopt_t) noexcept
 
template<class T >
constexpr bool operator>= (nullopt_t, const optional< T > &x) noexcept
 
template<class T , class U >
constexpr bool operator== (const optional< T > &x, const U &v)
 
template<class T , class U >
constexpr bool operator== (const U &v, const optional< T > &x)
 
template<class T , class U >
constexpr bool operator!= (const optional< T > &x, const U &v)
 
template<class T , class U >
constexpr bool operator!= (const U &v, const optional< T > &x)
 
template<class T , class U >
constexpr bool operator< (const optional< T > &x, const U &v)
 
template<class T , class U >
constexpr bool operator> (const U &v, const optional< T > &x)
 
template<class T , class U >
constexpr bool operator> (const optional< T > &x, const U &v)
 
template<class T , class U >
constexpr bool operator< (const U &v, const optional< T > &x)
 
template<class T , class U >
constexpr bool operator>= (const optional< T > &x, const U &v)
 
template<class T , class U >
constexpr bool operator<= (const U &v, const optional< T > &x)
 
template<class T , class U >
constexpr bool operator<= (const optional< T > &x, const U &v)
 
template<class T , class U >
constexpr bool operator>= (const U &v, const optional< T > &x)
 
template<class T >
constexpr bool operator== (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator== (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator!= (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator!= (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator< (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator> (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator> (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator< (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator>= (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator<= (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator<= (const optional< T & > &x, const T &v)
 
template<class T >
constexpr bool operator>= (const T &v, const optional< T & > &x)
 
template<class T >
constexpr bool operator== (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator== (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator!= (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator!= (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator< (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator> (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator> (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator< (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator>= (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator<= (const T &v, const optional< const T & > &x)
 
template<class T >
constexpr bool operator<= (const optional< const T & > &x, const T &v)
 
template<class T >
constexpr bool operator>= (const T &v, const optional< const T & > &x)
 
template<class T >
void swap (optional< T > &x, optional< T > &y) noexcept(noexcept(x.swap(y)))
 
template<class T >
constexpr optional< typename std::decay< T >::type > make_optional (T &&v)
 
template<class X >
constexpr optional< X & > make_optional (std::reference_wrapper< X > v)
 

Variables

constexpr DeviceType kCPU = DeviceType::CPU
 
constexpr DeviceType kCUDA = DeviceType::CUDA
 
constexpr DeviceType kHIP = DeviceType::HIP
 
constexpr DeviceType kFPGA = DeviceType::FPGA
 
constexpr DeviceType kORT = DeviceType::ORT
 
constexpr DeviceType kXLA = DeviceType::XLA
 
constexpr DeviceType kMPS = DeviceType::MPS
 
constexpr DeviceType kMeta = DeviceType::Meta
 
constexpr DeviceType kVulkan = DeviceType::Vulkan
 
constexpr DeviceType kMetal = DeviceType::Metal
 
constexpr DeviceType kXPU = DeviceType::XPU
 
constexpr DeviceType kHPU = DeviceType::HPU
 
constexpr DeviceType kVE = DeviceType::VE
 
constexpr DeviceType kLazy = DeviceType::Lazy
 
constexpr DeviceType kIPU = DeviceType::IPU
 
constexpr DeviceType kMTIA = DeviceType::MTIA
 
constexpr DeviceType kPrivateUse1 = DeviceType::PrivateUse1
 
constexpr int COMPILE_TIME_MAX_DEVICE_TYPES
 
constexpr struct c10::trivial_init_t trivial_init
 
constexpr nullopt_t nullopt {0}
 

ArrayRef Convenience constructors

using IntArrayRef = ArrayRef< int64_t >
 
 IntList
 
template<typename T >
ArrayRef< T > makeArrayRef (const T &OneElt)
 Construct an ArrayRef from a single element. More...
 
template<typename T >
ArrayRef< T > makeArrayRef (const T *data, size_t length)
 Construct an ArrayRef from a pointer and length. More...
 
template<typename T >
ArrayRef< T > makeArrayRef (const T *begin, const T *end)
 Construct an ArrayRef from a range. More...
 
template<typename T >
ArrayRef< T > makeArrayRef (const SmallVectorImpl< T > &Vec)
 Construct an ArrayRef from a SmallVector. More...
 
template<typename T , unsigned N>
ArrayRef< T > makeArrayRef (const SmallVector< T, N > &Vec)
 Construct an ArrayRef from a SmallVector. More...
 
template<typename T >
ArrayRef< T > makeArrayRef (const std::vector< T > &Vec)
 Construct an ArrayRef from a std::vector. More...
 
template<typename T , std::size_t N>
ArrayRef< T > makeArrayRef (const std::array< T, N > &Arr)
 Construct an ArrayRef from a std::array. More...
 
template<typename T >
ArrayRef< T > makeArrayRef (const ArrayRef< T > &Vec)
 Construct an ArrayRef from an ArrayRef (no-op) (const) More...
 
template<typename T >
ArrayRef< T > & makeArrayRef (ArrayRef< T > &Vec)
 Construct an ArrayRef from an ArrayRef (no-op) More...
 
template<typename T , size_t N>
ArrayRef< T > makeArrayRef (const T(&Arr)[N])
 Construct an ArrayRef from a C array. More...
 
template<typename T >
bool operator== (c10::ArrayRef< T > a1, c10::ArrayRef< T > a2)
 
template<typename T >
bool operator!= (c10::ArrayRef< T > a1, c10::ArrayRef< T > a2)
 
template<typename T >
bool operator== (const std::vector< T > &a1, c10::ArrayRef< T > a2)
 
template<typename T >
bool operator!= (const std::vector< T > &a1, c10::ArrayRef< T > a2)
 
template<typename T >
bool operator== (c10::ArrayRef< T > a1, const std::vector< T > &a2)
 
template<typename T >
bool operator!= (c10::ArrayRef< T > a1, const std::vector< T > &a2)
 

Typedef Documentation

◆ ClassTypePtr

using c10::ClassTypePtr = typedef std::shared_ptr<ClassType>

◆ DeprecationWarning

using c10::DeprecationWarning = typedef Warning::DeprecationWarning

◆ DeviceIndex

using c10::DeviceIndex = typedef int8_t

An index representing a specific device; e.g., the 1 in GPU 1.

A DeviceIndex is not independently meaningful without knowing the DeviceType it is associated; try to use Device rather than DeviceIndex directly.

◆ IntArrayRef

using c10::IntArrayRef = typedef ArrayRef<int64_t>

◆ IValueComparator

typedef std::function<bool(const IValue& a, const IValue& b)> c10::IValueComparator

◆ OptionalBase

template<class T >
using c10::OptionalBase = typedef std::conditional_t< detail_::is_arrayref<T>::value, arrayref_optional_base<T>, std::conditional_t< std::is_trivially_destructible<T>::value && std::is_trivially_copyable< T >::value && std::is_copy_constructible< trivially_copyable_optimization_optional_base<T> >::value && std::is_copy_assignable< trivially_copyable_optimization_optional_base<T> >::value, trivially_copyable_optimization_optional_base<T>, std::conditional_t< std::is_trivially_destructible<T>::value, constexpr_optional_base<std::remove_const_t<T> >, optional_base<std::remove_const_t<T> >> >>

◆ OptionalIntArrayRef

using c10::OptionalIntArrayRef = typedef OptionalArrayRef<int64_t>

◆ UserWarning

using c10::UserWarning = typedef Warning::UserWarning

Enumeration Type Documentation

◆ DeviceType

enum class c10::DeviceType : int8_t
strong
Enumerator
CPU 
CUDA 
MKLDNN 
OPENGL 
OPENCL 
IDEEP 
HIP 
FPGA 
ORT 
XLA 
Vulkan 
Metal 
XPU 
MPS 
Meta 
HPU 
VE 
Lazy 
IPU 
MTIA 
PrivateUse1 
COMPILE_TIME_MAX_DEVICE_TYPES 

Function Documentation

◆ _fastEqualsForContainer()

bool c10::_fastEqualsForContainer ( const IValue &  lhs,
const IValue &  rhs 
)

We primarily have this for consistency, because Python does the same thing. This actually provokes user-visible changes in behavior due to quirks in torch: [tensor1] == [tensor1] -> True (because container equality will first compare identity) [tensor1] == [tensor1_copy] -> RuntimeError: Boolean value of Tensor with more than one value is ambiguous

◆ checkObjectSortSchema()

torch::jit::Function * c10::checkObjectSortSchema ( const c10::ClassTypePtr &  t,
std::stringstream &  why_not 
)

◆ constexpr_forward() [1/2]

template<class T >
constexpr T && c10::constexpr_forward ( typename std::remove_reference< T >::type &&  t)
inlineconstexprnoexcept

◆ constexpr_forward() [2/2]

template<class T >
constexpr T && c10::constexpr_forward ( typename std::remove_reference< T >::type &  t)
inlineconstexprnoexcept

◆ constexpr_move()

template<class T >
constexpr std::remove_reference< T >::type && c10::constexpr_move ( T &&  t)
inlineconstexprnoexcept

◆ DeviceTypeName()

std::string c10::DeviceTypeName ( DeviceType  d,
bool  lower_case = false 
)

◆ get_privateuse1_backend()

std::string c10::get_privateuse1_backend ( bool  lower_case = true)

◆ GetExceptionString()

std::string c10::GetExceptionString ( const std::exception &  e)

◆ getGreaterThanComparator()

IValueComparator c10::getGreaterThanComparator ( const IValue &  v)

◆ getLessThanComparator()

IValueComparator c10::getLessThanComparator ( const IValue &  v)

◆ isValidDeviceType()

bool c10::isValidDeviceType ( DeviceType  d)

◆ make_optional() [1/2]

template<class X >
constexpr optional< X & > c10::make_optional ( std::reference_wrapper< X >  v)
constexpr

◆ make_optional() [2/2]

template<class T >
constexpr optional< typename std::decay< T >::type > c10::make_optional ( T &&  v)
constexpr

◆ makeArrayRef() [1/10]

template<typename T >
ArrayRef< T > & c10::makeArrayRef ( ArrayRef< T > &  Vec)

Construct an ArrayRef from an ArrayRef (no-op)

◆ makeArrayRef() [2/10]

template<typename T >
ArrayRef< T > c10::makeArrayRef ( const ArrayRef< T > &  Vec)

Construct an ArrayRef from an ArrayRef (no-op) (const)

◆ makeArrayRef() [3/10]

template<typename T , unsigned N>
ArrayRef< T > c10::makeArrayRef ( const SmallVector< T, N > &  Vec)

Construct an ArrayRef from a SmallVector.

◆ makeArrayRef() [4/10]

template<typename T >
ArrayRef< T > c10::makeArrayRef ( const SmallVectorImpl< T > &  Vec)

Construct an ArrayRef from a SmallVector.

◆ makeArrayRef() [5/10]

template<typename T , std::size_t N>
ArrayRef< T > c10::makeArrayRef ( const std::array< T, N > &  Arr)

Construct an ArrayRef from a std::array.

◆ makeArrayRef() [6/10]

template<typename T >
ArrayRef< T > c10::makeArrayRef ( const std::vector< T > &  Vec)

Construct an ArrayRef from a std::vector.

◆ makeArrayRef() [7/10]

template<typename T >
ArrayRef< T > c10::makeArrayRef ( const T &  OneElt)

Construct an ArrayRef from a single element.

◆ makeArrayRef() [8/10]

template<typename T >
ArrayRef< T > c10::makeArrayRef ( const T *  begin,
const T *  end 
)

Construct an ArrayRef from a range.

◆ makeArrayRef() [9/10]

template<typename T >
ArrayRef< T > c10::makeArrayRef ( const T *  data,
size_t  length 
)

Construct an ArrayRef from a pointer and length.

◆ makeArrayRef() [10/10]

template<typename T , size_t N>
ArrayRef< T > c10::makeArrayRef ( const T(&)  Arr[N])

Construct an ArrayRef from a C array.

◆ operator!=() [1/12]

template<typename T >
bool c10::operator!= ( c10::ArrayRef< T >  a1,
c10::ArrayRef< T >  a2 
)

◆ operator!=() [2/12]

template<typename T >
bool c10::operator!= ( c10::ArrayRef< T >  a1,
const std::vector< T > &  a2 
)

◆ operator!=() [3/12]

template<class T >
constexpr bool c10::operator!= ( const optional< const T & > &  x,
const T &  v 
)
constexpr

◆ operator!=() [4/12]

template<class T >
constexpr bool c10::operator!= ( const optional< T & > &  x,
const T &  v 
)
constexpr

◆ operator!=() [5/12]

template<class T >
constexpr bool c10::operator!= ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr

◆ operator!=() [6/12]

template<class T , class U >
constexpr bool c10::operator!= ( const optional< T > &  x,
const U &  v 
)
constexpr

◆ operator!=() [7/12]

template<class T >
constexpr bool c10::operator!= ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept

◆ operator!=() [8/12]

template<typename T >
bool c10::operator!= ( const std::vector< T > &  a1,
c10::ArrayRef< T >  a2 
)

◆ operator!=() [9/12]

template<class T >
constexpr bool c10::operator!= ( const T &  v,
const optional< const T & > &  x 
)
constexpr

◆ operator!=() [10/12]

template<class T >
constexpr bool c10::operator!= ( const T &  v,
const optional< T & > &  x 
)
constexpr

◆ operator!=() [11/12]

template<class T , class U >
constexpr bool c10::operator!= ( const U &  v,
const optional< T > &  x 
)
constexpr

◆ operator!=() [12/12]

template<class T >
constexpr bool c10::operator!= ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept

◆ operator<() [1/9]

template<class T >
constexpr bool c10::operator< ( const optional< const T & > &  x,
const T &  v 
)
constexpr

◆ operator<() [2/9]

template<class T >
constexpr bool c10::operator< ( const optional< T & > &  x,
const T &  v 
)
constexpr

◆ operator<() [3/9]

template<class T >
constexpr bool c10::operator< ( const optional< T > &  ,
nullopt_t   
)
constexprnoexcept

◆ operator<() [4/9]

template<class T >
constexpr bool c10::operator< ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr

◆ operator<() [5/9]

template<class T , class U >
constexpr bool c10::operator< ( const optional< T > &  x,
const U &  v 
)
constexpr

◆ operator<() [6/9]

template<class T >
constexpr bool c10::operator< ( const T &  v,
const optional< const T & > &  x 
)
constexpr

◆ operator<() [7/9]

template<class T >
constexpr bool c10::operator< ( const T &  v,
const optional< T & > &  x 
)
constexpr

◆ operator<() [8/9]

template<class T , class U >
constexpr bool c10::operator< ( const U &  v,
const optional< T > &  x 
)
constexpr

◆ operator<() [9/9]

template<class T >
constexpr bool c10::operator< ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept

◆ operator<<() [1/4]

template<typename T >
std::ostream & c10::operator<< ( std::ostream &  out,
ArrayRef< T >  list 
)

◆ operator<<() [2/4]

std::ostream & c10::operator<< ( std::ostream &  out,
const Half &  value 
)

◆ operator<<() [3/4]

std::ostream & c10::operator<< ( std::ostream &  stream,
const Device &  device 
)

◆ operator<<() [4/4]

std::ostream & c10::operator<< ( std::ostream &  stream,
DeviceType  type 
)

◆ operator<=() [1/9]

template<class T >
constexpr bool c10::operator<= ( const optional< const T & > &  x,
const T &  v 
)
constexpr

◆ operator<=() [2/9]

template<class T >
constexpr bool c10::operator<= ( const optional< T & > &  x,
const T &  v 
)
constexpr

◆ operator<=() [3/9]

template<class T >
constexpr bool c10::operator<= ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr

◆ operator<=() [4/9]

template<class T , class U >
constexpr bool c10::operator<= ( const optional< T > &  x,
const U &  v 
)
constexpr

◆ operator<=() [5/9]

template<class T >
constexpr bool c10::operator<= ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept

◆ operator<=() [6/9]

template<class T >
constexpr bool c10::operator<= ( const T &  v,
const optional< const T & > &  x 
)
constexpr

◆ operator<=() [7/9]

template<class T >
constexpr bool c10::operator<= ( const T &  v,
const optional< T & > &  x 
)
constexpr

◆ operator<=() [8/9]

template<class T , class U >
constexpr bool c10::operator<= ( const U &  v,
const optional< T > &  x 
)
constexpr

◆ operator<=() [9/9]

template<class T >
constexpr bool c10::operator<= ( nullopt_t  ,
const optional< T > &   
)
constexprnoexcept

◆ operator==() [1/14]

template<typename T >
bool c10::operator== ( c10::ArrayRef< T >  a1,
c10::ArrayRef< T >  a2 
)

◆ operator==() [2/14]

template<typename T >
bool c10::operator== ( c10::ArrayRef< T >  a1,
const std::vector< T > &  a2 
)

◆ operator==() [3/14]

bool c10::operator== ( const c10::IntArrayRef &  a1,
const c10::OptionalIntArrayRef &  a2 
)
inline

◆ operator==() [4/14]

template<class T >
constexpr bool c10::operator== ( const optional< const T & > &  x,
const T &  v 
)
constexpr

◆ operator==() [5/14]

template<class T >
constexpr bool c10::operator== ( const optional< T & > &  x,
const T &  v 
)
constexpr

◆ operator==() [6/14]

template<class T >
constexpr bool c10::operator== ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr

◆ operator==() [7/14]

template<class T , class U >
constexpr bool c10::operator== ( const optional< T > &  x,
const U &  v 
)
constexpr

◆ operator==() [8/14]

template<class T >
constexpr bool c10::operator== ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept

◆ operator==() [9/14]

bool c10::operator== ( const OptionalIntArrayRef &  a1,
const IntArrayRef &  other 
)
inline

◆ operator==() [10/14]

template<typename T >
bool c10::operator== ( const std::vector< T > &  a1,
c10::ArrayRef< T >  a2 
)

◆ operator==() [11/14]

template<class T >
constexpr bool c10::operator== ( const T &  v,
const optional< const T & > &  x 
)
constexpr

◆ operator==() [12/14]

template<class T >
constexpr bool c10::operator== ( const T &  v,
const optional< T & > &  x 
)
constexpr

◆ operator==() [13/14]

template<class T , class U >
constexpr bool c10::operator== ( const U &  v,
const optional< T > &  x 
)
constexpr

◆ operator==() [14/14]

template<class T >
constexpr bool c10::operator== ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept

◆ operator>() [1/9]

template<class T >
constexpr bool c10::operator> ( const optional< const T & > &  x,
const T &  v 
)
constexpr

◆ operator>() [2/9]

template<class T >
constexpr bool c10::operator> ( const optional< T & > &  x,
const T &  v 
)
constexpr

◆ operator>() [3/9]

template<class T >
constexpr bool c10::operator> ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr

◆ operator>() [4/9]

template<class T , class U >
constexpr bool c10::operator> ( const optional< T > &  x,
const U &  v 
)
constexpr

◆ operator>() [5/9]

template<class T >
constexpr bool c10::operator> ( const optional< T > &  x,
nullopt_t   
)
constexprnoexcept

◆ operator>() [6/9]

template<class T >
constexpr bool c10::operator> ( const T &  v,
const optional< const T & > &  x 
)
constexpr

◆ operator>() [7/9]

template<class T >
constexpr bool c10::operator> ( const T &  v,
const optional< T & > &  x 
)
constexpr

◆ operator>() [8/9]

template<class T , class U >
constexpr bool c10::operator> ( const U &  v,
const optional< T > &  x 
)
constexpr

◆ operator>() [9/9]

template<class T >
constexpr bool c10::operator> ( nullopt_t  ,
const optional< T > &   
)
constexprnoexcept

◆ operator>=() [1/9]

template<class T >
constexpr bool c10::operator>= ( const optional< const T & > &  x,
const T &  v 
)
constexpr

◆ operator>=() [2/9]

template<class T >
constexpr bool c10::operator>= ( const optional< T & > &  x,
const T &  v 
)
constexpr

◆ operator>=() [3/9]

template<class T >
constexpr bool c10::operator>= ( const optional< T > &  ,
nullopt_t   
)
constexprnoexcept

◆ operator>=() [4/9]

template<class T >
constexpr bool c10::operator>= ( const optional< T > &  x,
const optional< T > &  y 
)
constexpr

◆ operator>=() [5/9]

template<class T , class U >
constexpr bool c10::operator>= ( const optional< T > &  x,
const U &  v 
)
constexpr

◆ operator>=() [6/9]

template<class T >
constexpr bool c10::operator>= ( const T &  v,
const optional< const T & > &  x 
)
constexpr

◆ operator>=() [7/9]

template<class T >
constexpr bool c10::operator>= ( const T &  v,
const optional< T & > &  x 
)
constexpr

◆ operator>=() [8/9]

template<class T , class U >
constexpr bool c10::operator>= ( const U &  v,
const optional< T > &  x 
)
constexpr

◆ operator>=() [9/9]

template<class T >
constexpr bool c10::operator>= ( nullopt_t  ,
const optional< T > &  x 
)
constexprnoexcept

◆ overflows() [1/4]

template<typename To , typename From >
std::enable_if< std::is_integral< From >::value &&!std::is_same< From, bool >::value, bool >::type c10::overflows ( From  f)

◆ overflows() [2/4]

template<typename To , typename From >
std::enable_if< std::is_floating_point< From >::value, bool >::type c10::overflows ( From  f)

◆ overflows() [3/4]

template<typename To , typename From >
std::enable_if< is_complex< From >::value, bool >::type c10::overflows ( From  f)

◆ overflows() [4/4]

template<typename To , typename From >
std::enable_if< std::is_same< From, bool >::value, bool >::type c10::overflows ( From  )

◆ register_privateuse1_backend()

void c10::register_privateuse1_backend ( std::string  backend_name)

◆ swap()

template<class T >
void c10::swap ( optional< T > &  x,
optional< T > &  y 
)
noexcept

◆ value_or_else() [1/2]

template<class T , class F >
constexpr T c10::value_or_else ( const optional< T > &  v,
F &&  func 
)
constexpr

◆ value_or_else() [2/2]

template<class T , class F >
constexpr T c10::value_or_else ( optional< T > &&  v,
F &&  func 
)
constexpr

◆ warn()

void c10::warn ( const Warning &  warning)

Variable Documentation

◆ COMPILE_TIME_MAX_DEVICE_TYPES

constexpr int c10::COMPILE_TIME_MAX_DEVICE_TYPES
constexpr
Initial value:
=
static_cast<int>(DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES)

◆ IntList

c10::IntList

◆ kCPU

constexpr DeviceType c10::kCPU = DeviceType::CPU
constexpr

◆ kCUDA

constexpr DeviceType c10::kCUDA = DeviceType::CUDA
constexpr

◆ kFPGA

constexpr DeviceType c10::kFPGA = DeviceType::FPGA
constexpr

◆ kHIP

constexpr DeviceType c10::kHIP = DeviceType::HIP
constexpr

◆ kHPU

constexpr DeviceType c10::kHPU = DeviceType::HPU
constexpr

◆ kIPU

constexpr DeviceType c10::kIPU = DeviceType::IPU
constexpr

◆ kLazy

constexpr DeviceType c10::kLazy = DeviceType::Lazy
constexpr

◆ kMeta

constexpr DeviceType c10::kMeta = DeviceType::Meta
constexpr

◆ kMetal

constexpr DeviceType c10::kMetal = DeviceType::Metal
constexpr

◆ kMPS

constexpr DeviceType c10::kMPS = DeviceType::MPS
constexpr

◆ kMTIA

constexpr DeviceType c10::kMTIA = DeviceType::MTIA
constexpr

◆ kORT

constexpr DeviceType c10::kORT = DeviceType::ORT
constexpr

◆ kPrivateUse1

constexpr DeviceType c10::kPrivateUse1 = DeviceType::PrivateUse1
constexpr

◆ kVE

constexpr DeviceType c10::kVE = DeviceType::VE
constexpr

◆ kVulkan

constexpr DeviceType c10::kVulkan = DeviceType::Vulkan
constexpr

◆ kXLA

constexpr DeviceType c10::kXLA = DeviceType::XLA
constexpr

◆ kXPU

constexpr DeviceType c10::kXPU = DeviceType::XPU
constexpr

◆ nullopt

constexpr nullopt_t c10::nullopt {0}
constexpr

◆ trivial_init

constexpr struct c10::trivial_init_t c10::trivial_init
Generated by doxygen 1.9.5