Namespaces
	cuda

	eigen_converter

	kernel

	linalg

	nns

	shape_util

	sy

	tensor_check

	tensor_init

Data Structures
class	AdvancedIndexPreprocessor
	This class is based on PyTorch's aten/src/ATen/native/Indexing.cpp. More...

class	AdvancedIndexer

class	Blob

class	CUDAScopedDevice
	When CUDA is not enabled, this is a dummy class. More...

class	Device

class	IsDevice

class	Dtype

struct	FunctionTraits

struct	FunctionTraits< T ClassType::* >

struct	FunctionTraits< ReturnType(ClassType::*)(Args...) const >

struct	FunctionTraits< T & >

struct	FunctionTraits< T * >

struct	FunctionTraits< ReturnType(Args...)>

struct	NullaryFunctionTraits

struct	UnaryFunctionTraits

struct	BinaryFunctionTraits

class	CPUHashBackendBufferAccessor

class	TBBHashBackend

class	CUDAHashBackendBufferAccessor

class	SlabHashBackend

class	SlabHashBackendImpl

class	Slab

class	SlabNodeManagerImpl

class	SlabNodeManager

struct	iterator_t

struct	Pair

class	StdGPUAllocator

class	StdGPUHashBackend

struct	ValueExtractor

class	DeviceHashBackend

class	HashBackendBuffer

class	HashMap

class	HashSet

struct	OffsetCalculator

struct	TensorRef
	A minimalistic class that reference a Tensor. More...

class	TensorIterator

class	Indexer

class	IndexerIterator

class	MemoryManager

class	MemoryManagerDevice
	Interface for all concrete memory manager classes. More...

class	MemoryManagerCached

class	MemoryManagerCPU

struct	SizeOrder

struct	PointerOrder

struct	VirtualBlock

struct	RealBlock

class	MemoryCache

class	Cacher

class	MemoryManagerStatistic

class	Scalar

class	DynamicSizeVector

class	SizeVector

class	iterator_range

class	SmallVectorBase

struct	SmallVectorAlignmentAndSize
	Figure out the offset of the first element. More...

class	SmallVectorTemplateCommon

class	SmallVectorTemplateBase

class	SmallVectorTemplateBase< T, true >

class	SmallVectorImpl

struct	SmallVectorStorage

struct	SmallVectorStorage< T, 0 >

struct	CalculateSmallVectorDefaultInlinedElements

class	SmallVector

class	StdAllocator

class	Open3DDLManagedTensor
	Open3D DLPack Tensor manager. More...

class	Tensor

class	TensorKey
	TensorKey is used to represent single index, slice or advanced indexing on a Tensor. More...

class	TensorList

Typedefs
template<typename Key >
using	InternalStdGPUHashBackendAllocator = StdGPUAllocator< stdgpu::pair< const Key, buf_index_t > >

template<typename Key , typename Hash , typename Eq >
using	InternalStdGPUHashBackend = stdgpu::unordered_map< Key, buf_index_t, Hash, Eq, InternalStdGPUHashBackendAllocator< Key > >

using	buf_index_t = uint32_t

template<class T >
using	SmallVectorSizeType = typename std::conditional< sizeof(T)< 4 &&sizeof(void *) >=8, uint64_t, uint32_t >::type

template<typename RangeType >
using	ValueTypeFromRangeType = typename std::remove_const< typename std::remove_reference< decltype(*std::begin(std::declval< RangeType & >()))>::type >::type

Enumerations
enum class	HashBackendType { Slab , StdGPU , TBB , Default }

enum class	DtypePolicy { NONE , ALL_SAME , INPUT_SAME , INPUT_SAME_OUTPUT_BOOL }

Functions
uint32_t	AtomicFetchAddRelaxed (uint32_t *address, uint32_t val)

uint64_t	AtomicFetchAddRelaxed (uint64_t *address, uint64_t val)

void	CPUResetHeap (Tensor &heap)

std::shared_ptr< DeviceHashBackend >	CreateCPUHashBackend (int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
	Non-templated factory. More...

template<typename Key , typename Hash , typename Eq >
__global__ void	InsertKernelPass0 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void input_keys, buf_index_t output_buf_indices, int heap_counter_prev, int64_t count)
	Kernels. More...

template<typename Key , typename Hash , typename Eq >
__global__ void	InsertKernelPass1 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void input_keys, buf_index_t output_buf_indices, bool *output_masks, int64_t count)

template<typename Key , typename Hash , typename Eq , typename block_t >
__global__ void	InsertKernelPass2 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void const input_values_soa, buf_index_t output_buf_indices, bool output_masks, int64_t count, int64_t n_values)

template<typename Key , typename Hash , typename Eq >
__global__ void	FindKernel (SlabHashBackendImpl< Key, Hash, Eq > impl, const void input_keys, buf_index_t output_buf_indices, bool *output_masks, int64_t count)

template<typename Key , typename Hash , typename Eq >
__global__ void	EraseKernelPass0 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void input_keys, buf_index_t output_buf_indices, bool *output_masks, int64_t count)

template<typename Key , typename Hash , typename Eq >
__global__ void	EraseKernelPass1 (SlabHashBackendImpl< Key, Hash, Eq > impl, buf_index_t output_buf_indices, bool output_masks, int64_t count)

template<typename Key , typename Hash , typename Eq >
__global__ void	GetActiveIndicesKernel (SlabHashBackendImpl< Key, Hash, Eq > impl, buf_index_t output_buf_indices, uint32_t output_count)

template<typename Key , typename Hash , typename Eq >
__global__ void	CountElemsPerBucketKernel (SlabHashBackendImpl< Key, Hash, Eq > impl, int64_t *bucket_elem_counts)

__global__ void	CountSlabsPerSuperblockKernel (SlabNodeManagerImpl impl, uint32_t *slabs_per_superblock)

template<typename First , typename Second >
OPEN3D_HOST_DEVICE Pair< First, Second >	make_pair (const First &_first, const Second &_second)

template<typename Key , typename Hash , typename Eq >
__global__ void	STDGPUFindKernel (InternalStdGPUHashBackend< Key, Hash, Eq > map, CUDAHashBackendBufferAccessor buffer_accessor, const Key input_keys, buf_index_t output_buf_indices, bool *output_masks, int64_t count)

