pytorch/torch/csrc/generic/methods/TensorMath.cwrap

[[
  name: abs
  return: argument 0
  types:
    - floating_point
    - Long
    - Int
    - Short
  backends:
    - CPU
    - CUDA
  variants:
    - method
    - function
  arguments:
    - arg: THTensor* destination
      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: 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: 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
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - bool keepdim
    - cname: mean
      return: argument 0
      before_call: maybeThrowBackCompatKeepdimWarn("mean");
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - CONSTANT 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
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - arg: bool unbiased
          if_true: 0
          if_false: 1
          default: 0
        - bool keepdim
    - cname: var
      return: argument 0
      before_call: maybeThrowBackCompatKeepdimWarn("var");
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - arg: bool unbiased
          if_true: 0
          if_false: 1
          default: 0
        - CONSTANT 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
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - arg: bool unbiased
          if_true: 0
          if_false: 1
          default: 0
        - bool keepdim
    - cname: std
      return: argument 0
      before_call: maybeThrowBackCompatKeepdimWarn("std");
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - arg: bool unbiased
          if_true: 0
          if_false: 1
          default: 0
        - CONSTANT false
]]

[[
  name: norm
  types:
    - floating_point
  backends:
    - CPU
    - CUDA
  variants:
    - method
    - function
  options:
    - cname: normall
      return: accreal
      arguments:
        - THTensor* self
        - arg: real p
          default: AS_REAL(2)
    - cname: norm
      return: argument 0
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - real p
        - arg: int64_t dim
          wrap_dim: self
        - bool keepdim
    - cname: norm
      return: argument 0
      before_call: maybeThrowBackCompatKeepdimWarn("norm");
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - real p
        - arg: int64_t dim
          wrap_dim: self
        - CONSTANT false
]]

[[
  name: renorm
  types:
    - floating_point
  backends:
    - CPU
    - CUDA
  variants:
    - method
    - function
  options:
    - cname: renorm
      return: argument 0
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - real p
        - arg: int64_t dim
          wrap_dim: self
        - real maxnorm
]]

[[
  name: renorm_
  types:
    - floating_point
  backends:
    - CPU
    - CUDA
  options:
    - cname: renorm
      return: self
      arguments:
        - THTensor* self
        - THTensor* self
        - real p
        - arg: int64_t 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* destination
          output: True
        - THTensor* self
]]

[[
  name: reciprocal_
  types:
    - floating_point
  backends:
    - CPU
    - CUDA
  options:
    - cname: cinv
      return: self
      arguments:
        - THTensor* self
        - THTensor* self
]]

[[
  name: neg
  types:
    - floating_point
    - Long
    - Int
    - Short
  backends:
    - CPU
    - CUDA
  variants:
    - method
    - function
  options:
    - cname: neg
      return: argument 0
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
]]

[[
  name: neg_
  types:
    - floating_point
    - Long
    - Int
    - Short
  backends:
    - CPU
    - CUDA
  options:
    - cname: neg
      return: self
      arguments:
        - THTensor* self
        - THTensor* self
]]

[[
  name: atan2
  types:
    - Float
    - Double
  backends:
    - CPU
  backend_type_pairs: [[CPU,Float],[CPU,Double],[CUDA,Float]]

  variants:
    - method
    - function
  cname: atan2
  return: argument 0
  arguments:
    - arg: THTensor* destination
      output: True
    - arg: THTensor* self
      broadcast: other fallback
    - THTensor* other
]]

[[
  name: atan2_
  backend_type_pairs: [[CPU,Float],[CPU,Double],[CUDA,Float]]
  cname: atan2
  return: argument 0
  arguments:
    - THTensor* self
    - arg: THTensor* self
      broadcast: other fallback inplace
    - THTensor* other
]]



// These options look the same in stateful method - only the first one will
// be available. Still, they differ in torch.pow.
[[
  name: pow
  types:
    - floating_point
  backends:
    - CPU
    - CUDA
  variants:
    - method
    - function
  return: argument 0
  options:
    - cname: pow
      arguments:
        - arg: THTensor* destination
          output: True
        - THTensor* self
        - real exponent
    - cname: cpow
      arguments:
        - arg: THTensor* destination
          output: True
        - arg: THTensor* self
          broadcast: exponent fallback
        - THTensor* exponent
    - cname: tpow
      arguments:
        - arg: THTensor* destination
          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* destination
      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: int64_t 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: int64_t steps
      default: 100
]]

