| [[ |
| name: storageOffset |
| python_name: storage_offset |
| cpu_half: True |
| auto_gpu: False |
| return: long |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: nDimension |
| python_name: ndimension |
| cpu_half: True |
| auto_gpu: False |
| return: long |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: resize_ |
| return: self |
| cname: resize |
| cpu_half: True |
| before_call: |
| THPUtils_assert(arg_self->storage->flag & TH_STORAGE_RESIZABLE, |
| "calling resize_ on a tensor that has non-resizable storage. Clone it first " |
| "or create a new tensor instead."); |
| arguments: |
| - THTensor* self |
| - arg: THSize* size |
| long_args: True |
| - CONSTANT NULL |
| ]] |
| [[ |
| name: zeros |
| variants: |
| - function |
| aten_sparse: True |
| auto_gpu: False |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THSize* size |
| long_args: True |
| ]] |
| [[ |
| name: zeros_like |
| cname: zerosLike |
| aten_sparse: True |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* input |
| ]] |
| [[ |
| name: ones |
| variants: |
| - function |
| auto_gpu: False |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THSize* size |
| long_args: True |
| ]] |
| [[ |
| name: ones_like |
| cname: onesLike |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* input |
| ]] |
| [[ |
| name: numel |
| return: long |
| cname: nElement |
| cpu_half: True |
| auto_gpu: False |
| variants: |
| - method |
| - function |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: set_ |
| cname: set |
| cpu_half: True |
| auto_gpu: False |
| return: argument 0 |
| options: |
| - cname: set |
| scalar_check: source_->isScalar() |
| arguments: |
| - THTensor* self |
| - THTensor* source |
| - cname: setStorage |
| scalar_check: False |
| arguments: |
| - THTensor* self |
| - CONSTANT NULL, 0, NULL, NULL |
| - cname: setStorage |
| before_call: THLongStoragePtr __storage_size(THLongStorage_newWithSize1(THStorage_(size)(LIBRARY_STATE arg_storage))); |
| scalar_check: False |
| arguments: |
| - THTensor* self |
| - THStorage* storage |
| - CONSTANT 0 |
| - CONSTANT __storage_size.get() |
| - CONSTANT NULL |
| - cname: setStorage |
| arguments: |
| - THTensor* self |
| - THStorage* sourceStorage |
| - long storage_offset |
| - THSize* size |
| - arg: THStride* stride |
| default: NULL |
| ]] |
| [[ |
| name: fill_ |
| return: self |
| cname: fill |
| options: |
| - arguments: |
| - THTensor* self |
| - real value |
| - zero_dim_tensor_only: True |
| arguments: |
| - THTensor* self |
| - THTensor* value |
| ]] |
| [[ |
| name: isContiguous |
| python_name: is_contiguous |
| cpu_half: True |
| auto_gpu: False |
| return: bool |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: isSetTo |
| python_name: is_set_to |
| cpu_half: True |
| auto_gpu: False |
| return: bool |
| arguments: |
| - THTensor* self |
| - THTensor* tensor |
| ]] |
| [[ |
| name: maskedFill_ |
| cname: maskedFill |
| python_name: masked_fill_ |
| return: self |
| options: |
| - arguments: |
| - arg: THTensor* self |
| broadcast: mask inplace fallback types:Byte |
| - THBoolTensor* mask |
| - real value |
| - zero_dim_tensor_only: True |
| arguments: |
| - arg: THTensor* self |
| broadcast: mask inplace fallback types:Byte |
| - THBoolTensor* mask |
| - THTensor* value |
| ]] |
| [[ |
| name: maskedCopy_ |
| cname: maskedCopy |
| python_name: masked_scatter_ |
| return: self |
| arguments: |
| - arg: THTensor* self |
| broadcast: mask inplace fallback types:Byte |
| - THBoolTensor* mask |
| - THTensor* source |
| ]] |
| [[ |
| name: maskedSelect |
| python_name: masked_select |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: mask fallback types:Byte |
| - THBoolTensor* mask |
| ]] |
| [[ |
| name: transpose |
| variants: |
| - method |
| - function |
| cname: newTranspose |
| aten_sparse: True |
| cpu_half: True |
| auto_gpu: False |
| return: THTensor* |
| arguments: |
| - THTensor* self |
| - arg: long dim0 |
| wrap_dim: self |
| - arg: long dim1 |
| wrap_dim: self |
| ]] |
| [[ |
| name: t |
| cname: newTranspose |
| cpu_half: True |
| aten_sparse: True |
| variants: |
| - method |
| - function |
| auto_gpu: False |
| return: THTensor* |
| before_call: | |
| if (self.is_sparse) { |
| int64_t nDimI = arg_self->nDimensionI; |
| int64_t nDimV = arg_self->nDimensionV; |
| THPUtils_assert(nDimI == 2 && nDimV == 0, "t() expects a 2D sparse tensor, but self is %ldD indices and %ldD values", nDimI, nDimV); |
| } else { |
| long ndim = arg_self->nDimension; |
| THPUtils_assert(ndim == 2, "t() expects a 2D tensor, but self is %ldD", ndim); |
| } |
| arguments: |
| - THTensor* self |
| - CONSTANT 0 |
| - CONSTANT 1 |
| ]] |
| [[ |
| name: nonzero |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THIndexTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: contiguous |
| cname: newContiguous |
| return: THTensor* |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: clone |
| cname: newClone |
| return: THTensor* |
| aten_sparse: True |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: view |
| cname: newView |
| auto_gpu: False |
| return: THTensor* |
| arguments: |
| - THTensor* self |
| - arg: THSize* size |
| long_args: True |
| ]] |
| [[ |
| name: resizeAs_ |
| python_name: resize_as_ |
| cname: resizeAs |
| aten_sparse: True |
| return: self |
| scalar_check: the_template_->isScalar() |
| arguments: |
| - THTensor* self |
| - THTensor* the_template |
| ]] |
| [[ |
| name: indexSelect |
| python_name: index_select |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| ]] |
| [[ |
| name: indexCopy_ |
| python_name: index_copy_ |
| cname: indexCopy |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - THTensor* source |
| ]] |
| [[ |
| name: take |
| cname: take |
| variants: |
| - method |
| - function |
| return: argument 0 |
| scalar_check: index_->isScalar() |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THIndexTensor* index |
| ]] |
| [[ |
| name: put_ |
| cname: put |
| backends: |
| - CPU |
| - CUDA |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THIndexTensor* index |
| - THTensor* source |
| - arg: bool accumulate |
| default: "false" |
| ]] |
| [[ |
| name: indexAdd_ |
| python_name: index_add_ |
| cname: indexAdd |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - THTensor* source |
| ]] |
| [[ |
| name: indexFill_ |
| python_name: index_fill_ |
| cname: indexFill |
| return: argument 0 |
| options: |
| - arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - real value |
| - zero_dim_tensor_only: True |
| arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - THTensor* value |
| ]] |
| [[ |
| name: unfold |
| cpu_half: True |
| auto_gpu: False |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dimension |
| wrap_dim: self |
| - long size |
| - long step |
| ]] |
| [[ |
| name: range |
| variants: |
| - function |
| backends: |
| - CPU |
| - CUDA |
| return: argument 0 |
| before_arg_assign: | |
| PyErr_WarnEx(PyExc_UserWarning, "torch.range is deprecated in favor of torch.arange " |
| "and will be removed in 0.3. Note that arange generates values in [start; end), " |
| "not [start; end].", 1); |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - accreal start |
| - accreal end |
| - arg: accreal step |
| default: 1 |
| ]] |
| [[ |
| name: arange |
| variants: |
| - function |
| backends: |
| - CPU |
| - CUDA |
| return: argument 0 |
| options: |
| - cname: arange |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - accreal start |
| - accreal end |
| - arg: accreal step |
| default: 1 |
| - cname: arange |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - CONSTANT 0 |
| - accreal end |
| - CONSTANT 1 |
| ]] |
| [[ |
| name: scatter_ |
| return: argument 0 |
| options: |
| - cname: scatter |
| arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - THTensor* src |
| - cname: scatterFill |
| arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - real value |
| ]] |
| [[ |
| name: scatter_add_ |
| return: argument 0 |
| cname: scatterAdd |
| arguments: |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| - THTensor* src |
| ]] |
| [[ |
| name: gather |
| variants: |
| - method |
| - function |
| return: argument 0 |
| before_call: | |
| THLongStoragePtr _size(THIndexTensor_(newSizeOf)(LIBRARY_STATE arg_index)); |
| THTensor_(resize)(LIBRARY_STATE arg_result, _size, NULL); |
| arguments: |
| - arg: THTensor* result |
| output: True |
| resize: index |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| ]] |
| [[ |
| name: data_ptr |
| with_gil: True |
| auto_gpu: False |
| return: void* |
| cpu_half: True |
| cname: data |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: equal |
| variants: |
| - method |
| - function |
| return: bool |
| arguments: |
| - THTensor* self |
| - THTensor* other |
| ]] |
| [[ |
| name: __and__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: bitand |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cbitand |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __iand__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: bitand |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cbitand |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __or__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: bitor |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cbitor |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __ior__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: bitor |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cbitor |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __xor__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: bitxor |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cbitxor |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __ixor__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: bitxor |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cbitxor |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __lshift__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: lshift |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: clshift |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __ilshift__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: lshift |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: clshift |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __rshift__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: rshift |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: crshift |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: __irshift__ |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: rshift |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: crshift |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: lt |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: ltValue |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: ltTensor |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: lt_ |
| return: self |
| options: |
| - cname: ltValueT |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: ltTensorT |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - arg: THTensor* other |
| ]] |
| [[ |
| name: gt |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: gtValue |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: gtTensor |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: gt_ |
| return: self |
| options: |
| - cname: gtValueT |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: gtTensorT |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: le |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: leValue |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: leTensor |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: le_ |
| return: self |
| options: |
| - cname: leValueT |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: leTensorT |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: ge |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: geValue |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: geTensor |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: ge_ |
| return: self |
| options: |
| - cname: geValueT |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: geTensorT |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: eq |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: eqValue |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: eqTensor |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: eq_ |
| return: self |
| options: |
| - cname: eqValueT |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: eqTensorT |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: ne |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: neValue |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: neTensor |
| arguments: |
| - arg: THBoolTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: ne_ |
| return: self |
| options: |
| - cname: neValueT |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: neTensorT |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: min |
| variants: |
| - method |
| - function |
| options: |
| - cname: minall |
| return: real |
| arguments: |
| - THTensor* self |
| - cname: cmin |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| - cname: min |
| return: argument 0,1 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* min |
| output: True |
| - arg: THIndexTensor* min_indices |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: max |
| variants: |
| - method |
| - function |
| options: |
| - cname: maxall |
| return: real |
| arguments: |
| - THTensor* self |
| - cname: cmax |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| - cname: max |
| return: argument 0,1 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* max |
| output: True |
| - arg: THIndexTensor* max_indices |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: kthvalue |
| backends: |
| - CPU |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* values |
| output: True |
| - arg: THIndexTensor* indices |
| output: True |
| - THTensor* self |
| - long k |
| - arg: long dim |
| wrap_dim: self |
| default: __last_dim |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: mode |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* values |
| output: True |
| - arg: THIndexTensor* indices |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| default: __last_dim |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: median |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| options: |
| - cname: medianall |
| return: real |
| arguments: |
| - THTensor* self |
| - cname: median |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* values |
| output: True |
| - arg: THIndexTensor* indices |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: sort |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* values |
| output: True |
| - arg: THIndexTensor* indices |
| output: True |
| - THTensor* self |
| - arg: long dim |
| default: __last_dim |
| wrap_dim: self |
| - arg: bool descending |
| default: "false" |
| ]] |
| [[ |
| name: topk |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* values |
| output: True |
| - arg: THIndexTensor* indices |
| output: True |
| - THTensor* self |
| - long k |
| - arg: long dim |
| default: __last_dim |
| wrap_dim: self |
| - arg: bool largest |
| default: "true" |
| - arg: bool sorted |
| default: "true" |
| ]] |
| [[ |
| name: all |
| types: |
| - Byte |
| backends: |
| - CPU |
| - CUDA |
| cname: logicalall |
| return: real |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: any |
| types: |
| - Byte |
| backends: |
| - CPU |
| - CUDA |
| cname: logicalany |
| return: real |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: getDevice |
| python_name: get_device |
| backends: |
| - CUDA |
| aten_sparse: True |
| return: long |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: abs |
| return: argument 0 |
| types: |
| - floating_point |
| - Long |
| - Int |
| - Short |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: abs_ |
| cname: abs |
| return: self |
| types: |
| - floating_point |
| - Long |
| - Int |
| - Short |
| backends: |
| - CPU |
| - CUDA |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: sigmoid_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: sigmoid |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: sigmoid |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: sigmoid |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: log_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: log |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: log |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: log1p_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: log1p |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: log1p |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: lgamma |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: lgamma_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: lgamma |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: digamma |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: digamma_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: digamma |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: polygamma |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - int64_t n |
| - THTensor* self |
| ]] |
| [[ |
| name: polygamma_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: polygamma |
| return: self |
| arguments: |
| - THTensor* self |
| - int64_t n |
| - THTensor* self |
| ]] |
| [[ |
| name: exp_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: exp |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: exp |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: expm1_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: expm1 |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: expm1 |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: cos_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: cos |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: cos |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: acos_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: acos |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: acos |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: cosh_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: cosh |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: cosh |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: sin_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: sin |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: sin |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: asin_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: asin |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: asin |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: sinh_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: sinh |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: sinh |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: tan_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: tan |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: tan |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: atan_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: atan |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: atan |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: tanh_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: tanh |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: tanh |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: erf_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: erf |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: erf |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: erfinv_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: erfinv |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: erfinv |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: sqrt_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: sqrt |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: sqrt |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: rsqrt_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: rsqrt |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: rsqrt |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: ceil_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: ceil |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: ceil |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: floor_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: floor |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: floor |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: round_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: round |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: round |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: trunc_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: trunc |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: trunc |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: frac_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: frac |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: frac |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: mean |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: meanall |
| return: accreal |
| arguments: |
| - THTensor* self |
| - cname: mean |
| return: argument 0 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: var |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: varall |
| return: accreal |
| arguments: |
| - THTensor* self |
| - arg: bool unbiased |
| if_true: 0 |
| if_false: 1 |
| default: 0 |
| - cname: var |
| return: argument 0 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool unbiased |
| if_true: 0 |
| if_false: 1 |
| default: 0 |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: std |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: stdall |
| return: accreal |
| arguments: |
| - THTensor* self |
| - arg: bool unbiased |
| if_true: 0 |
| if_false: 1 |
| default: 0 |
| - cname: std |
| return: argument 0 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool unbiased |
| if_true: 0 |
| if_false: 1 |
| default: 0 |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: norm |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: normall |
| aten_sparse: True |
| return: accreal |
| arguments: |
| - THTensor* self |
| - arg: real p |
| default: AS_REAL(2) |
| aten_custom_call: | |
| // norm(value) for a sparse tensor returns a DENSE 0-dim tensor |
| if (self.is_sparse()) { |
| auto result = ${THTensor}_normall(${state,} self_->tensor, convert<${THScalarType}>(p_)); |
| return toBackend(toDense(backend())).tensor({}).fill_(result); |
| } |
| // aten_custom_call is followed by the generated call to normall |
| - cname: norm |
| return: argument 0 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: real p |
| python_default_init: AS_REAL(2) |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: renorm |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real p |
| - arg: long dim |
| wrap_dim: self |
| - real maxnorm |
| ]] |
| [[ |
| name: renorm_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: renorm |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real p |
| - arg: long dim |
| wrap_dim: self |
| - real maxnorm |
| ]] |
| [[ |
| name: dist |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: dist |
| return: accreal |
| arguments: |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| - arg: real p |
| default: AS_REAL(2) |
| ]] |
| [[ |
| name: reciprocal |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: cinv |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: reciprocal_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| options: |
| - cname: cinv |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: neg |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - cname: neg |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: neg_ |
| backends: |
| - CPU |
| - CUDA |
| options: |
| - cname: neg |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: atan2 |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| cname: atan2 |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: atan2_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: atan2 |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other fallback inplace |
| - THTensor* other |
| ]] |
| [[ |
| name: pow |
| types: |
| - floating_point |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: pow |
| aten_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real exponent |
| - cname: cpow |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: exponent fallback |
| - THTensor* exponent |
| ]] |
| [[ |
| name: pow |
| types: |
| - floating_point |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: tpow |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - real base |
| - THTensor* self |
| ]] |
| [[ |
| name: pow_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| return: argument 0 |
| cname: pow |
| options: |
| - cname: pow |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real exponent |
| - cname: cpow |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: exponent inplace fallback |
| - THTensor* exponent |
| ]] |
| [[ |
| name: lerp |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| cname: lerp |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: end fallback |
| - THTensor* end |
| - real weight |
| ]] |
| [[ |
| name: lerp_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| return: self |
| cname: lerp |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: end fallback inplace |
| - THTensor* end |
| - real weight |
| ]] |
| [[ |
| name: linspace |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - real start |
| - real end |
| - arg: long steps |
| default: 100 |
| ]] |
| [[ |
| name: logspace |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - real start |
| - real end |
| - arg: long steps |
| default: 100 |
| ]] |
| [[ |
| name: histc |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long bins |
| default: 100 |
| - arg: real min |
| default: 0 |
| - arg: real max |
| default: 0 |
| ]] |
| [[ |
| name: zero_ |
| cname: zero |
| return: self |
| aten_sparse: True |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: sum |
| variants: |
| - method |
| - function |
| options: |
| - cname: sumall |
| return: accreal |
| arguments: |
| - THTensor* self |
| - cname: sum |
| return: argument 0 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: prod |
| variants: |
| - method |
| - function |
| options: |
| - cname: prodall |
| return: accreal |
| arguments: |
| - THTensor* self |
| - cname: prod |
| return: argument 0 |
| scalar_check: self_->isScalar() || (keepdim == false && self_->dim() == 1) |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - arg: bool keepdim |
| default: "false" |
| ]] |
| [[ |
| name: cumsum |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| ]] |
| [[ |
| name: cumprod |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| ]] |
| [[ |
| name: sign |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: sign_ |
| cname: sign |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| ]] |
| [[ |
| name: trace |
| variants: |
| - method |
| - function |
| return: accreal |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: add |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: add_scaled |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - cname: cadd |
| aten_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* other |
| - sparse: True |
| cname: spcadd |
| aten_dense_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THSTensor* other |
| ]] |
| [[ |
| name: add_ |
| return: argument 0 |
| options: |
| - cname: add_scaled |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - cname: cadd |
| aten_sparse: True |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* other |
| - sparse: True |
| cname: spcadd |
| aten_dense_sparse: True |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THSTensor* other |
| ]] |
| [[ |
| name: sub |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: sub_scaled |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - cname: csub |
| aten_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* other |
| ]] |
| [[ |
| name: sub_ |
| return: argument 0 |
| options: |
| - cname: sub_scaled |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - cname: csub |
| aten_sparse: True |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* other |
| ]] |
| [[ |
| name: mul |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: mul |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cmul |
| aten_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - arg: THTensor* other |
| ]] |
| [[ |
| name: mul_ |
| return: argument 0 |
| options: |
| - cname: mul |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cmul |
| aten_sparse: True |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: div |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: div |
| aten_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cdiv |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: div_ |
| return: argument 0 |
| options: |
| - cname: div |
| aten_sparse: True |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cdiv |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: fmod |
| return: argument 0 |
| variants: |
| - method |
| - function |
| options: |
| - cname: fmod |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cfmod |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: fmod_ |
| return: argument 0 |
| options: |
| - cname: fmod |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cfmod |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: remainder |
| return: argument 0 |
| variants: |
| - method |
| - function |
| options: |
| - cname: remainder |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cremainder |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - arg: THTensor* other |
| ]] |
| [[ |
| name: remainder_ |
| return: argument 0 |
| options: |
| - cname: remainder |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cremainder |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: clamp |
| cname: clamp |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real min |
| - real max |
| ]] |
| [[ |
| name: clamp_ |
| cname: clamp |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real min |
| - real max |
| ]] |
| [[ |
| name: clamp_min |
| cname: cmaxValue |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real min |
| ]] |
| [[ |
| name: clamp_min_ |
| cname: cmaxValue |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real min |
| ]] |
| [[ |
| name: clamp_max |
| cname: cminValue |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real max |
| ]] |
| [[ |
| name: clamp_max_ |
| cname: cminValue |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real max |
| ]] |
| [[ |
| name: _dot |
| backend_type_pairs: [[CUDA,floating_point], [CPU,all]] |
| cname: dot |
| variants: |
| - method |
| - function |
| return: accreal |
| arguments: |
| - arg: THTensor* self |
| assert_ndim: 1 |
| - arg: THTensor* tensor |
| assert_ndim: 1 |
| ]] |
| [[ |
| name: tril |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long diagonal |
| default: 0 |
| ]] |
| [[ |
| name: tril_ |
| cname: tril |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - arg: long diagonal |
| default: 0 |
| ]] |
| [[ |
| name: triu |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long diagonal |
| default: 0 |
| ]] |
| [[ |
| name: triu_ |
| cname: triu |
| return: self |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - arg: long diagonal |
| default: 0 |
| ]] |
| [[ |
| name: cross |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THTensor* other |
| - arg: long dim |
| default: -1 |
| ]] |
| [[ |
| name: eye |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - long n |
| - arg: long m |
| default: -1 |
| ]] |
| [[ |
| name: diag |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long diagonal |
| default: 0 |
| aten_custom_call: | |
| if (self_->isScalar()) { |
| throw std::runtime_error("Input must be 1-d or 2-d"); |
| } |
| ${THTensor}_diag(${state,}result_->tensor, self_->tensor, diagonal); |
| result_->maybeScalar(self_->isScalar()); |
| ]] |
| [[ |
| name: addmm |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - arg: THTensor* self |
| broadcast: mat1,mat2 dims:mat1.dim0,mat2.dim1 |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* mat1 |
| - THTensor* mat2 |
| - sparse: True |
| cname: spaddmm |
| aten_dense_sparse: True |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THSTensor* mat1 |
| - THTensor* mat2 |
| ]] |
| [[ |
| name: addmm_ |
| return: self |
| options: |
| - cname: addmm |
| arguments: |
| - THTensor* self |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* mat1 |
| - THTensor* mat2 |
| - sparse: True |
| cname: spaddmm |
| aten_dense_sparse: True |
| arguments: |
| - arg: THTensor* self |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THSTensor* mat1 |
| - THTensor* mat2 |
| ]] |
| [[ |
| name: _addmv |
| cname: addmv |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - arg: THTensor* self |
| broadcast: mat,vec dims:mat.dim0 |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* mat |
| - THTensor* vec |
| ]] |
| [[ |
| name: _addmv_ |
| cname: addmv |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* mat |
| - THTensor* vec |
| ]] |
| [[ |
| name: _addr |
| cname: addr |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - arg: THTensor* self |
| broadcast: vec1,vec2 dims:vec1.dim0,vec2.dim0 |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* vec1 |
| - THTensor* vec2 |
| ]] |
| [[ |
| name: _addr_ |
| cname: addr |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* vec1 |
| - THTensor* vec2 |
| ]] |
| [[ |
| name: _ger |
| cname: addr |
| variants: |
| - method |
| - function |
| return: argument 0 |
| scalar_check: False |
| before_call: | |
| long s1 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0); |
| long s2 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg5)->cdata, 0); |
| THTensor_(resize2d)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata, s1, s2); |
| arguments: |
| - arg: THTensor* result |
| output: True |
| resize: [ [self,0], [vec2,0] ] |
| resize_scalar: True |
| - CONSTANT AS_REAL(0) |
| - argument 0 |
| - CONSTANT AS_REAL(1) |
| - THTensor* self |
| - THTensor* vec2 |
| ]] |
| [[ |
| name: _mv |
| cname: addmv |
| variants: |
| - method |
| - function |
| return: argument 0 |
| before_call: | |
| long s = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0); |
| THTensor_(resize1d)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata, s); |
| #if !IS_CUDA |
| THTensor_(zero)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata); |
| #endif |
| arguments: |
| - arg: THTensor* result |
| output: True |
| resize: [ [self, 0] ] |
| cpu_zero: True |
| - CONSTANT AS_REAL(0) |
| - argument 0 |
| - CONSTANT AS_REAL(1) |
| - THTensor* self |
| - THTensor* vec |
| ]] |
| [[ |
| name: _mm |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: addmm |
| before_call: | |
| long s1 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0); |
| long s2 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg5)->cdata, 1); |
| THTensor_(resize2d)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata, s1, s2); |
| #if !IS_CUDA |
| THTensor_(zero)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata); |
| #endif |
| arguments: |
| - arg: THTensor* result |
| output: True |
| resize: [ [self, 0], [mat2,1] ] |
| cpu_zero: True |
| - CONSTANT AS_REAL(0) |
| - argument 0 |
| - CONSTANT AS_REAL(1) |
| - THTensor* self |
| - THTensor* mat2 |
| ]] |
| [[ |
| name: bmm |
| cname: baddbmm |
| variants: |
| - method |
| - function |
| return: argument 0 |
| before_call: | |
| long s1 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0); |
| long s2 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 1); |
| long s3 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg5)->cdata, 2); |
| THTensor_(resize3d)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata, s1, s2, s3); |
| #if !IS_CUDA |
| THTensor_(zero)(LIBRARY_STATE ((THPTensor*)$arg0)->cdata); |
| #endif |
| arguments: |
| - arg: THTensor* result |
| output: True |
| resize: [ [self,0], [self,1], [mat2,2] ] |
| cpu_zero: True |
| - CONSTANT AS_REAL(0) |
| - argument 0 |
| - CONSTANT AS_REAL(1) |
| - THTensor* self |
| - THTensor* mat2 |
| ]] |
| [[ |
| name: addbmm |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - arg: THTensor* self |
| broadcast: batch1,batch2 dims:batch1.dim1,batch2.dim2 |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* batch1 |
| - THTensor* batch2 |
| ]] |
| [[ |
| name: addbmm_ |
| cname: addbmm |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* batch1 |
| - THTensor* batch2 |
| ]] |
| [[ |
| name: baddbmm |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - arg: THTensor* self |
| broadcast: batch1,batch2 dims:batch1.dim0,batch1.dim1,batch2.dim2 |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* batch1 |
| - THTensor* batch2 |
| ]] |
| [[ |
| name: baddbmm_ |
| cname: baddbmm |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - arg: real beta |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* self |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* batch1 |
| - THTensor* batch2 |
| ]] |
| [[ |
| name: addcmul |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: tensor1,tensor2 fallback |
| - arg: real value |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* tensor1 |
| - THTensor* tensor2 |
| ]] |
| [[ |
| name: addcmul_ |
| options: |
| - cname: addcmul |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: tensor1,tensor2 inplace fallback |
| - arg: real value |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* tensor1 |
| - THTensor* tensor2 |
| - cname: spaddcmul |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - arg: real value |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THSTensor* tensor1 |
| - THSTensor* tensor2 |
| ]] |
| [[ |
| name: addcdiv |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: tensor1,tensor2 fallback |
| - arg: real value |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* tensor1 |
| - THTensor* tensor2 |
| ]] |
| [[ |
| name: addcdiv_ |
| cname: addcdiv |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: tensor1,tensor2 inplace fallback |
| - arg: real value |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* tensor1 |
| - THTensor* tensor2 |
| ]] |
| [[ |
| name: gesv |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* solution |
| output: True |
| - arg: THTensor* lu |
| output: True |
| - THTensor* self |
| - THTensor* A |
| ]] |
| [[ |
| name: gels |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - THTensor* self |
| - THTensor* A |
| ]] |
| [[ |
| name: trtrs |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - THTensor* self |
| - THTensor* A |
| - arg: bool upper |
| if_true: U |
| if_false: L |
| default: U |
| - arg: bool transpose |
| if_true: T |
| if_false: N |
| default: N |
| - arg: bool unitriangular |
| if_true: U |
| if_false: N |
| default: N |
| ]] |
| [[ |
| name: symeig |
| cname: syev |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - THTensor* self |
| - arg: bool eigenvectors |
| if_true: V |
| if_false: N |
| default: N |
| - arg: bool upper |
| if_true: U |
| if_false: L |
| default: U |
| ]] |
| [[ |
| name: eig |
| cname: geev |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - THTensor* self |
| - arg: bool eigenvectors |
| if_true: V |
| if_false: N |
| default: N |
| ]] |
| [[ |
| name: svd |
| cname: gesvd |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1,2 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - arg: THTensor* res3 |
| output: True |
| - THTensor* self |
| - arg: bool some |
| if_true: S |
| if_false: A |
| default: S |
| ]] |
| [[ |
| name: inverse |
| cname: getri |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: potrf |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - THTensor* self |
| - arg: bool upper |
| if_true: U |
| if_false: L |
| default: U |
| ]] |
| [[ |
| name: potrs |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THTensor* input2 |
| - arg: bool upper |
| if_true: U |
| if_false: L |
| default: U |
| ]] |
| [[ |
| name: potri |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - THTensor* self |
| - arg: bool upper |
| if_true: U |
| if_false: L |
| default: U |
| ]] |
| [[ |
| name: pstrf |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THIntegerTensor* res2 |
| output: True |
| - THTensor* self |
| - arg: bool upper |
| if_true: U |
| if_false: L |
| default: U |
| - arg: real tol |
| default: -1 |
| aten_custom_call: | |
| ${THTensor}_pstrf(res1_->tensor, res2_->tensor, self_->tensor, (upper) ? "U" : "L", tol_); |
| res2 -= 1; // LAPACK returns 1-indexed pivots |
| ]] |
| [[ |
| name: qr |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: geqrf |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* res1 |
| output: True |
| - arg: THTensor* res2 |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: orgqr |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THTensor* input2 |
| ]] |
| [[ |
| name: ormqr |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THTensor* input2 |
| - THTensor* input3 |
| - arg: bool left |
| if_true: L |
| if_false: R |
| default: L |
| - arg: bool transpose |
| if_true: T |
| if_false: N |
| default: N |
| ]] |
| [[ |
| name: btrifact |
| cname: btrifact |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THIntegerTensor* pivots |
| output: True |
| - CONSTANT NULL |
| - arg: bool pivot |
| kwarg_only: True |
| default: "true" |
| - THTensor* self |
| ]] |
| [[ |
| name: btrifact_with_info |
| cname: btrifact |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0,1,2 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THIntegerTensor* pivots |
| output: True |
| - arg: THIntegerTensor* info |
| output: True |
| - arg: bool pivot |
| kwarg_only: True |
| default: "true" |
| - THTensor* self |
| ]] |
| [[ |
| name: btrisolve |
| cname: btrisolve |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THTensor* LU_data |
| - THIntegerTensor* LU_pivots |
| ]] |
| [[ |
| name: randperm |
| backends: |
| - CPU |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - long n |
| ]] |
| [[ |
| name: random_ |
| backends: |
| - CPU |
| - CUDA |
| return: self |
| options: |
| - cname: random |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - cname: cappedRandom |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - int64_t to |
| - cname: clampedRandom |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - int64_t from |
| - int64_t to |
| ]] |
| [[ |
| name: multinomial |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THIndexTensor* result |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - THTensor* self |
| - long num_samples |
| - arg: bool replacement |
| default: "false" |
| ]] |
| [[ |
| name: uniform_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: uniform |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: double from |
| default: 0 |
| - arg: double to |
| default: 1 |
| ]] |
| [[ |
| name: normal |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| return: argument 0 |
| variants: |
| - function |
| options: |
| - cname: normal_means |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - THTensor* mean |
| - arg: double std |
| default: 1 |
| - cname: normal_stddevs |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: double mean |
| - THTensor* std |
| - cname: normal_means_stddevs |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - THTensor* mean |
| - THTensor* std |
| ]] |
| [[ |
| name: normal_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: normal |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: double mean |
| default: 0 |
| - arg: double std |
| default: 1 |
| ]] |
| [[ |
| name: cauchy_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: cauchy |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: double median |
| default: 0 |
| - arg: double sigma |
| default: 1 |
| ]] |
| [[ |
| name: logNormal_ |
| cname: logNormal |
| python_name: log_normal_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: double mean |
| default: 1 |
| - arg: double std |
| default: 2 |
| ]] |
| [[ |
| name: exponential_ |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| cname: exponential |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: double lambd |
| default: 1 |
| ]] |
| [[ |
| name: rand |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: THSize* size |
| long_args: True |
| ]] |
| [[ |
| name: randn |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - arg: THSize* size |
| long_args: True |
| ]] |
| [[ |
| name: geometric_ |
| backends: |
| - CPU |
| - CUDA |
| cname: geometric |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - double p |
| ]] |
| [[ |
| name: bernoulli |
| types: |
| - Float |
| - Double |
| return: argument 0 |
| variants: |
| - method |
| - function |
| cname: bernoulli_Tensor |
| arguments: |
| - arg: THTensor* output |
| output: True |
| resize: self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _standard_gamma |
| types: |
| - floating_point |
| backends: |
| - CPU |
| return: argument 0 |
| variants: |
| - method |
| - function |
| options: |
| - cname: standard_gamma |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _dirichlet_grad |
| types: |
| - floating_point |
| backends: |
| - CPU |
| return: argument 0 |
| variants: |
| - function |
| options: |
| - cname: dirichlet_grad |
| arguments: |
| - arg: THTensor* output |
| output: True |
| - THTensor* x |
| - THTensor* alpha |
| - THTensor* total |
| ]] |
| [[ |
| name: tensor |
| return: THTensor* |
| cpu_half: True |
| variants: [function] |
| options: |
| - cname: new |
| aten_sparse: True |
| arguments: [] |
| - cname: newWithSize |
| aten_sparse: True |
| arguments: |
| - THSize* size |
| - CONSTANT NULL |
| - cname: newWithSize |
| arguments: |
| - THSize* size |
| - arg: THStride* stride |
| - cname: newWithStorage |
| arguments: |
| - THStorage* storage |
| - int64_t storageOffset |
| - THSize* size |
| - arg: THStride* stride |
| default: NULL |
| ]] |
| [[ |
| name: sparse_coo_tensor |
| return: THTensor* |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| variants: [function] |
| options: |
| - cname: newWithTensor |
| arguments: |
| - THDenseIndexTensor* indices |
| - THDenseTensor* values |
| - cname: newWithTensorAndSize |
| arguments: |
| - THDenseIndexTensor* indices |
| - THDenseTensor* values |
| - THSize* size |
| ]] |
| |
| # In theory, this could be a part of the above declaration. But in |
| # practice this leads to all sorts of problems with ambiguous overloads. |
| # So we add it here with a separate name. |
| [[ |
| name: alias |
| return: THTensor* |
| cpu_half: True |
| variants: [function] |
| options: |
| - cname: newWithTensor |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: _copy_ignoring_overlaps_ |
| cname: copyIgnoringOverlaps |
| return: self |
| backends: |
| - CUDA |
| arguments: |
| - THTensor* self |
| - THTensor* src |
| ]] |
| |
| [[ |
| name: as_strided |
| variants: [method,function] |
| cpu_half: True |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - THSize* size |
| - THStride* stride |
| - arg: int64_t storage_offset |
| default: -1 |
| aten_custom_call: | |
| if (storage_offset == -1) { |
| storage_offset = self_->tensor->storageOffset; |
| } |
| ${THTensor}_setStorage(${state,}result_->tensor, self_->tensor->storage, storage_offset, size_, stride_); |
| result_->maybeScalar(size.size() == 0); |
| ]] |
| |
| [[ |
| name: as_strided_ |
| variants: [method,function] |
| cpu_half: True |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THSize* size |
| - THStride* stride |
| - arg: int64_t storage_offset |
| default: -1 |
| aten_custom_call: | |
| if (storage_offset == -1) { |
| storage_offset = self_->tensor->storageOffset; |
| } |
| ${THTensor}_setStorage(${state,}self_->tensor, self_->tensor->storage, storage_offset, size_, stride_); |
| self_->maybeScalar(size.size() == 0); |
| ]] |
| |
| [[ |
| name: sparse_raw_resize_ |
| variants: [method] |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THSize* size |
| - int64_t nDimI |
| - int64_t nDimV |
| aten_custom_call: | |
| /* |
| * Sets sizes, nDimI, and nDimV of a sparse tensor directly without any |
| * safety checks. If nDimI and/or nDimV are -1, recompute them from |
| * indices and values, respectively. |
| */ |
| if (nDimI == -1) { |
| nDimI = self._indices().size(0); |
| } |
| if (nDimV == -1) { |
| nDimV = self._values().dim() - 1; |
| } |
| ${THTensor}_rawResize(${state,}self_->tensor, nDimI, nDimV, (*size_).data); |
| self_->maybeScalar(size.size() == 0); |
| ]] |
| |
| [[ |
| name: _cat |
| cname: catArray |
| variants: [function] |
| return: self |
| arguments: |
| - arg: THTensor* self |
| output: True |
| - TensorList tensors |
| - arg: int64_t dim |
| wrap_dim: tensors |
| default: 0 |
| ]] |
| |
| [[ |
| name: reshape_ |
| cname: resize |
| cpu_half: True |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THSize* size |
| - arg: THStride* stride |
| ]] |
| |
| [[ |
| name: _sparse_mask |
| return: argument 0 |
| cname: sparseMask |
| aten_dense_sparse: True |
| arguments: |
| - arg: THSTensor* result |
| output: True |
| - THTensor* self |
| - THSTensor* mask |
| ]] |
| |
| [[ |
| name: to_dense |
| cname: toDense |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: THDenseTensor* |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: _dimI |
| cname: nDimensionI |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: int64_t |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: _dimV |
| cname: nDimensionV |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: int64_t |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: _nnz |
| cname: nnz |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: int64_t |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: coalesce |
| cname: newCoalesce |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: THTensor* |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: is_coalesced |
| cname: isCoalesced |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: bool |
| arguments: |
| - THTensor* self |
| ]] |
| |
| [[ |
| name: _indices |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: THDenseIndexTensor* |
| cname: newIndices |
| arguments: |
| - THTensor* self |
| aten_custom_call: | |
| if (self_->isScalar()) { |
| // Empty tensor |
| return self_->type().toScalarType(kLong).tensor({0}); |
| } |
| ]] |
| |
| [[ |
| name: _values |
| variants: |
| - method |
| backends: |
| - SparseCPU |
| - SparseCUDA |
| return: THDenseTensor* |
| cname: newValues |
| arguments: |
| - THTensor* self |
| ]] |