template<typename Key , typename Hash , typename Eq >
__global__ void	STDGPUEraseKernel (InternalStdGPUHashBackend< Key, Hash, Eq > map, CUDAHashBackendBufferAccessor buffer_accessor, const Key input_keys, buf_index_t output_buf_indices, bool *output_masks, int64_t count)

template<typename Key , typename Hash , typename Eq , typename block_t >
__global__ void	STDGPUInsertKernel (InternalStdGPUHashBackend< Key, Hash, Eq > map, CUDAHashBackendBufferAccessor buffer_accessor, const Key input_keys, const void const input_values_soa, buf_index_t output_buf_indices, bool *output_masks, int64_t count, int64_t n_values)

std::shared_ptr< DeviceHashBackend >	CreateDeviceHashBackend (int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)

std::shared_ptr< DeviceHashBackend >	CreateCUDAHashBackend (int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)

void	AddMM (const Tensor &A, const Tensor &B, Tensor &output, double alpha, double beta)

void	AddMMCPU (void A_data, void B_data, void *C_data, int64_t m, int64_t k, int64_t n, double alpha, double beta, bool gemmTrA, bool gemmTrB, int lda, int ldb, int ldc, Dtype dtype)

void	AddMMCUDA (void A_data, void B_data, void *C_data, int64_t m, int64_t k, int64_t n, double alpha, double beta, bool gemmTrA, bool gemmTrB, int lda, int ldb, int ldc, Dtype dtype, const Device &device)

void	AddMMSYCL (void A_data, void B_data, void *C_data, int64_t m, int64_t k, int64_t n, double alpha, double beta, bool gemmTrA, bool gemmTrB, int lda, int ldb, int ldc, Dtype dtype, const Device &device)

template<typename scalar_t >
void	gemm_cpu (CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, scalar_t alpha, const scalar_t A_data, OPEN3D_CPU_LINALG_INT lda, const scalar_t B_data, OPEN3D_CPU_LINALG_INT ldb, scalar_t beta, scalar_t *C_data, OPEN3D_CPU_LINALG_INT ldc)

template<>
void	gemm_cpu< float > (CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, float alpha, const float A_data, OPEN3D_CPU_LINALG_INT lda, const float B_data, OPEN3D_CPU_LINALG_INT ldb, float beta, float *C_data, OPEN3D_CPU_LINALG_INT ldc)

template<>
void	gemm_cpu< double > (CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, double alpha, const double A_data, OPEN3D_CPU_LINALG_INT lda, const double B_data, OPEN3D_CPU_LINALG_INT ldb, double beta, double *C_data, OPEN3D_CPU_LINALG_INT ldc)

double	Det (const Tensor &A)

void	Inverse (const Tensor &A, Tensor &output)
	Computes A^{-1} with LU factorization, where A is a N x N square matrix. More...

void	InverseCPU (void A_data, void ipiv_data, [[maybe_unused]] void *output_data, int64_t n, Dtype dtype, const Device &device)

void	InverseCPU (void A_data, void ipiv_data, void *output_data, int64_t n, Dtype dtype, const Device &device)

void	InverseCUDA (void A_data, void ipiv_data, void *output_data, int64_t n, Dtype dtype, const Device &device)

void	InverseSYCL (void A_data, void ipiv_data, void *output_data, int64_t n, Dtype dtype, const Device &device)

template<typename scalar_t >
OPEN3D_CPU_LINALG_INT	getrf_cpu (int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, scalar_t A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data)

template<typename scalar_t >
OPEN3D_CPU_LINALG_INT	getri_cpu (int layout, OPEN3D_CPU_LINALG_INT n, scalar_t A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data)

template<typename scalar_t >
OPEN3D_CPU_LINALG_INT	gesv_cpu (int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, scalar_t A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data, scalar_t *B_data, OPEN3D_CPU_LINALG_INT ldb)

template<typename scalar_t >
OPEN3D_CPU_LINALG_INT	gels_cpu (int matrix_layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, scalar_t A_data, OPEN3D_CPU_LINALG_INT lda, scalar_t B_data, OPEN3D_CPU_LINALG_INT ldb)

template<typename scalar_t >
OPEN3D_CPU_LINALG_INT	gesvd_cpu (int matrix_layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, scalar_t A_data, OPEN3D_CPU_LINALG_INT lda, scalar_t S_data, scalar_t U_data, OPEN3D_CPU_LINALG_INT ldu, scalar_t VT_data, OPEN3D_CPU_LINALG_INT ldvt, scalar_t *superb)

template<>
OPEN3D_CPU_LINALG_INT	getrf_cpu< float > (int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, float A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data)

template<>
OPEN3D_CPU_LINALG_INT	getrf_cpu< double > (int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, double A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data)

template<>
OPEN3D_CPU_LINALG_INT	getri_cpu< float > (int layout, OPEN3D_CPU_LINALG_INT n, float A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data)

template<>
OPEN3D_CPU_LINALG_INT	getri_cpu< double > (int layout, OPEN3D_CPU_LINALG_INT n, double A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data)

template<>
OPEN3D_CPU_LINALG_INT	gesv_cpu< float > (int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, float A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data, float *B_data, OPEN3D_CPU_LINALG_INT ldb)

template<>
OPEN3D_CPU_LINALG_INT	gesv_cpu< double > (int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, double A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT ipiv_data, double *B_data, OPEN3D_CPU_LINALG_INT ldb)

template<>
OPEN3D_CPU_LINALG_INT	gels_cpu< float > (int layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, float A_data, OPEN3D_CPU_LINALG_INT lda, float B_data, OPEN3D_CPU_LINALG_INT ldb)

template<>
OPEN3D_CPU_LINALG_INT	gels_cpu< double > (int layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, double A_data, OPEN3D_CPU_LINALG_INT lda, double B_data, OPEN3D_CPU_LINALG_INT ldb)

template<>
OPEN3D_CPU_LINALG_INT	gesvd_cpu< float > (int layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, float A_data, OPEN3D_CPU_LINALG_INT lda, float S_data, float U_data, OPEN3D_CPU_LINALG_INT ldu, float VT_data, OPEN3D_CPU_LINALG_INT ldvt, float *superb)