[[
  name: histc
  types:
    - Float
    - Double
  backends:
    - CPU
  variants:
    - method
    - function
  return: argument 0
  options:
    - arguments:
      - arg: THTensor* destination
        output: True
      - THTensor* self
      - CONSTANT 100
      - CONSTANT 0
      - CONSTANT 0
    - arguments:
      - arg: THTensor* destination
        output: True
      - THTensor* self
      - int64_t bins
      - CONSTANT 0
      - CONSTANT 0
    - arguments:
      - arg: THTensor* destination
        output: True
      - THTensor* self
      - int64_t bins
      - real min
      - CONSTANT 0
    - arguments:
      - arg: THTensor* destination
        output: True
      - THTensor* self
      - int64_t bins
      - real min
      - real max
]]

[[
  name: zero_
  cname: zero
  return: self
  arguments:
    - THTensor* self
]]

[[
  name: sum
  variants:
    - method
    - function
  options:
    - cname: sumall
      return: accreal
      arguments:
        - THTensor* self
    - cname: sum
      return: argument 0
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - bool keepdim
    - cname: sum
      return: argument 0
      before_call: maybeThrowBackCompatKeepdimWarn("sum");
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - CONSTANT false
]]

[[
  name: prod
  variants:
    - method
    - function
  options:
    - cname: prodall
      return: accreal
      arguments:
        - THTensor* self
    - cname: prod
      return: argument 0
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - bool keepdim
    - cname: prod
      return: argument 0
      before_call: maybeThrowBackCompatKeepdimWarn("prod");
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: int64_t dim
          wrap_dim: self
        - CONSTANT false
]]

[[
  name: cumsum
  variants:
    - method
    - function
  return: argument 0
  arguments:
    - arg: THTensor* result
      output: True
    - THTensor* self
    - arg: int64_t dim
      wrap_dim: self
]]

[[
  name: cumprod
  variants:
    - method
    - function
  return: argument 0
  arguments:
    - arg: THTensor* result
      output: True
    - THTensor* self
    - arg: int64_t 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
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - real value
    - cname: cadd
      aten_sparse: True
      arguments:
        - arg: THTensor* result
          output: True
        - arg: THTensor* self
          broadcast: other fallback
        - arg: real value
          default: AS_REAL(1)
        - THTensor* other
    - sparse: True
      cname: spcadd
      aten_dense_sparse: True
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: real value
          default: AS_REAL(1)
        - THSTensor* other
]]

[[
  name: add_
  return: argument 0
  options:
    - cname: add
      arguments:
        - THTensor* self
        - THTensor* self
        - real value
    - cname: cadd
      aten_sparse: True
      arguments:
        - THTensor* self
        - arg: THTensor* self
          broadcast: other inplace fallback
        - arg: real value
          default: AS_REAL(1)
        - THTensor* other
    - sparse: True
      cname: spcadd
      aten_dense_sparse: True
      arguments:
        - THTensor* self
        - THTensor* self
        - arg: real value
          default: AS_REAL(1)
        - THSTensor* other
]]


[[
  name: sub
  variants:
    - method
    - function
  return: argument 0
  options:
    - cname: sub
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - real value
    - cname: csub
      arguments:
        - arg: THTensor* result
          output: True
        - arg: THTensor* self
          broadcast: other fallback
        - arg: real value
          default: AS_REAL(1)
        - THTensor* other
]]

[[
  name: sub_
  return: argument 0
  options:
    - cname: sub
      arguments:
        - THTensor* self
        - THTensor* self
        - real value
    - cname: csub
      arguments:
        - THTensor* self
        - arg: THTensor* self
          broadcast: other inplace fallback
        - arg: real value
          default: AS_REAL(1)
        - THTensor* other
]]


[[
  name: mul
  variants:
    - method
    - function
  return: argument 0
  options:
    - cname: mul
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - real value
    - cname: cmul
      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 value
    - cname: cmul
      arguments:
        - THTensor* self
        - arg: THTensor* self
          broadcast: other inplace fallback
        - THTensor* other
]]


[[
  name: div
  variants:
    - method
    - function
  return: argument 0
  options:
    - cname: div
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - real value
    - cname: cdiv
      arguments:
        - arg: THTensor* result
          output: True
        - arg: THTensor* self
          broadcast: other fallback
        - THTensor* other
]]

