| [[ |
| name: storageOffset |
| python_name: storage_offset |
| cpu_half: True |
| device_guard: False |
| return: long |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: nDimension |
| python_name: ndimension |
| cpu_half: True |
| device_guard: False |
| return: long |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: resize_ |
| return: self |
| cname: resize |
| cpu_half: True |
| arguments: |
| - THTensor* self |
| - arg: THSize* size |
| long_args: True |
| - CONSTANT NULL |
| ]] |
| [[ |
| name: set_ |
| cname: set |
| cpu_half: True |
| device_guard: 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, THLongStorageView({0}, THLongStorageViewKind::SIZE), NULL |
| - cname: setStorage |
| scalar_check: False |
| arguments: |
| - THTensor* self |
| - THStorage* source |
| - CONSTANT 0 |
| - CONSTANT __storage_size.get() |
| - CONSTANT NULL |
| - cname: setStorage |
| arguments: |
| - THTensor* self |
| - THStorage* source |
| - 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 |
| device_guard: False |
| return: bool |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: isSetTo |
| python_name: is_set_to |
| cpu_half: True |
| device_guard: 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: 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: th_clone |
| cname: newClone |
| return: THTensor* |
| variants: |
| - function |
| cpu_half: True |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: view |
| cname: newView |
| device_guard: False |
| return: THTensor* |
| arguments: |
| - THTensor* self |
| - arg: THSize* size |
| long_args: True |
| ]] |
| [[ |
| name: resizeAs_ |
| python_name: th_resize_as_ |
| cname: resizeAs |
| variants: |
| - function |
| 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_ |
| 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 |
| device_guard: False |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dimension |
| wrap_dim: self |
| - long size |
| - long step |
| ]] |
| [[ |
| name: _range |
| cname: range |
| variants: |
| - function |
| backends: |
| - CPU |
| - CUDA |
| return: argument 0 |
| 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 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| resize: index |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| - THIndexTensor* index |
| ]] |
| [[ |
| name: data_ptr |
| with_gil: True |
| device_guard: 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| variants: |
| - method |
| - function |
| backends: |
| - CPU |
| - CUDA |
| options: |
| - cname: logicalAndAll |
| return: real |
| arguments: |
| - THTensor* self |
| - cname: logicalAnd |
| 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: any |
| types: |
| - Byte |
| variants: |
| - method |
| - function |
| backends: |
| - CPU |
| - CUDA |
| options: |
| - cname: logicalAnyAll |
| return: real |
| arguments: |
| - THTensor* self |
| - cname: logicalAny |
| 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: getDevice |
| python_name: _th_get_device |
| device_guard: False |
| variants: |
| - function |
| backends: |
| - CUDA |
| return: long |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: _abs |
| cname: abs |
| types: |
| - floating_point |
| - Long |
| - Int |
| - Short |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - 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 |
| cname: log |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _log10 |
| cname: log10 |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _log1p |
| cname: log1p |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _log2 |
| cname: log2 |
| 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 |
| cname: exp |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _expm1 |
| cname: expm1 |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _cos |
| cname: cos |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _acos |
| cname: acos |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _cosh |
| cname: cosh |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _sin |
| cname: sin |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _asin |
| cname: asin |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _sinh |
| cname: sinh |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _tan |
| cname: tan |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _atan |
| cname: atan |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _th_tanh |
| cname: tanh |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _erf |
| cname: erf |
| types: |
| - floating_point |
| backends: |
| - 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 |
| cname: sqrt |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _rsqrt |
| cname: rsqrt |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _ceil |
| cname: ceil |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _floor |
| cname: floor |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _round |
| cname: round |
| types: |
| - floating_point |
| backends: |
| - CUDA |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| ]] |
| [[ |
| name: _trunc |
| cname: trunc |
| types: |
| - floating_point |
| backends: |
| - 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: 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: th_norm |
| cname: norm |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - function |
| options: |
| - cname: normall |
| return: accreal |
| arguments: |
| - THTensor* self |
| - arg: real p |
| default: AS_REAL(2) |
| ]] |
| [[ |
| name: norm |
| types: |
| - floating_point |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - method |
| - function |
| options: |
| - 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: th_pow |
| cname: pow |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: pow |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real exponent |
| ]] |
| [[ |
| name: pow |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: cpow |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: exponent fallback |
| - THTensor* exponent |
| ]] |
| [[ |
| name: pow |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: tpow |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - real base |
| - THTensor* self |
| ]] |
| [[ |
| name: pow_ |
| 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 |
| cname: linspace |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| variants: |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - real start |
| - real end |
| - arg: long steps |
| default: 100 |
| ]] |
| [[ |
| name: _logspace |
| cname: logspace |
| types: |
| - Float |
| - Double |
| backends: |
| - CPU |
| - CUDA |
| 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: th_zero_ |
| cname: zero |
| return: self |
| variants: |
| - function |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: _sumall |
| variants: |
| - method |
| - function |
| options: |
| - cname: sumall |
| return: accreal |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: _th_sum |
| variants: |
| - method |
| - function |
| options: |
| - 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: _prodall |
| variants: |
| - method |
| - function |
| options: |
| - cname: prodall |
| return: accreal |
| arguments: |
| - THTensor* self |
| ]] |
| [[ |
| name: _th_prod |
| variants: |
| - method |
| - function |
| options: |
| - 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 |
| cname: cumsum |
| variants: |
| - method |
| - function |
| return: argument 0 |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - arg: long dim |
| wrap_dim: self |
| ]] |
| [[ |
| name: _cumprod |
| cname: 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: th_add |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: cadd |
| 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: 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 |
| ]] |
| [[ |
| name: th_add_ |
| return: argument 0 |
| variants: [function] |
| options: |
| - cname: cadd |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - arg: real alpha |
| default: AS_REAL(1) |
| kwarg_only: True |
| - THTensor* 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 |
| ]] |
| [[ |
| name: th_sub |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: csub |
| 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 |
| 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 |
| ]] |
| [[ |
| name: th_sub_ |
| return: argument 0 |
| variants: [function] |
| options: |
| - cname: csub |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace 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 |
| ]] |
| [[ |
| name: th_mul |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: mul |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| - cname: cmul |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - arg: THTensor* other |
| ]] |
| [[ |
| name: th_mul_ |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: mul |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| - cname: cmul |
| arguments: |
| - THTensor* self |
| - arg: THTensor* self |
| broadcast: other inplace fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: th_div |
| variants: |
| - function |
| return: argument 0 |
| options: |
| - cname: div |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - THTensor* self |
| - real other |
| ]] |
| [[ |
| name: div |
| variants: |
| - method |
| - function |
| return: argument 0 |
| options: |
| - cname: cdiv |
| arguments: |
| - arg: THTensor* result |
| output: True |
| - arg: THTensor* self |
| broadcast: other fallback |
| - THTensor* other |
| ]] |
| [[ |
| name: th_div_ |
| variants: [function] |
| return: argument 0 |
| options: |
| - cname: div |
| arguments: |
| - THTensor* self |
| - THTensor* self |
| - real other |
| ]] |
| [[ |
| name: div_ |
| return: argument 0 |
| options: |
| - 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 |
| - arg: THTensor* tensor |
| ]] |
| [[ |
| 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: 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: th_addmm |
| cname: addmm |
| variants: |
| - 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 |
| ]] |
| [[ |
| name: th_addmm_ |
| variants: [function] |
| 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 |
| ]] |
| [[ |
| 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 |
| 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 |
| 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 |
| 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 |
| 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_single |
| cname: 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 |
| - CUDA |
| 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: 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: geometric_ |
| backends: |
| - CPU |
| - CUDA |
| cname: geometric |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - double p |
| ]] |
| [[ |
| name: _bernoulli_ |
| backends: |
| - CPU |
| - CUDA |
| cname: bernoulli |
| return: self |
| arguments: |
| - THTensor* self |
| - arg: THGenerator* generator |
| default: nullptr |
| kwarg_only: True |
| - double p |
| ]] |
| [[ |
| name: _th_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: _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: th_tensor |
| return: THTensor* |
| cpu_half: True |
| variants: [function] |
| options: |
| - cname: new |
| arguments: [] |
| - cname: newWithSize |
| arguments: |
| - THSize* size |
| - CONSTANT NULL |
| ]] |
| [[ |
| name: tensor |
| return: THTensor* |
| cpu_half: True |
| variants: [function] |
| options: |
| - cname: newWithSize |
| arguments: |
| - THSize* size |
| - arg: THStride* stride |
| - cname: newWithStorage |
| arguments: |
| - THStorage* storage |
| - int64_t storageOffset |
| - THSize* size |
| - arg: THStride* stride |
| default: NULL |
| ]] |
| |
| # 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 |
| aten_custom_call: | |
| ${THTensor}_setStorage(${state,}result_->tensor, self_->tensor->storage, storage_offset, size_, stride_); |
| result_->maybeScalar(size.size() == 0); |
| ]] |
| |
| [[ |
| name: as_strided_ |
| variants: [method] |
| cpu_half: True |
| return: argument 0 |
| arguments: |
| - THTensor* self |
| - THSize* size |
| - THStride* stride |
| - arg: int64_t storage_offset |
| aten_custom_call: | |
| ${THTensor}_setStorage(${state,}self_->tensor, self_->tensor->storage, storage_offset, size_, stride_); |
| 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 |
| default: 0 |
| ]] |