template<>
OPEN3D_CPU_LINALG_INT	gesvd_cpu< double > (int layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, double A_data, OPEN3D_CPU_LINALG_INT lda, double S_data, double U_data, OPEN3D_CPU_LINALG_INT ldu, double VT_data, OPEN3D_CPU_LINALG_INT ldvt, double *superb)

void	LeastSquares (const Tensor &A, const Tensor &B, Tensor &X)
	Solve AX = B with QR decomposition. A is a full-rank m x n matrix (m >= n). More...

void	LeastSquaresCPU (void A_data, void B_data, int64_t m, int64_t n, int64_t k, Dtype dtype, const Device &device)

void	LeastSquaresCUDA (void A_data, void B_data, int64_t m, int64_t n, int64_t k, Dtype dtype, const Device &device)

void	LeastSquaresSYCL (void A_data, void B_data, int64_t m, int64_t n, int64_t k, Dtype dtype, const Device &device)

void	OPEN3D_LAPACK_CHECK (OPEN3D_CPU_LINALG_INT info, const std::string &msg)

void	LUIpiv (const Tensor &A, Tensor &ipiv, Tensor &output)

void	LU (const Tensor &A, Tensor &permutation, Tensor &lower, Tensor &upper, const bool permute_l)

void	LUCPU (void A_data, void ipiv_data, int64_t rows, int64_t cols, Dtype dtype, const Device &device)

void	LUCUDA (void A_data, void ipiv_data, int64_t rows, int64_t cols, Dtype dtype, const Device &device)

void	LUSYCL (void A_data, void ipiv_data, int64_t m, int64_t n, Dtype dtype, const Device &device)

void	Matmul (const Tensor &A, const Tensor &B, Tensor &C)
	Computes matrix multiplication C = AB. More...

void	MatmulCPU (void A_data, void B_data, void *C_data, int64_t m, int64_t k, int64_t n, Dtype dtype)

void	MatmulCUDA (void A_data, void B_data, void *C_data, int64_t m, int64_t k, int64_t n, Dtype dtype, const Device &device)

void	MatmulSYCL (void A_data, void B_data, void *C_data, int64_t m, int64_t k, int64_t n, Dtype dtype, const Device &device)

void	Solve (const Tensor &A, const Tensor &B, Tensor &X)
	Solve AX = B with LU decomposition. A is a square matrix. More...

void	SolveCPU (void A_data, void B_data, void *ipiv_data, int64_t n, int64_t k, Dtype dtype, const Device &device)

void	SolveCUDA (void A_data, void B_data, void *ipiv_data, int64_t n, int64_t k, Dtype dtype, const Device &device)

void	SolveSYCL (void A_data, void B_data, void *ipiv_data, int64_t n, int64_t k, Dtype dtype, const Device &device)

void	SVD (const Tensor &A, Tensor &U, Tensor &S, Tensor &VT)

void	SVDCPU (const void A_data, void U_data, void S_data, void VT_data, void *superb_data, int64_t m, int64_t n, Dtype dtype, const Device &device)

void	SVDCUDA (const void A_data, void U_data, void S_data, void VT_data, void *superb_data, int64_t m, int64_t n, Dtype dtype, const Device &device)

void	SVDSYCL (const void A_data, void U_data, void S_data, void VT_data, int64_t m, int64_t n, Dtype dtype, const Device &device)

void	Triu (const Tensor &A, Tensor &output, const int diagonal)

void	Tril (const Tensor &A, Tensor &output, const int diagonal)

void	Triul (const Tensor &A, Tensor &upper, Tensor &lower, const int diagonal)

void	TriuCPU (const Tensor &A, Tensor &output, const int diagonal)

void	TrilCPU (const Tensor &A, Tensor &output, const int diagonal)

void	TriulCPU (const Tensor &A, Tensor &upper, Tensor &lower, const int diagonal)

void	TriuSYCL (const Tensor &A, Tensor &output, const int diagonal)

void	TrilSYCL (const Tensor &A, Tensor &output, const int diagonal)

void	TriulSYCL (const Tensor &A, Tensor &upper, Tensor &lower, const int diagonal)

template<typename func_t >
void	ParallelForCPU_ (const Device &device, int64_t n, const func_t &func)
	Run a function in parallel on CPU. More...

template<typename func_t >
void	ParallelFor (const Device &device, int64_t n, const func_t &func)

template<typename vec_func_t , typename func_t >
void	ParallelFor (const Device &device, int64_t n, const func_t &func, const vec_func_t &vec_func)

template<typename Functor , typename... FuncArgs>
void	ParallelForSYCL (const Device &device, Indexer indexer, FuncArgs... func_args)
	Run a function in parallel with SYCL. More...

template<typename Functor , typename... FuncArgs>
void	ParallelForSYCL (const Device &device, int64_t num_workloads, FuncArgs... func_args)
	Run a function in parallel with SYCL. More...

void *	safe_malloc (size_t Sz)

void *	safe_realloc (void *Ptr, size_t Sz)

template<typename T , unsigned N>
size_t	capacity_in_bytes (const SmallVector< T, N > &X)

template<unsigned Size, typename R >
SmallVector< ValueTypeFromRangeType< R >, Size >	to_vector (R &&Range)

template<typename R >
SmallVector< ValueTypeFromRangeType< R >, CalculateSmallVectorDefaultInlinedElements< ValueTypeFromRangeType< R > >::value >	to_vector (R &&Range)

template<typename T >
Tensor	operator+ (T scalar_lhs, const Tensor &rhs)

template<typename T >
Tensor	operator- (T scalar_lhs, const Tensor &rhs)

template<typename T >
Tensor	operator* (T scalar_lhs, const Tensor &rhs)

template<typename T >
Tensor	operator/ (T scalar_lhs, const Tensor &rhs)

void	AssertNotSYCL (const Tensor &tensor)

Tensor	Concatenate (const std::vector< Tensor > &tensors, const utility::optional< int64_t > &axis=0)
	Concatenates the list of tensors in their order, along the given axis into a new tensor. All the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be concatenated. Using Concatenate for a single tensor, the tensor is split along its first dimension (length), and concatenated along the axis. More...

Tensor	Append (const Tensor &self, const Tensor &other, const utility::optional< int64_t > &axis=utility::nullopt)
	Appends the two tensors, along the given axis into a new tensor. Both the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be appended. More...