[[
  name: div_
  return: argument 0
  options:
    - cname: div
      arguments:
        - THTensor* self
        - THTensor* self
        - real value
    - 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 value
    - 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 value
    - 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 value
    - 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 value
    - cname: cremainder
      arguments:
        - THTensor* self
        - arg: THTensor* self
          broadcast: other inplace fallback
        - THTensor* other
]]

[[
  name: clamp
  variants:
    - method
    - function
  return: argument 0
  options:
    - cname: clamp
      arguments:
      - arg: THTensor* destination
        output: True
      - THTensor* self
      - real min
      - real max
    - cname: cmaxValue
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: real min
          kwarg_only: True
    - cname: cminValue
      arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: real max
          kwarg_only: True
]]

[[
  name: clamp_
  cname: clamp
  return: self
  options:
    - cname: clamp
      arguments:
      - THTensor* self
      - THTensor* self
      - real min
      - real max
    - cname: cmaxValue
      arguments:
        - THTensor* self
        - THTensor* self
        - arg: real min
          kwarg_only: True
    - cname: cminValue
      arguments:
        - THTensor* self
        - THTensor* self
        - arg: real max
          kwarg_only: True
]]

[[
  name: dot
  backend_type_pairs: [[CUDA,floating_point], [CPU,all]]

  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* destination
      output: True
    - THTensor* self
    - arg: int64_t diagonal
      default: 0
]]

[[
  name: tril_
  cname: tril
  return: self
  arguments:
    - THTensor* self
    - THTensor* self
    - arg: int64_t diagonal
      default: 0
]]

[[
  name: triu
  variants:
    - method
    - function
  return: argument 0
  arguments:
    - arg: THTensor* destination
      output: True
    - THTensor* self
    - arg: int64_t diagonal
      default: 0
]]

[[
  name: triu_
  cname: triu
  return: self
  arguments:
    - THTensor* self
    - THTensor* self
    - arg: int64_t diagonal
      default: 0
]]

[[
  name: cross
  variants:
    - method
    - function
  return: argument 0
  arguments:
    - arg: THTensor* destination
      output: True
    - THTensor* self
    - THTensor* other
    - arg: int64_t dim
      default: -1
]]

[[
  name: eye
  backends:
    - CPU
    - CUDA
  variants:
    - function
  return: argument 0
  options:
    - arguments:
      - arg: THTensor* result
        output: True
      - int64_t n
      - argument 1
    - arguments:
      - arg: THTensor* result
        output: True
      - int64_t n
      - int64_t m
]]

[[
  name: diag
  variants:
    - method
    - function
  return: argument 0
  options:
    - arguments:
        - arg: THTensor* result
          output: True
        - THTensor* self
        - arg: int64_t diagonal
          default: 0
]]

[[
  name: addmm
  variants:
    - method
    - function
  return: argument 0
  options:
    - arguments:
      - arg: THTensor* result
        output: True
      - arg: real beta
        default: AS_REAL(1)
      - arg: THTensor* self
        broadcast: mat1,mat2 dims:mat1.dim0,mat2.dim1
      - arg: real alpha
        default: AS_REAL(1)
      - THTensor* mat1
      - THTensor* mat2
    - cname: spaddmm
      sparse: yes
      arguments:
        - arg: THTensor* result
          output: True
        - arg: real beta
          default: AS_REAL(1)
        - THTensor* self
        - arg: real alpha
          default: AS_REAL(1)
        - THSTensor* mat1
        - THTensor* mat2
]]

[[
  name: addmm_
  return: self
  options:
    - cname: addmm
      arguments:
      - THTensor* self
      - arg: real beta
        default: AS_REAL(1)
      - THTensor* self
      - arg: real alpha
        default: AS_REAL(1)
      - THTensor* mat1
      - THTensor* mat2
    - cname: spaddmm
      sparse: yes
      arguments:
        - arg: THTensor* self
        - arg: real beta
          default: AS_REAL(1)
        - THTensor* self
        - arg: real alpha
          default: AS_REAL(1)
        - THSTensor* mat1
        - THTensor* mat2
]]

[[
  name: addmv
  variants:
    - method
    - function
  return: argument 0
  arguments:
    - arg: THTensor* result
      output: True
    - arg: real beta
      default: AS_REAL(1)
    - arg: THTensor* self
      broadcast: mat,vec dims:mat.dim0
    - arg: real alpha
      default: AS_REAL(1)
    - THTensor* mat
    - THTensor* vec
]]

