Open3D (C++ API)  0.18.0+80ae047
Namespaces | Data Structures | Typedefs | Enumerations | Functions | Variables
open3d::core Namespace Reference

Namespaces

 cuda
 
 eigen_converter
 
 kernel
 
 linalg
 
 nns
 
 shape_util
 
 sycl
 
 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< thrust::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< DeviceHashBackendCreateCPUHashBackend (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< DeviceHashBackendCreateDeviceHashBackend (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< DeviceHashBackendCreateCUDAHashBackend (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)
 
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, 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)
 
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 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 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 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 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 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)
 
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)
 
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)
 
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<thrust::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

Enumerator
NONE 
ALL_SAME 
INPUT_SAME 
INPUT_SAME_OUTPUT_BOOL 

◆ HashBackendType

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 
)

◆ 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:

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]
Tensor Append(const Tensor &self, const Tensor &other, const utility::optional< int64_t > &axis)
Appends the two tensors, along the given axis into a new tensor. Both the tensors must have same data...
Definition: TensorFunction.cpp:118
Parameters
selfValues are appended to a copy of this tensor.
otherValues 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.

◆ 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:

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]
Tensor Concatenate(const std::vector< Tensor > &tensors, const utility::optional< int64_t > &axis)
Concatenates the list of tensors in their order, along the given axis into a new tensor....
Definition: TensorFunction.cpp:79
Parameters
tensorsVector 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:

◆ 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()

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 
)

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ 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
inputThe input tensor.
otherThe 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
inputThe input tensor.
otherThe 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* ( scalar_lhs,
const Tensor rhs 
)
inline

◆ operator+()

template<typename T >
Tensor open3d::core::operator+ ( scalar_lhs,
const Tensor rhs 
)
inline

◆ operator-()

template<typename T >
Tensor open3d::core::operator- ( scalar_lhs,
const Tensor rhs 
)
inline

◆ operator/()

template<typename T >
Tensor open3d::core::operator/ ( 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
deviceThe device for the parallel for loop to run on.
nThe number of workloads.
funcThe 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.

◆ 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
deviceThe device for the parallel for loop to run on.
nThe number of workloads.
funcThe 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_funcThe 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::Device("CPU:0"),
v.size(),
[&](int64_t idx) { v[idx] = fill_value; },
OPEN3D_VECTORIZED(MyFillKernel, v.data(), fill_value));
/* MyFile.ispc */
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)
#define OPEN3D_VECTORIZED(ISPCKernel,...)
Definition: ParallelFor.h:220
void ParallelFor(const Device &device, int64_t n, const func_t &func)
Definition: ParallelFor.h:103

◆ 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.

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ 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 
)

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