Tensor	Maximum (const Tensor &input, const Tensor &other)
	Computes the element-wise maximum of input and other. The tensors must have same data type and device. More...

Tensor	Minimum (const Tensor &input, const Tensor &other)
	Computes the element-wise minimum of input and other. The tensors must have same data type and device. More...

Variables
const Dtype	Undefined = Dtype::Undefined

const Dtype	Float32 = Dtype::Float32

const Dtype	Float64 = Dtype::Float64

const Dtype	Int8 = Dtype::Int8

const Dtype	Int16 = Dtype::Int16

const Dtype	Int32 = Dtype::Int32

const Dtype	Int64 = Dtype::Int64

const Dtype	UInt8 = Dtype::UInt8

const Dtype	UInt16 = Dtype::UInt16

const Dtype	UInt32 = Dtype::UInt32

const Dtype	UInt64 = Dtype::UInt64

const Dtype	Bool = Dtype::Bool

template<typename T , unsigned N>
class LLVM_GSL_OWNER	SmallVector

constexpr utility::nullopt_t	None {utility::nullopt_t::init()}

Typedef Documentation

◆ buf_index_t

using open3d::core::buf_index_t = typedef uint32_t

◆ InternalStdGPUHashBackend

template<typename Key , typename Hash , typename Eq >

using open3d::core::InternalStdGPUHashBackend = typedef stdgpu::unordered_map<Key, buf_index_t, Hash, Eq, InternalStdGPUHashBackendAllocator<Key> >

◆ InternalStdGPUHashBackendAllocator

template<typename Key >

using open3d::core::InternalStdGPUHashBackendAllocator = typedef StdGPUAllocator<stdgpu::pair<const Key, buf_index_t> >

◆ SmallVectorSizeType

template<class T >

using open3d::core::SmallVectorSizeType = typedef typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t, uint32_t>::type

◆ ValueTypeFromRangeType

template<typename RangeType >

using open3d::core::ValueTypeFromRangeType = typedef typename std::remove_const<typename std::remove_reference<decltype( *std::begin(std::declval<RangeType &>()))>::type>::type

Enumeration Type Documentation

◆ DtypePolicy

enum open3d::core::DtypePolicy

strong

Enumerator
NONE
ALL_SAME
INPUT_SAME
INPUT_SAME_OUTPUT_BOOL

◆ HashBackendType

enum open3d::core::HashBackendType

strong

Enumerator
Slab
StdGPU
TBB
Default

Function Documentation

◆ AddMM()

void open3d::core::AddMM	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	C,
		double	alpha,
		double	beta
	)

Computes matrix multiplication C = alpha * A @ B + beta * C. If matrix A is a (n x m) tensor, and B is a (m x p) tensor, C should have a shape (n x p). alpha and beta are scaling factors on matrix-matrix multiplication and the added matrix input respectively.

◆ AddMMCPU()

void open3d::core::AddMMCPU	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		double	alpha,
		double	beta,
		bool	gemmTrA,
		bool	gemmTrB,
		int	lda,
		int	ldb,
		int	ldc,
		Dtype	dtype
	)

◆ AddMMCUDA()

void open3d::core::AddMMCUDA	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		double	alpha,
		double	beta,
		bool	gemmTrA,
		bool	gemmTrB,
		int	lda,
		int	ldb,
		int	ldc,
		Dtype	dtype,
		const Device &	device
	)

◆ AddMMSYCL()

void open3d::core::AddMMSYCL	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		double	alpha,
		double	beta,
		bool	gemmTrA,
		bool	gemmTrB,
		int	lda,
		int	ldb,
		int	ldc,
		Dtype	dtype,
		const Device &	device
	)

◆ Append()

Tensor open3d::core::Append	(	const Tensor &	self,
		const Tensor &	other,
		const utility::optional< int64_t > &	axis = `utility::nullopt`
	)

Appends the two tensors, along the given axis into a new tensor. Both the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be appended.

This is the same as NumPy's semantics:

https://numpy.org/doc/stable/reference/generated/numpy.append.html

Example:

Tensor a = Tensor::Init<int64_t>({{0, 1}, {2, 3}});
Tensor b = Tensor::Init<int64_t>({{4, 5}});
Tensor t1 = core::Append(a, b, 0);
// t1:
//  [[0 1],
//   [2 3],
//   [4 5]]
//  Tensor[shape={3, 2}, stride={2, 1}, Int64, CPU:0, 0x55555abc6b00]
 
Tensor t2 = core::Append(a, b);
// t2:
//  [0 1 2 3 4 5]
//  Tensor[shape={6}, stride={1}, Int64, CPU:0, 0x55555abc6b70]

Parameters

self	Values are appended to a copy of this tensor.
other	Values of this tensor is appended to the `self`.
axis	[optional] The axis along which values are appended. If axis is not given, both tensors are flattened before use.

Returns: A copy of tensor with values appended to axis. Note that append does not occur in-place: a new array is allocated and filled. If axis is None, out is a flattened tensor.

◆ AssertNotSYCL()

void open3d::core::AssertNotSYCL ( const Tensor & tensor )

inline

◆ AtomicFetchAddRelaxed() [1/2]

uint32_t open3d::core::AtomicFetchAddRelaxed	(	uint32_t *	address,
		uint32_t	val
	)

inline

Adds val to the value stored at address and returns the previous stored value as an atomic operation. This function does not impose any ordering on concurrent memory accesses.

Warning: This function will treat all values as signed integers on Windows!

◆ AtomicFetchAddRelaxed() [2/2]

uint64_t open3d::core::AtomicFetchAddRelaxed	(	uint64_t *	address,
		uint64_t	val
	)

inline

Adds val to the value stored at address and returns the previous stored value as an atomic operation. This function does not impose any ordering on concurrent memory accesses.

Warning: This function will treat all values as signed integers on Windows!

◆ capacity_in_bytes()

template<typename T , unsigned N>

size_t open3d::core::capacity_in_bytes ( const SmallVector< T, N > & X )

inline

◆ Concatenate()

Tensor open3d::core::Concatenate	(	const std::vector< Tensor > &	tensors,
		const utility::optional< int64_t > &	axis = `0`
	)

Concatenates the list of tensors in their order, along the given axis into a new tensor. All the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be concatenated. Using Concatenate for a single tensor, the tensor is split along its first dimension (length), and concatenated along the axis.