[[
  name: addmv_
  cname: addmv
  return: self
  arguments:
    - THTensor* self
    - arg: real beta
      default: AS_REAL(1)
    - THTensor* self
    - arg: real alpha
      default: AS_REAL(1)
    - THTensor* mat
    - THTensor* vec
]]

[[
  name: addr
  variants:
    - method
    - function
  return: argument 0
  arguments:
    - arg: THTensor* result
      output: True
    - arg: real beta
      default: AS_REAL(1)
    - arg: THTensor* self
      broadcast: vec1,vec2 dims:vec1.dim0,vec2.dim0
    - arg: real alpha
      default: AS_REAL(1)
    - THTensor* vec1
    - THTensor* vec2
]]

[[
  name: addr_
  cname: addr
  return: self
  arguments:
    - THTensor* self
    - arg: real beta
      default: AS_REAL(1)
    - THTensor* self
    - arg: real alpha
      default: AS_REAL(1)
    - THTensor* vec1
    - THTensor* vec2
]]

[[
  name: ger
  cname: addr
  variants:
    - method
    - function
  return: argument 0
  before_call: |
    int64_t s1 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0);
    int64_t 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] ]
    - 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: |
    int64_t 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: |
        int64_t s1 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0);
        int64_t 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
    - cname: spaddmm
      sparse: True
      arguments:
        - arg: THTensor* result
          output: True
        - CONSTANT AS_REAL(0)
        - argument 0
        - CONSTANT AS_REAL(1)
        - THSTensor* self
        - THTensor* mat2
]]

[[
  name: bmm
  cname: baddbmm
  variants:
    - method
    - function
  return: argument 0
  before_call: |
    int64_t s1 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 0);
    int64_t s2 = THTensor_(size)(LIBRARY_STATE ((THPTensor*)$arg4)->cdata, 1);
    int64_t 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)
    - arg: THTensor* self
      broadcast: batch1,batch2 dims:batch1.dim1,batch2.dim2
    - arg: real alpha
      default: AS_REAL(1)
    - THTensor* batch1
    - THTensor* batch2
]]

[[
  name: addbmm_
  cname: addbmm
  return: self
  arguments:
    - THTensor* self
    - arg: real beta
      default: AS_REAL(1)
    - THTensor* self
    - arg: real alpha
      default: AS_REAL(1)
    - 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)
    - arg: THTensor* self
      broadcast: batch1,batch2 dims:batch1.dim0,batch1.dim1,batch2.dim2
    - arg: real alpha
      default: AS_REAL(1)
    - THTensor* batch1
    - THTensor* batch2
]]

[[
  name: baddbmm_
  cname: baddbmm
  return: argument 0
  arguments:
    - THTensor* self
    - arg: real beta
      default: AS_REAL(1)
    - THTensor* self
    - arg: real alpha
      default: AS_REAL(1)
    - 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)
    - 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)
        - THTensor* tensor1
        - THTensor* tensor2
    - cname: spaddcmul
      defined_if: "!IS_DISTRIBUTED"
      return: argument 0
      arguments:
        - THTensor* self
        - THTensor* self
        - arg: real value
          default: AS_REAL(1)
        - 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)
    - 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)
    - THTensor* tensor1
    - THTensor* tensor2
]]

#if defined(TH_REAL_IS_FLOAT) || defined(TH_REAL_IS_DOUBLE) || CUDA_FLOAT || CUDA_DOUBLE
// We need to pass pointers to chars to tensor lapack functions...
static const char __U = 'U';
static const char __L = 'L';
static const char __N = 'N';
static const char __V = 'V';
static const char __A = 'A';
static const char __S = 'S';
#if !IS_CUDA
static const char __T = 'T';
static const char __R = 'R';
#endif
static const char *U = &__U;
static const char *L = &__L;
static const char *N = &__N;
static const char *V = &__V;
static const char *A = &__A;
static const char *S = &__S;
#if !IS_CUDA
static const char *T = &__T;
static const char *R = &__R;
#endif
#endif

[[
  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
  after_call:
    THIntTensor_sub(((THPIntTensor*)$arg1)->cdata, ((THPIntTensor*)$arg1)->cdata, 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
]]

[[
  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,1
  arguments:
    - arg: THTensor* result
      output: True
    - THTensor* self
    - THTensor* input2
]]

[[
  name: ormqr
  types:
    - Float
    - Double
  backends:
    - CPU
  variants:
    - method
    - function
  return: argument 0,1
  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
    - arg: THIntegerTensor* info
      kwarg_only: True
      default: NULL
    - 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
]]