This is the same as NumPy's semantics:

https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html

Example:

Tensor a = Tensor::Init<int64_t>({{0, 1}, {2, 3}});
Tensor b = Tensor::Init<int64_t>({{4, 5}});
Tensor c = Tensor::Init<int64_t>({{6, 7}});
Tensor output = core::Concatenate({a, b, c}, 0);
// output:
//  [[0 1],
//   [2 3],
//   [4 5],
//   [6 7]]
//  Tensor[shape={4, 2}, stride={2, 1}, Int64, CPU:0, 0x55555abc6b00]
 
a = core::Tensor::Init<float>(
        {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}, {{8, 9}, {10, 11}}}, device);
output = core::Concatenate({a}, 1);
//  output:
//  [[0, 1, 4, 5, 8, 9],
//   [2, 3, 6, 7, 10, 11]]
//  Tensor[shape={2, 6}, stride={6, 1}, Int64, CPU:0, 0x55555abc6b00]

Parameters

tensors	Vector of tensors to be concatenated. If only one tensor is present, the tensor is split along its first dimension (length), and concatenated along the axis.
axis	[optional] The axis along which values are concatenated. [Default axis is 0].

Returns: A new tensor with the values of list of tensors concatenated in order, along the given axis.

◆ CountElemsPerBucketKernel()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::CountElemsPerBucketKernel	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		int64_t *	bucket_elem_counts
	)

◆ CountSlabsPerSuperblockKernel()

__global__ void open3d::core::CountSlabsPerSuperblockKernel	(	SlabNodeManagerImpl	impl,
		uint32_t *	slabs_per_superblock
	)

◆ CPUResetHeap()

void open3d::core::CPUResetHeap ( Tensor & heap )

◆ CreateCPUHashBackend()

std::shared_ptr< DeviceHashBackend > open3d::core::CreateCPUHashBackend	(	int64_t	init_capacity,
		const Dtype &	key_dtype,
		const SizeVector &	key_element_shape,
		const std::vector< Dtype > &	value_dtypes,
		const std::vector< SizeVector > &	value_element_shapes,
		const Device &	device,
		const HashBackendType &	backend
	)

Non-templated factory.

◆ CreateCUDAHashBackend()

std::shared_ptr<DeviceHashBackend> open3d::core::CreateCUDAHashBackend	(	int64_t	init_capacity,
		const Dtype &	key_dtype,
		const SizeVector &	key_element_shape,
		const std::vector< Dtype > &	value_dtypes,
		const std::vector< SizeVector > &	value_element_shapes,
		const Device &	device,
		const HashBackendType &	backend
	)

◆ CreateDeviceHashBackend()

std::shared_ptr< DeviceHashBackend > open3d::core::CreateDeviceHashBackend	(	int64_t	init_capacity,
		const Dtype &	key_dtype,
		const SizeVector &	key_element_shape,
		const std::vector< Dtype > &	value_dtypes,
		const std::vector< SizeVector > &	value_element_shapes,
		const Device &	device,
		const HashBackendType &	backend
	)

Factory functions:

Default constructor switch is in DeviceHashBackend.cpp
Default CPU constructor is in CPU/CreateCPUHashBackend.cpp
Default CUDA constructor is in CUDA/CreateCUDAHashBackend.cu

◆ Det()

double open3d::core::Det ( const Tensor & A )

◆ EraseKernelPass0()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::EraseKernelPass0	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count
	)

◆ EraseKernelPass1()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::EraseKernelPass1	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count
	)

◆ FindKernel()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::FindKernel	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count
	)

◆ gels_cpu()

template<typename scalar_t >

OPEN3D_CPU_LINALG_INT open3d::core::gels_cpu	(	int	matrix_layout,
		char	trans,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	nrhs,
		scalar_t *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		scalar_t *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb
	)

inline

◆ gels_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gels_cpu< double >	(	int	layout,
		char	trans,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	nrhs,
		double *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		double *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb
	)

inline

◆ gels_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gels_cpu< float >	(	int	layout,
		char	trans,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	nrhs,
		float *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		float *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb
	)

inline

◆ gemm_cpu()

template<typename scalar_t >

void open3d::core::gemm_cpu	(	CBLAS_LAYOUT	layout,
		CBLAS_TRANSPOSE	trans_A,
		CBLAS_TRANSPOSE	trans_B,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	k,
		scalar_t	alpha,
		const scalar_t *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		const scalar_t *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb,
		scalar_t	beta,
		scalar_t *	C_data,
		OPEN3D_CPU_LINALG_INT	ldc
	)

inline

◆ gemm_cpu< double >()

template<>

void open3d::core::gemm_cpu< double >	(	CBLAS_LAYOUT	layout,
		CBLAS_TRANSPOSE	trans_A,
		CBLAS_TRANSPOSE	trans_B,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	k,
		double	alpha,
		const double *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		const double *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb,
		double	beta,
		double *	C_data,
		OPEN3D_CPU_LINALG_INT	ldc
	)

inline

◆ gemm_cpu< float >()

template<>

void open3d::core::gemm_cpu< float >	(	CBLAS_LAYOUT	layout,
		CBLAS_TRANSPOSE	trans_A,
		CBLAS_TRANSPOSE	trans_B,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	k,
		float	alpha,
		const float *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		const float *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb,
		float	beta,
		float *	C_data,
		OPEN3D_CPU_LINALG_INT	ldc
	)

inline

◆ gesv_cpu()

template<typename scalar_t >

OPEN3D_CPU_LINALG_INT open3d::core::gesv_cpu	(	int	layout,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	m,
		scalar_t *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data,
		scalar_t *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb
	)

inline

◆ gesv_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesv_cpu< double >	(	int	layout,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	m,
		double *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data,
		double *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb
	)

inline

◆ gesv_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesv_cpu< float >	(	int	layout,
		OPEN3D_CPU_LINALG_INT	n,
		OPEN3D_CPU_LINALG_INT	m,
		float *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data,
		float *	B_data,
		OPEN3D_CPU_LINALG_INT	ldb
	)

inline

◆ gesvd_cpu()

template<typename scalar_t >

OPEN3D_CPU_LINALG_INT open3d::core::gesvd_cpu	(	int	matrix_layout,
		char	jobu,
		char	jobvt,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		scalar_t *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		scalar_t *	S_data,
		scalar_t *	U_data,
		OPEN3D_CPU_LINALG_INT	ldu,
		scalar_t *	VT_data,
		OPEN3D_CPU_LINALG_INT	ldvt,
		scalar_t *	superb
	)

inline

◆ gesvd_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesvd_cpu< double >	(	int	layout,
		char	jobu,
		char	jobvt,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		double *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		double *	S_data,
		double *	U_data,
		OPEN3D_CPU_LINALG_INT	ldu,
		double *	VT_data,
		OPEN3D_CPU_LINALG_INT	ldvt,
		double *	superb
	)

inline

◆ gesvd_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesvd_cpu< float >	(	int	layout,
		char	jobu,
		char	jobvt,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		float *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		float *	S_data,
		float *	U_data,
		OPEN3D_CPU_LINALG_INT	ldu,
		float *	VT_data,
		OPEN3D_CPU_LINALG_INT	ldvt,
		float *	superb
	)

inline

◆ GetActiveIndicesKernel()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::GetActiveIndicesKernel	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		buf_index_t *	output_buf_indices,
		uint32_t *	output_count
	)

◆ getrf_cpu()

template<typename scalar_t >

OPEN3D_CPU_LINALG_INT open3d::core::getrf_cpu	(	int	layout,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		scalar_t *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data
	)

inline

◆ getrf_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getrf_cpu< double >	(	int	layout,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		double *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data
	)

inline

◆ getrf_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getrf_cpu< float >	(	int	layout,
		OPEN3D_CPU_LINALG_INT	m,
		OPEN3D_CPU_LINALG_INT	n,
		float *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data
	)

inline

◆ getri_cpu()

template<typename scalar_t >

OPEN3D_CPU_LINALG_INT open3d::core::getri_cpu	(	int	layout,
		OPEN3D_CPU_LINALG_INT	n,
		scalar_t *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data
	)

inline

◆ getri_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getri_cpu< double >	(	int	layout,
		OPEN3D_CPU_LINALG_INT	n,
		double *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data
	)

inline

◆ getri_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getri_cpu< float >	(	int	layout,
		OPEN3D_CPU_LINALG_INT	n,
		float *	A_data,
		OPEN3D_CPU_LINALG_INT	lda,
		OPEN3D_CPU_LINALG_INT *	ipiv_data
	)

inline

◆ InsertKernelPass0()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::InsertKernelPass0	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		int	heap_counter_prev,
		int64_t	count
	)

Kernels.

◆ InsertKernelPass1()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::InsertKernelPass1	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count
	)

◆ InsertKernelPass2()

template<typename Key , typename Hash , typename Eq , typename block_t >

__global__ void open3d::core::InsertKernelPass2	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void const	input_values_soa,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count,
		int64_t	n_values
	)

◆ Inverse()

void open3d::core::Inverse	(	const Tensor &	A,
		Tensor &	output
	)

Computes A^{-1} with LU factorization, where A is a N x N square matrix.

◆ InverseCPU() [1/2]

void open3d::core::InverseCPU	(	void *	A_data,
		void *	ipiv_data,
		[[maybe_unused] ] void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ InverseCPU() [2/2]

void open3d::core::InverseCPU	(	void *	A_data,
		void *	ipiv_data,
		void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ InverseCUDA()

void open3d::core::InverseCUDA	(	void *	A_data,
		void *	ipiv_data,
		void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ InverseSYCL()

void open3d::core::InverseSYCL	(	void *	A_data,
		void *	ipiv_data,
		void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ LeastSquares()

void open3d::core::LeastSquares	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	X
	)

Solve AX = B with QR decomposition. A is a full-rank m x n matrix (m >= n).

◆ LeastSquaresCPU()

void open3d::core::LeastSquaresCPU	(	void *	A_data,
		void *	B_data,
		int64_t	m,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device
	)

◆ LeastSquaresCUDA()

void open3d::core::LeastSquaresCUDA	(	void *	A_data,
		void *	B_data,
		int64_t	m,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device
	)

◆ LeastSquaresSYCL()

void open3d::core::LeastSquaresSYCL	(	void *	A_data,
		void *	B_data,
		int64_t	m,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device
	)

◆ LU()

void open3d::core::LU	(	const Tensor &	A,
		Tensor &	permutation,
		Tensor &	lower,
		Tensor &	upper,
		const bool	permute_l
	)

◆ LUCPU()

void open3d::core::LUCPU	(	void *	A_data,
		void *	ipiv_data,
		int64_t	rows,
		int64_t	cols,
		Dtype	dtype,
		const Device &	device
	)

◆ LUCUDA()

void open3d::core::LUCUDA	(	void *	A_data,
		void *	ipiv_data,
		int64_t	rows,
		int64_t	cols,
		Dtype	dtype,
		const Device &	device
	)

◆ LUIpiv()

void open3d::core::LUIpiv	(	const Tensor &	A,
		Tensor &	ipiv,
		Tensor &	output
	)

◆ LUSYCL()

void open3d::core::LUSYCL	(	void *	A_data,
		void *	ipiv_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ make_pair()

template<typename First , typename Second >

OPEN3D_HOST_DEVICE Pair<First, Second> open3d::core::make_pair	(	const First &	_first,
		const Second &	_second
	)

◆ Matmul()

void open3d::core::Matmul	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	output
	)

Computes matrix multiplication C = AB.

◆ MatmulCPU()

void open3d::core::MatmulCPU	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		Dtype	dtype
	)

◆ MatmulCUDA()

void open3d::core::MatmulCUDA	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ MatmulSYCL()

void open3d::core::MatmulSYCL	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ Maximum()

Tensor open3d::core::Maximum	(	const Tensor &	input,
		const Tensor &	other
	)

Computes the element-wise maximum of input and other. The tensors must have same data type and device.

If input.GetShape() != other.GetShape(), then they will be broadcasted to a common shape (which becomes the shape of the output).

Parameters

input	The input tensor.
other	The second input tensor.

◆ Minimum()

Tensor open3d::core::Minimum	(	const Tensor &	input,
		const Tensor &	other
	)

Computes the element-wise minimum of input and other. The tensors must have same data type and device.

If input.GetShape() != other.GetShape(), then they will be broadcasted to a common shape (which becomes the shape of the output).

Parameters

input	The input tensor.
other	The second input tensor.

◆ OPEN3D_LAPACK_CHECK()

void open3d::core::OPEN3D_LAPACK_CHECK	(	OPEN3D_CPU_LINALG_INT	info,
		const std::string &	msg
	)

inline

◆ operator*()

template<typename T >

Tensor open3d::core::operator*	(	T	scalar_lhs,
		const Tensor &	rhs
	)

inline

◆ operator+()

template<typename T >

Tensor open3d::core::operator+	(	T	scalar_lhs,
		const Tensor &	rhs
	)

inline

◆ operator-()

template<typename T >

Tensor open3d::core::operator-	(	T	scalar_lhs,
		const Tensor &	rhs
	)

inline

◆ operator/()

template<typename T >

Tensor open3d::core::operator/	(	T	scalar_lhs,
		const Tensor &	rhs
	)

inline

◆ ParallelFor() [1/2]

template<typename func_t >

void open3d::core::ParallelFor	(	const Device &	device,
		int64_t	n,
		const func_t &	func
	)

Run a function in parallel on CPU or CUDA.

Parameters

device	The device for the parallel for loop to run on.
n	The number of workloads.
func	The function to be executed in parallel. The function should take an int64_t workload index and returns void, i.e., `void func(int64_t)`.

Note

This is optimized for uniform work items, i.e. where each call to func takes the same time.

If you use a lambda function, capture only the required variables instead of all to prevent accidental race conditions. If you want the kernel to be used on both CPU and CUDA, capture the variables by value.

This does not dispatch to SYCL, since SYCL has extra constraints:

Lambdas may capture by value only.
No function pointers / virtual functions. Auto dispatch to SYCL will enforce these conditions even on CPU devices. Use ParallelForSYCL instead.

◆ ParallelFor() [2/2]

template<typename vec_func_t , typename func_t >

void open3d::core::ParallelFor	(	const Device &	device,
		int64_t	n,
		const func_t &	func,
		const vec_func_t &	vec_func
	)

Run a potentially vectorized function in parallel on CPU or CUDA.

Parameters

device	The device for the parallel for loop to run on.
n	The number of workloads.
func	The function to be executed in parallel. The function should take an int64_t workload index and returns void, i.e., `void func(int64_t)`.
vec_func	The vectorized function to be executed in parallel. The function should be provided using the OPEN3D_VECTORIZED macro, e.g., `OPEN3D_VECTORIZED(MyISPCKernel, some_used_variable)`.

Note: This is optimized for uniform work items, i.e. where each call to func takes the same time.; If you use a lambda function, capture only the required variables instead of all to prevent accidental race conditions. If you want the kernel to be used on both CPU and CUDA, capture the variables by value.

Example:

/* MyFile.cpp */
#ifdef BUILD_ISPC_MODULE
#include "MyFile_ispc.h"
#endif
 
std::vector<float> v(1000);
float fill_value = 42.0f;
core::ParallelFor(
        core::Device("CPU:0"),
        v.size(),
        [&](int64_t idx) { v[idx] = fill_value; },
        OPEN3D_VECTORIZED(MyFillKernel, v.data(), fill_value));
 
/* MyFile.ispc */
#include "open3d/core/ParallelFor.isph"
 
static inline void MyFillFunction(int64_t idx,
                                  float* uniform v,
                                  uniform float fill_value) {
    v[idx] = fill_value;
}
 
OPEN3D_EXPORT_VECTORIZED(MyFillKernel,
                         MyFillFunction,
                         float* uniform,
                         uniform float)

◆ ParallelForCPU_()

template<typename func_t >

void open3d::core::ParallelForCPU_	(	const Device &	device,
		int64_t	n,
		const func_t &	func
	)

Run a function in parallel on CPU.

◆ ParallelForSYCL() [1/2]

template<typename Functor , typename... FuncArgs>

void open3d::core::ParallelForSYCL	(	const Device &	device,
		Indexer	indexer,
		FuncArgs...	func_args
	)

Run a function in parallel with SYCL.

TODO: Specify grid size based on device properties

◆ ParallelForSYCL() [2/2]

template<typename Functor , typename... FuncArgs>

void open3d::core::ParallelForSYCL	(	const Device &	device,
		int64_t	num_workloads,
		FuncArgs...	func_args
	)

Run a function in parallel with SYCL.

TODO: Specify grid size based on device properties

◆ safe_malloc()

void* open3d::core::safe_malloc ( size_t Sz )

inline

◆ safe_realloc()

void* open3d::core::safe_realloc	(	void *	Ptr,
		size_t	Sz
	)

inline

◆ Solve()

void open3d::core::Solve	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	X
	)

Solve AX = B with LU decomposition. A is a square matrix.

◆ SolveCPU()

void open3d::core::SolveCPU	(	void *	A_data,
		void *	B_data,
		void *	ipiv_data,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device
	)

◆ SolveCUDA()

void open3d::core::SolveCUDA	(	void *	A_data,
		void *	B_data,
		void *	ipiv_data,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device
	)

◆ SolveSYCL()

void open3d::core::SolveSYCL	(	void *	A_data,
		void *	B_data,
		void *	ipiv_data,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device
	)

◆ STDGPUEraseKernel()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::STDGPUEraseKernel	(	InternalStdGPUHashBackend< Key, Hash, Eq >	map,
		CUDAHashBackendBufferAccessor	buffer_accessor,
		const Key *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count
	)

◆ STDGPUFindKernel()

template<typename Key , typename Hash , typename Eq >

__global__ void open3d::core::STDGPUFindKernel	(	InternalStdGPUHashBackend< Key, Hash, Eq >	map,
		CUDAHashBackendBufferAccessor	buffer_accessor,
		const Key *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count
	)

◆ STDGPUInsertKernel()

template<typename Key , typename Hash , typename Eq , typename block_t >

__global__ void open3d::core::STDGPUInsertKernel	(	InternalStdGPUHashBackend< Key, Hash, Eq >	map,
		CUDAHashBackendBufferAccessor	buffer_accessor,
		const Key *	input_keys,
		const void const	input_values_soa,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count,
		int64_t	n_values
	)

◆ SVD()

void open3d::core::SVD	(	const Tensor &	A,
		Tensor &	U,
		Tensor &	S,
		Tensor &	VT
	)

Computes SVD decomposition A = U S VT, where A is an m x n, U is an m x m, S is a min(m, n), VT is an n x n tensor.

◆ SVDCPU()

void open3d::core::SVDCPU	(	const void *	A_data,
		void *	U_data,
		void *	S_data,
		void *	VT_data,
		void *	superb_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ SVDCUDA()

void open3d::core::SVDCUDA	(	const void *	A_data,
		void *	U_data,
		void *	S_data,
		void *	VT_data,
		void *	superb_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ SVDSYCL()

void open3d::core::SVDSYCL	(	const void *	A_data,
		void *	U_data,
		void *	S_data,
		void *	VT_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device
	)

◆ to_vector() [1/2]

template<unsigned Size, typename R >

SmallVector<ValueTypeFromRangeType<R>, Size> open3d::core::to_vector ( R && Range )

Given a range of type R, iterate the entire range and return a SmallVector with elements of the vector. This is useful, for example, when you want to iterate a range and then sort the results.

◆ to_vector() [2/2]

template<typename R >

SmallVector<ValueTypeFromRangeType<R>, CalculateSmallVectorDefaultInlinedElements< ValueTypeFromRangeType<R> >::value> open3d::core::to_vector ( R && Range )

◆ Tril()

void open3d::core::Tril	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal
	)

◆ TrilCPU()

void open3d::core::TrilCPU	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal
	)

◆ TrilSYCL()

void open3d::core::TrilSYCL	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal
	)

◆ Triu()

void open3d::core::Triu	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal
	)

◆ TriuCPU()

void open3d::core::TriuCPU	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal
	)

◆ Triul()

void open3d::core::Triul	(	const Tensor &	A,
		Tensor &	upper,
		Tensor &	lower,
		const int	diagonal
	)

◆ TriulCPU()

void open3d::core::TriulCPU	(	const Tensor &	A,
		Tensor &	upper,
		Tensor &	lower,
		const int	diagonal
	)

◆ TriulSYCL()

void open3d::core::TriulSYCL	(	const Tensor &	A,
		Tensor &	upper,
		Tensor &	lower,
		const int	diagonal
	)

◆ TriuSYCL()

void open3d::core::TriuSYCL	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal
	)

Variable Documentation

◆ Bool

OPEN3D_API const Dtype open3d::core::Bool = Dtype::Bool

◆ Float32

OPEN3D_API const Dtype open3d::core::Float32 = Dtype::Float32

◆ Float64

OPEN3D_API const Dtype open3d::core::Float64 = Dtype::Float64

◆ Int16

OPEN3D_API const Dtype open3d::core::Int16 = Dtype::Int16

◆ Int32

OPEN3D_API const Dtype open3d::core::Int32 = Dtype::Int32

◆ Int64

OPEN3D_API const Dtype open3d::core::Int64 = Dtype::Int64

◆ Int8

OPEN3D_API const Dtype open3d::core::Int8 = Dtype::Int8

◆ None

constexpr utility::nullopt_t open3d::core::None {utility::nullopt_t::init()}

constexpr

◆ SmallVector

template<typename T , unsigned N>

class LLVM_GSL_OWNER open3d::core::SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference sizeof(SmallVector<T, 0>).

◆ UInt16

OPEN3D_API const Dtype open3d::core::UInt16 = Dtype::UInt16

◆ UInt32

OPEN3D_API const Dtype open3d::core::UInt32 = Dtype::UInt32

◆ UInt64

OPEN3D_API const Dtype open3d::core::UInt64 = Dtype::UInt64

◆ UInt8

OPEN3D_API const Dtype open3d::core::UInt8 = Dtype::UInt8

◆ Undefined

OPEN3D_API const Dtype open3d::core::Undefined = Dtype::Undefined

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ buf_index_t

◆ InternalStdGPUHashBackend

◆ InternalStdGPUHashBackendAllocator

◆ SmallVectorSizeType

◆ ValueTypeFromRangeType

Enumeration Type Documentation

◆ DtypePolicy

◆ HashBackendType

Function Documentation

◆ AddMM()

◆ AddMMCPU()

◆ AddMMCUDA()

◆ AddMMSYCL()

◆ Append()

◆ AssertNotSYCL()

◆ AtomicFetchAddRelaxed() [1/2]

◆ AtomicFetchAddRelaxed() [2/2]

◆ capacity_in_bytes()

◆ Concatenate()

◆ CountElemsPerBucketKernel()

◆ CountSlabsPerSuperblockKernel()

◆ CPUResetHeap()

◆ CreateCPUHashBackend()

◆ CreateCUDAHashBackend()

◆ CreateDeviceHashBackend()

◆ Det()

◆ EraseKernelPass0()

◆ EraseKernelPass1()

◆ FindKernel()

◆ gels_cpu()

◆ gels_cpu< double >()

◆ gels_cpu< float >()

◆ gemm_cpu()

◆ gemm_cpu< double >()

◆ gemm_cpu< float >()

◆ gesv_cpu()

◆ gesv_cpu< double >()

◆ gesv_cpu< float >()

◆ gesvd_cpu()

◆ gesvd_cpu< double >()

◆ gesvd_cpu< float >()

◆ GetActiveIndicesKernel()

◆ getrf_cpu()

◆ getrf_cpu< double >()

◆ getrf_cpu< float >()

◆ getri_cpu()

◆ getri_cpu< double >()

◆ getri_cpu< float >()

◆ InsertKernelPass0()

◆ InsertKernelPass1()

◆ InsertKernelPass2()

◆ Inverse()

◆ InverseCPU() [1/2]

◆ InverseCPU() [2/2]

◆ InverseCUDA()

◆ InverseSYCL()

◆ LeastSquares()

◆ LeastSquaresCPU()

◆ LeastSquaresCUDA()

◆ LeastSquaresSYCL()

◆ LU()

◆ LUCPU()

◆ LUCUDA()

◆ LUIpiv()

◆ LUSYCL()

◆ make_pair()

◆ Matmul()

◆ MatmulCPU()

◆ MatmulCUDA()

◆ MatmulSYCL()

◆ Maximum()

◆ Minimum()

◆ OPEN3D_LAPACK_CHECK()