//===-------------------------------------------------------*- tablegen -*-===//
//
// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
// Operation summaries and descriptions were systematically derived from public
// API docstrings and are licensed accordingly:
//   https://github.com/pytorch/pytorch/blob/master/LICENSE
//===----------------------------------------------------------------------===//
// This file is automatically generated.  Please do not edit.
// Generated via:
//   python -m npcomp.torch.opdefs.generate_ods
//===----------------------------------------------------------------------===//

def ATen_AbsOp: ATen_ImmutableTensorOp<"abs", [NoSideEffect]> {
  let summary = "abs(input, *, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the absolute value of each element in :attr:`input`.

    .. math::
        \text{out}_{i} = |\text{input}_{i}|

    Args:
        input (Tensor): the input tensor.

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.abs(torch.tensor([-1, -2, 3]))
        tensor([ 1,  2,  3])
  }];
}

def ATen_AbsInplaceOp: ATen_RefTensorOp<"abs.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_AcosOp: ATen_ImmutableTensorOp<"acos", [NoSideEffect]> {
  let summary = "acos(input, *, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the inverse cosine of each element in :attr:`input`.

    .. math::
        \text{out}_{i} = \cos^{-1}(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.3348, -0.5889,  0.2005, -0.1584])
        >>> torch.acos(a)
        tensor([ 1.2294,  2.2004,  1.3690,  1.7298])
  }];
}

def ATen_AcosInplaceOp: ATen_RefTensorOp<"acos.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_AngleOp: ATen_ImmutableTensorOp<"angle", [NoSideEffect]> {
  let summary = "angle(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the element-wise angle (in radians) of the given :attr:`input` tensor.

    .. math::
        \text{out}_{i} = angle(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.angle(torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j]))*180/3.14159
        tensor([ 135.,  135,  -45])
  }];
}

def ATen_AngleInplaceOp: ATen_RefTensorOp<"angle.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_AsinOp: ATen_ImmutableTensorOp<"asin", [NoSideEffect]> {
  let summary = "asin(input, *, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the arcsine  of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \sin^{-1}(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.5962,  1.4985, -0.4396,  1.4525])
        >>> torch.asin(a)
        tensor([-0.6387,     nan, -0.4552,     nan])
  }];
}

def ATen_AsinInplaceOp: ATen_RefTensorOp<"asin.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_AtanOp: ATen_ImmutableTensorOp<"atan", [NoSideEffect]> {
  let summary = "atan(input, *, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the arctangent  of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \tan^{-1}(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.2341,  0.2539, -0.6256, -0.6448])
        >>> torch.atan(a)
        tensor([ 0.2299,  0.2487, -0.5591, -0.5727])
  }];
}

def ATen_AtanInplaceOp: ATen_RefTensorOp<"atan.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_CeilOp: ATen_ImmutableTensorOp<"ceil", [NoSideEffect]> {
  let summary = "ceil(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the ceil of the elements of :attr:`input`,
    the smallest integer greater than or equal to each element.

    .. math::
        \text{out}_{i} = \left\lceil \text{input}_{i} \right\rceil = \left\lfloor \text{input}_{i} \right\rfloor + 1

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.6341, -1.4208, -1.0900,  0.5826])
        >>> torch.ceil(a)
        tensor([-0., -1., -1.,  1.])
  }];
}

def ATen_CeilInplaceOp: ATen_RefTensorOp<"ceil.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ConjOp: ATen_ImmutableTensorOp<"conj", [NoSideEffect]> {
  let summary = "conj(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the element-wise conjugate of the given :attr:`input` tensor.

    .. math::
        \text{out}_{i} = conj(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.conj(torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j]))
        tensor([-1 - 1j, -2 - 2j, 3 + 3j])
  }];
}

def ATen_ConjInplaceOp: ATen_RefTensorOp<"conj.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_CosOp: ATen_ImmutableTensorOp<"cos", [NoSideEffect]> {
  let summary = "cos(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the cosine  of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \cos(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 1.4309,  1.2706, -0.8562,  0.9796])
        >>> torch.cos(a)
        tensor([ 0.1395,  0.2957,  0.6553,  0.5574])
  }];
}

def ATen_CosInplaceOp: ATen_RefTensorOp<"cos.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_CoshOp: ATen_ImmutableTensorOp<"cosh", [NoSideEffect]> {
  let summary = "cosh(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the hyperbolic cosine  of the elements of
    :attr:`input`.

    .. math::
        \text{out}_{i} = \cosh(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.1632,  1.1835, -0.6979, -0.7325])
        >>> torch.cosh(a)
        tensor([ 1.0133,  1.7860,  1.2536,  1.2805])
  }];
}

def ATen_CoshInplaceOp: ATen_RefTensorOp<"cosh.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_DigammaOp: ATen_ImmutableTensorOp<"digamma", [NoSideEffect]> {
  let summary = "digamma(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the logarithmic derivative of the gamma function on `input`.

    .. math::
        \psi(x) = \frac{d}{dx} \ln\left(\Gamma\left(x\right)\right) = \frac{\Gamma'(x)}{\Gamma(x)}

    Args:
        input (Tensor): the tensor to compute the digamma function on

    Example::

        >>> a = torch.tensor([1, 0.5])
        >>> torch.digamma(a)
        tensor([-0.5772, -1.9635])
  }];
}

def ATen_DigammaInplaceOp: ATen_RefTensorOp<"digamma.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ErfOp: ATen_ImmutableTensorOp<"erf", [NoSideEffect]> {
  let summary = "erf(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the error function of each element. The error function is defined as follows:

    .. math::
        \mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.erf(torch.tensor([0, -1., 10.]))
        tensor([ 0.0000, -0.8427,  1.0000])
  }];
}

def ATen_ErfInplaceOp: ATen_RefTensorOp<"erf.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ErfcOp: ATen_ImmutableTensorOp<"erfc", [NoSideEffect]> {
  let summary = "erfc(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the complementary error function of each element of :attr:`input`.
    The complementary error function is defined as follows:

    .. math::
        \mathrm{erfc}(x) = 1 - \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.erfc(torch.tensor([0, -1., 10.]))
        tensor([ 1.0000, 1.8427,  0.0000])
  }];
}

def ATen_ErfcInplaceOp: ATen_RefTensorOp<"erfc.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ErfinvOp: ATen_ImmutableTensorOp<"erfinv", [NoSideEffect]> {
  let summary = "erfinv(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the inverse error function of each element of :attr:`input`.
    The inverse error function is defined in the range :math:`(-1, 1)` as:

    .. math::
        \mathrm{erfinv}(\mathrm{erf}(x)) = x

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.erfinv(torch.tensor([0, 0.5, -1.]))
        tensor([ 0.0000,  0.4769,    -inf])
  }];
}

def ATen_ErfinvInplaceOp: ATen_RefTensorOp<"erfinv.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ExpOp: ATen_ImmutableTensorOp<"exp", [NoSideEffect]> {
  let summary = "exp(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the exponential of the elements
    of the input tensor :attr:`input`.

    .. math::
        y_{i} = e^{x_{i}}

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.exp(torch.tensor([0, math.log(2.)]))
        tensor([ 1.,  2.])
  }];
}

def ATen_ExpInplaceOp: ATen_RefTensorOp<"exp.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_Expm1Op: ATen_ImmutableTensorOp<"expm1", [NoSideEffect]> {
  let summary = "expm1(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the exponential of the elements minus 1
    of :attr:`input`.

    .. math::
        y_{i} = e^{x_{i}} - 1

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.expm1(torch.tensor([0, math.log(2.)]))
        tensor([ 0.,  1.])
  }];
}

def ATen_Expm1InplaceOp: ATen_RefTensorOp<"expm1.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_FloorOp: ATen_ImmutableTensorOp<"floor", [NoSideEffect]> {
  let summary = "floor(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the floor of the elements of :attr:`input`,
    the largest integer less than or equal to each element.

    .. math::
        \text{out}_{i} = \left\lfloor \text{input}_{i} \right\rfloor

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.8166,  1.5308, -0.2530, -0.2091])
        >>> torch.floor(a)
        tensor([-1.,  1., -1., -1.])
  }];
}

def ATen_FloorInplaceOp: ATen_RefTensorOp<"floor.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_FracOp: ATen_ImmutableTensorOp<"frac", [NoSideEffect]> {
  let summary = "frac(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the fractional portion of each element in :attr:`input`.

    .. math::
        \text{out}_{i} = \text{input}_{i} - \left\lfloor |\text{input}_{i}| \right\rfloor * \operatorname{sgn}(\text{input}_{i})

    Example::

        >>> torch.frac(torch.tensor([1, 2.5, -3.2]))
        tensor([ 0.0000,  0.5000, -0.2000])
  }];
}

def ATen_FracInplaceOp: ATen_RefTensorOp<"frac.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_LgammaOp: ATen_ImmutableTensorOp<"lgamma", [NoSideEffect]> {
  let summary = "lgamma(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the logarithm of the gamma function on :attr:`input`.

    .. math::
        \text{out}_{i} = \log \Gamma(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.arange(0.5, 2, 0.5)
        >>> torch.lgamma(a)
        tensor([ 0.5724,  0.0000, -0.1208])
  }];
}

def ATen_LgammaInplaceOp: ATen_RefTensorOp<"lgamma.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_LogOp: ATen_ImmutableTensorOp<"log", [NoSideEffect]> {
  let summary = "log(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the natural logarithm of the elements
    of :attr:`input`.

    .. math::
        y_{i} = \log_{e} (x_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(5)
        >>> a
        tensor([-0.7168, -0.5471, -0.8933, -1.4428, -0.1190])
        >>> torch.log(a)
        tensor([ nan,  nan,  nan,  nan,  nan])
  }];
}

def ATen_LogInplaceOp: ATen_RefTensorOp<"log.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_Log10Op: ATen_ImmutableTensorOp<"log10", [NoSideEffect]> {
  let summary = "log10(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the logarithm to the base 10 of the elements
    of :attr:`input`.

    .. math::
        y_{i} = \log_{10} (x_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.rand(5)
        >>> a
        tensor([ 0.5224,  0.9354,  0.7257,  0.1301,  0.2251])


        >>> torch.log10(a)
        tensor([-0.2820, -0.0290, -0.1392, -0.8857, -0.6476])
  }];
}

def ATen_Log10InplaceOp: ATen_RefTensorOp<"log10.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_Log1pOp: ATen_ImmutableTensorOp<"log1p", [NoSideEffect]> {
  let summary = "log1p(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the natural logarithm of (1 + :attr:`input`).

    .. math::
        y_i = \log_{e} (x_i + 1)

    .. note:: This function is more accurate than :func:`torch.log` for small
              values of :attr:`input`

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(5)
        >>> a
        tensor([-1.0090, -0.9923,  1.0249, -0.5372,  0.2492])
        >>> torch.log1p(a)
        tensor([    nan, -4.8653,  0.7055, -0.7705,  0.2225])
  }];
}

def ATen_Log1pInplaceOp: ATen_RefTensorOp<"log1p.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_Log2Op: ATen_ImmutableTensorOp<"log2", [NoSideEffect]> {
  let summary = "log2(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the logarithm to the base 2 of the elements
    of :attr:`input`.

    .. math::
        y_{i} = \log_{2} (x_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.rand(5)
        >>> a
        tensor([ 0.8419,  0.8003,  0.9971,  0.5287,  0.0490])


        >>> torch.log2(a)
        tensor([-0.2483, -0.3213, -0.0042, -0.9196, -4.3504])
  }];
}

def ATen_Log2InplaceOp: ATen_RefTensorOp<"log2.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_NegOp: ATen_ImmutableTensorOp<"neg", [NoSideEffect]> {
  let summary = "neg(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the negative of the elements of :attr:`input`.

    .. math::
        \text{out} = -1 \times \text{input}

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(5)
        >>> a
        tensor([ 0.0090, -0.2262, -0.0682, -0.2866,  0.3940])
        >>> torch.neg(a)
        tensor([-0.0090,  0.2262,  0.0682,  0.2866, -0.3940])
  }];
}

def ATen_NegInplaceOp: ATen_RefTensorOp<"neg.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ReciprocalOp: ATen_ImmutableTensorOp<"reciprocal", [NoSideEffect]> {
  let summary = "reciprocal(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the reciprocal of the elements of :attr:`input`

    .. math::
        \text{out}_{i} = \frac{1}{\text{input}_{i}}

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.4595, -2.1219, -1.4314,  0.7298])
        >>> torch.reciprocal(a)
        tensor([-2.1763, -0.4713, -0.6986,  1.3702])
  }];
}

def ATen_ReciprocalInplaceOp: ATen_RefTensorOp<"reciprocal.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_RoundOp: ATen_ImmutableTensorOp<"round", [NoSideEffect]> {
  let summary = "round(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with each of the elements of :attr:`input` rounded
    to the closest integer.

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.9920,  0.6077,  0.9734, -1.0362])
        >>> torch.round(a)
        tensor([ 1.,  1.,  1., -1.])
  }];
}

def ATen_RoundInplaceOp: ATen_RefTensorOp<"round.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_RsqrtOp: ATen_ImmutableTensorOp<"rsqrt", [NoSideEffect]> {
  let summary = "rsqrt(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the reciprocal of the square-root of each of
    the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \frac{1}{\sqrt{\text{input}_{i}}}

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.0370,  0.2970,  1.5420, -0.9105])
        >>> torch.rsqrt(a)
        tensor([    nan,  1.8351,  0.8053,     nan])
  }];
}

def ATen_RsqrtInplaceOp: ATen_RefTensorOp<"rsqrt.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_SigmoidOp: ATen_ImmutableTensorOp<"sigmoid", [NoSideEffect]> {
  let summary = "sigmoid(input, *, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the sigmoid of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \frac{1}{1 + e^{-\text{input}_{i}}}

    Args:
        input (Tensor): the input tensor.

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.9213,  1.0887, -0.8858, -1.7683])
        >>> torch.sigmoid(a)
        tensor([ 0.7153,  0.7481,  0.2920,  0.1458])
  }];
}

def ATen_SigmoidInplaceOp: ATen_RefTensorOp<"sigmoid.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_SignOp: ATen_ImmutableTensorOp<"sign", [NoSideEffect]> {
  let summary = "sign(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the signs of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \operatorname{sgn}(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.tensor([0.7, -1.2, 0., 2.3])
        >>> a
        tensor([ 0.7000, -1.2000,  0.0000,  2.3000])
        >>> torch.sign(a)
        tensor([ 1., -1.,  0.,  1.])
  }];
}

def ATen_SignInplaceOp: ATen_RefTensorOp<"sign.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_SinOp: ATen_ImmutableTensorOp<"sin", [NoSideEffect]> {
  let summary = "sin(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the sine of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \sin(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.5461,  0.1347, -2.7266, -0.2746])
        >>> torch.sin(a)
        tensor([-0.5194,  0.1343, -0.4032, -0.2711])
  }];
}

def ATen_SinInplaceOp: ATen_RefTensorOp<"sin.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_SinhOp: ATen_ImmutableTensorOp<"sinh", [NoSideEffect]> {
  let summary = "sinh(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the hyperbolic sine of the elements of
    :attr:`input`.

    .. math::
        \text{out}_{i} = \sinh(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.5380, -0.8632, -0.1265,  0.9399])
        >>> torch.sinh(a)
        tensor([ 0.5644, -0.9744, -0.1268,  1.0845])
  }];
}

def ATen_SinhInplaceOp: ATen_RefTensorOp<"sinh.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_SqrtOp: ATen_ImmutableTensorOp<"sqrt", [NoSideEffect]> {
  let summary = "sqrt(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the square-root of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \sqrt{\text{input}_{i}}

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-2.0755,  1.0226,  0.0831,  0.4806])
        >>> torch.sqrt(a)
        tensor([    nan,  1.0112,  0.2883,  0.6933])
  }];
}

def ATen_SqrtInplaceOp: ATen_RefTensorOp<"sqrt.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_TanOp: ATen_ImmutableTensorOp<"tan", [NoSideEffect]> {
  let summary = "tan(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the tangent of the elements of :attr:`input`.

    .. math::
        \text{out}_{i} = \tan(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-1.2027, -1.7687,  0.4412, -1.3856])
        >>> torch.tan(a)
        tensor([-2.5930,  4.9859,  0.4722, -5.3366])
  }];
}

def ATen_TanInplaceOp: ATen_RefTensorOp<"tan.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_TanhOp: ATen_ImmutableTensorOp<"tanh", [NoSideEffect]> {
  let summary = "tanh(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the hyperbolic tangent of the elements
    of :attr:`input`.

    .. math::
        \text{out}_{i} = \tanh(\text{input}_{i})

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.8986, -0.7279,  1.1745,  0.2611])
        >>> torch.tanh(a)
        tensor([ 0.7156, -0.6218,  0.8257,  0.2553])
  }];
}

def ATen_TanhInplaceOp: ATen_RefTensorOp<"tanh.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_TruncOp: ATen_ImmutableTensorOp<"trunc", [NoSideEffect]> {
  let summary = "trunc(input, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the truncated integer values of
    the elements of :attr:`input`.

    Args:
        input (Tensor): the input tensor.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 3.4742,  0.5466, -0.8008, -0.9079])
        >>> torch.trunc(a)
        tensor([ 3.,  0., -0., -0.])
  }];
}

def ATen_TruncInplaceOp: ATen_RefTensorOp<"trunc.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_ReluOp: ATen_ImmutableTensorOp<"relu", [NoSideEffect]> {
  let summary = "";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
}

def ATen_AddOp: ATen_ImmutableTensorOp<"add", [NoSideEffect]> {
  let summary = "add(input, other, out=None)";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyScalar:$alpha
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Adds the scalar :attr:`other` to each element of the input :attr:`input`
    and returns a new resulting tensor.

    .. math::
        \text{out} = \text{input} + \text{other}

    If :attr:`input` is of type FloatTensor or DoubleTensor, :attr:`other` must be
    a real number, otherwise it should be an integer.

    Args:
        input (Tensor): the input tensor.
        value (Number): the number to be added to each element of :attr:`input`

    Keyword arguments:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.0202,  1.0985,  1.3506, -0.6056])
        >>> torch.add(a, 20)
        tensor([ 20.0202,  21.0985,  21.3506,  19.3944])

    .. function:: add(input, other, *, alpha=1, out=None)

    Each element of the tensor :attr:`other` is multiplied by the scalar
    :attr:`alpha` and added to each element of the tensor :attr:`input`.
    The resulting tensor is returned.

    The shapes of :attr:`input` and :attr:`other` must be
    :ref:`broadcastable <broadcasting-semantics>`.

    .. math::
        \text{out} = \text{input} + \text{alpha} \times \text{other}

    If :attr:`other` is of type FloatTensor or DoubleTensor, :attr:`alpha` must be
    a real number, otherwise it should be an integer.

    Args:
        input (Tensor): the first input tensor
        other (Tensor): the second input tensor
        alpha (Number): the scalar multiplier for :attr:`other`

    Keyword arguments:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([-0.9732, -0.3497,  0.6245,  0.4022])
        >>> b = torch.randn(4, 1)
        >>> b
        tensor([[ 0.3743],
                [-1.7724],
                [-0.5811],
                [-0.8017]])
        >>> torch.add(a, b, alpha=10)
        tensor([[  2.7695,   3.3930,   4.3672,   4.1450],
                [-18.6971, -18.0736, -17.0994, -17.3216],
                [ -6.7845,  -6.1610,  -5.1868,  -5.4090],
                [ -8.9902,  -8.3667,  -7.3925,  -7.6147]])
  }];
}

def ATen_AddInplaceOp: ATen_RefTensorOp<"add.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyScalar:$alpha,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_Atan2Op: ATen_ImmutableTensorOp<"atan2", [NoSideEffect]> {
  let summary = "atan2(input, other, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Element-wise arctangent of :math:`\text{input}_{i} / \text{other}_{i}`
    with consideration of the quadrant. Returns a new tensor with the signed angles
    in radians between vector :math:`(\text{other}_{i}, \text{input}_{i})`
    and vector :math:`(1, 0)`. (Note that :math:`\text{other}_{i}`, the second
    parameter, is the x-coordinate, while :math:`\text{input}_{i}`, the first
    parameter, is the y-coordinate.)

    The shapes of ``input`` and ``other`` must be
    :ref:`broadcastable <broadcasting-semantics>`.

    Args:
        input (Tensor): the first input tensor
        other (Tensor): the second input tensor
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4)
        >>> a
        tensor([ 0.9041,  0.0196, -0.3108, -2.4423])
        >>> torch.atan2(a, torch.randn(4))
        tensor([ 0.9833,  0.0811, -1.9743, -1.4151])
  }];
}

def ATen_Atan2InplaceOp: ATen_RefTensorOp<"atan2.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_DivOp: ATen_ImmutableTensorOp<"div", [NoSideEffect]> {
  let summary = "div(input, other, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Divides each element of the input ``input`` with the scalar ``other`` and
    returns a new resulting tensor.

    .. warning::
        Integer division using div is no longer supported, and in a future release
        div will perform true division as in Python 3. Use :func:`torch.true_divide`
        or :func:`torch.floor_divide` (// in Python), instead.

    .. math::
        \text{out}_i = \frac{\text{input}_i}{\text{other}}

    If the :class:`torch.dtype` of ``input`` and ``other`` differ, the
    :class:`torch.dtype` of the result tensor is determined following rules
    described in the type promotion :ref:`documentation <type-promotion-doc>`. If
    ``out`` is specified, the result must be :ref:`castable <type-promotion-doc>`
    to the :class:`torch.dtype` of the specified output tensor. Integral division
    by zero leads to undefined behavior.

    Args:
        input (Tensor): the input tensor.
        other (Number): the number to be divided to each element of ``input``

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(5)
        >>> a
        tensor([ 0.3810,  1.2774, -0.2972, -0.3719,  0.4637])
        >>> torch.div(a, 0.5)
        tensor([ 0.7620,  2.5548, -0.5944, -0.7439,  0.9275])

    .. function:: div(input, other, out=None) -> Tensor

    Each element of the tensor ``input`` is divided by each element of the tensor
    ``other``. The resulting tensor is returned.

    .. math::
        \text{out}_i = \frac{\text{input}_i}{\text{other}_i}

    The shapes of ``input`` and ``other`` must be :ref:`broadcastable
    <broadcasting-semantics>`. If the :class:`torch.dtype` of ``input`` and
    ``other`` differ, the :class:`torch.dtype` of the result tensor is determined
    following rules described in the type promotion :ref:`documentation
    <type-promotion-doc>`. If ``out`` is specified, the result must be
    :ref:`castable <type-promotion-doc>` to the :class:`torch.dtype` of the
    specified output tensor. Integral division by zero leads to undefined behavior.

    Args:
        input (Tensor): the numerator tensor
        other (Tensor): the denominator tensor

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4, 4)
        >>> a
        tensor([[-0.3711, -1.9353, -0.4605, -0.2917],
                [ 0.1815, -1.0111,  0.9805, -1.5923],
                [ 0.1062,  1.4581,  0.7759, -1.2344],
                [-0.1830, -0.0313,  1.1908, -1.4757]])
        >>> b = torch.randn(4)
        >>> b
        tensor([ 0.8032,  0.2930, -0.8113, -0.2308])
        >>> torch.div(a, b)
        tensor([[-0.4620, -6.6051,  0.5676,  1.2637],
                [ 0.2260, -3.4507, -1.2086,  6.8988],
                [ 0.1322,  4.9764, -0.9564,  5.3480],
                [-0.2278, -0.1068, -1.4678,  6.3936]])
  }];
}

def ATen_DivInplaceOp: ATen_RefTensorOp<"div.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_FloorDivideOp: ATen_ImmutableTensorOp<"floor_divide", [NoSideEffect]> {
  let summary = "floor_divide(input, other, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Return the division of the inputs rounded down to the nearest integer. See :func:`torch.div`
    for type promotion and broadcasting rules.

    .. math::
        \text{{out}}_i = \left\lfloor \frac{{\text{{input}}_i}}{{\text{{other}}_i}} \right\rfloor


    Args:
        input (Tensor): the numerator tensor
        other (Tensor or Scalar): the denominator

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.tensor([4.0, 3.0])
        >>> b = torch.tensor([2.0, 2.0])
        >>> torch.floor_divide(a, b)
        tensor([2.0, 1.0])
        >>> torch.floor_divide(a, 1.4)
        tensor([2.0, 2.0])
  }];
}

def ATen_FloorDivideInplaceOp: ATen_RefTensorOp<"floor_divide.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_MulOp: ATen_ImmutableTensorOp<"mul", [NoSideEffect]> {
  let summary = "mul(input, other, out=None)";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Multiplies each element of the input :attr:`input` with the scalar
    :attr:`other` and returns a new resulting tensor.

    .. math::
        \text{out}_i = \text{other} \times \text{input}_i

    If :attr:`input` is of type `FloatTensor` or `DoubleTensor`, :attr:`other`
    should be a real number, otherwise it should be an integer

    Args:
        {input}
        value (Number): the number to be multiplied to each element of :attr:`input`
        {out}

    Example::

        >>> a = torch.randn(3)
        >>> a
        tensor([ 0.2015, -0.4255,  2.6087])
        >>> torch.mul(a, 100)
        tensor([  20.1494,  -42.5491,  260.8663])

    .. function:: mul(input, other, out=None)

    Each element of the tensor :attr:`input` is multiplied by the corresponding
    element of the Tensor :attr:`other`. The resulting tensor is returned.

    The shapes of :attr:`input` and :attr:`other` must be
    :ref:`broadcastable <broadcasting-semantics>`.

    .. math::
        \text{out}_i = \text{input}_i \times \text{other}_i

    Args:
        input (Tensor): the first multiplicand tensor
        other (Tensor): the second multiplicand tensor
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4, 1)
        >>> a
        tensor([[ 1.1207],
                [-0.3137],
                [ 0.0700],
                [ 0.8378]])
        >>> b = torch.randn(1, 4)
        >>> b
        tensor([[ 0.5146,  0.1216, -0.5244,  2.2382]])
        >>> torch.mul(a, b)
        tensor([[ 0.5767,  0.1363, -0.5877,  2.5083],
                [-0.1614, -0.0382,  0.1645, -0.7021],
                [ 0.0360,  0.0085, -0.0367,  0.1567],
                [ 0.4312,  0.1019, -0.4394,  1.8753]])
  }];
}

def ATen_MulInplaceOp: ATen_RefTensorOp<"mul.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_RemainderOp: ATen_ImmutableTensorOp<"remainder", [NoSideEffect]> {
  let summary = "remainder(input, other, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the element-wise remainder of division.

    The dividend and divisor may contain both for integer and floating point
    numbers. The remainder has the same sign as the divisor :attr:`other`.

    When :attr:`other` is a tensor, the shapes of :attr:`input` and
    :attr:`other` must be :ref:`broadcastable <broadcasting-semantics>`.

    Args:
        input (Tensor): the dividend
        other (Tensor or float): the divisor that may be either a number or a
                                   Tensor of the same shape as the dividend
        out (Tensor, optional): the output tensor.

    Example::

        >>> torch.remainder(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
        tensor([ 1.,  0.,  1.,  1.,  0.,  1.])
        >>> torch.remainder(torch.tensor([1., 2, 3, 4, 5]), 1.5)
        tensor([ 1.0000,  0.5000,  0.0000,  1.0000,  0.5000])

    .. seealso::

            :func:`torch.fmod`, which computes the element-wise remainder of
            division equivalently to the C library function ``fmod()``.
  }];
}

def ATen_RemainderInplaceOp: ATen_RefTensorOp<"remainder.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_TrueDivideOp: ATen_ImmutableTensorOp<"true_divide", [NoSideEffect]> {
  let summary = "true_divide(dividend, divisor, *, out) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$dividend,
    ATen_AnyTensor:$divisor
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Performs "true division" that always computes the division
    in floating point. Analogous to division in Python 3 and equivalent to
    :func:`torch.div` except when both inputs have bool or integer scalar types,
    in which case they are cast to the default (floating) scalar type before the division.

    .. math::
        \text{out}_i = \frac{\text{dividend}_i}{\text{divisor}}

    Args:
        dividend (Tensor): the dividend
        divisor (Tensor or Scalar): the divisor

    Keyword args:
        out (Tensor, optional): the output tensor.

    Example::

        >>> dividend = torch.tensor([5, 3], dtype=torch.int)
        >>> divisor = torch.tensor([3, 2], dtype=torch.int)
        >>> torch.true_divide(dividend, divisor)
        tensor([1.6667, 1.5000])
        >>> torch.true_divide(dividend, 2)
        tensor([2.5000, 1.5000])
  }];
}

def ATen_TrueDivideInplaceOp: ATen_RefTensorOp<"true_divide.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$dividend,
    ATen_AnyTensor:$divisor,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_CumsumOp: ATen_ImmutableTensorOp<"cumsum", [NoSideEffect]> {
  let summary = "cumsum(input, dim, out=None, dtype=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyScalar:$dim
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns the cumulative sum of elements of :attr:`input` in the dimension
    :attr:`dim`.

    For example, if :attr:`input` is a vector of size N, the result will also be
    a vector of size N, with elements.

    .. math::
        y_i = x_1 + x_2 + x_3 + \dots + x_i

    Args:
        input (Tensor): the input tensor.
        dim  (int): the dimension to do the operation over
        dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
            If specified, the input tensor is casted to :attr:`dtype` before the operation
            is performed. This is useful for preventing data type overflows. Default: None.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(10)
        >>> a
        tensor([-0.8286, -0.4890,  0.5155,  0.8443,  0.1865, -0.1752, -2.0595,
                 0.1850, -1.1571, -0.4243])
        >>> torch.cumsum(a, dim=0)
        tensor([-0.8286, -1.3175, -0.8020,  0.0423,  0.2289,  0.0537, -2.0058,
                -1.8209, -2.9780, -3.4022])
  }];
}

def ATen_CumsumInplaceOp: ATen_RefTensorOp<"cumsum.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyScalar:$dim,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_MeanOp: ATen_ImmutableTensorOp<"mean", [NoSideEffect]> {
  let summary = "mean(input) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$dim,
    ATen_BoolScalar:$keep_dim
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns the mean value of all elements in the :attr:`input` tensor.

    Args:
        input (Tensor): the input tensor.

    Example::

        >>> a = torch.randn(1, 3)
        >>> a
        tensor([[ 0.2294, -0.5481,  1.3288]])
        >>> torch.mean(a)
        tensor(0.3367)

    .. function:: mean(input, dim, keepdim=False, out=None) -> Tensor

    Returns the mean value of each row of the :attr:`input` tensor in the given
    dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
    reduce over all of them.


    If :attr:`keepdim` is ``True``, the output tensor is of the same size
    as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
    Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
    output tensor having 1 (or ``len(dim)``) fewer dimension(s).


    Args:
        input (Tensor): the input tensor.
        dim (int or tuple of ints): the dimension or dimensions to reduce.
        keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
        out (Tensor, optional): the output tensor.

    Example::

        >>> a = torch.randn(4, 4)
        >>> a
        tensor([[-0.3841,  0.6320,  0.4254, -0.7384],
                [-0.9644,  1.0131, -0.6549, -1.4279],
                [-0.2951, -1.3350, -0.7694,  0.5600],
                [ 1.0842, -0.9580,  0.3623,  0.2343]])
        >>> torch.mean(a, 1)
        tensor([-0.0163, -0.5085, -0.4599,  0.1807])
        >>> torch.mean(a, 1, True)
        tensor([[-0.0163],
                [-0.5085],
                [-0.4599],
                [ 0.1807]])
  }];
}

def ATen_MeanInplaceOp: ATen_RefTensorOp<"mean.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$dim,
    ATen_BoolScalar:$keep_dim,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_SumOp: ATen_ImmutableTensorOp<"sum", [NoSideEffect]> {
  let summary = "sum(input, dtype=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$dim,
    ATen_BoolScalar:$keep_dim
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns the sum of all elements in the :attr:`input` tensor.

    Args:
        input (Tensor): the input tensor.
        dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
            If specified, the input tensor is casted to :attr:`dtype` before the operation
            is performed. This is useful for preventing data type overflows. Default: None.

    Example::

        >>> a = torch.randn(1, 3)
        >>> a
        tensor([[ 0.1133, -0.9567,  0.2958]])
        >>> torch.sum(a)
        tensor(-0.5475)

    .. function:: sum(input, dim, keepdim=False, dtype=None) -> Tensor

    Returns the sum of each row of the :attr:`input` tensor in the given
    dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
    reduce over all of them.


    If :attr:`keepdim` is ``True``, the output tensor is of the same size
    as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
    Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
    output tensor having 1 (or ``len(dim)``) fewer dimension(s).


    Args:
        input (Tensor): the input tensor.
        dim (int or tuple of ints): the dimension or dimensions to reduce.
        keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
        dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
            If specified, the input tensor is casted to :attr:`dtype` before the operation
            is performed. This is useful for preventing data type overflows. Default: None.

    Example::

        >>> a = torch.randn(4, 4)
        >>> a
        tensor([[ 0.0569, -0.2475,  0.0737, -0.3429],
                [-0.2993,  0.9138,  0.9337, -1.6864],
                [ 0.1132,  0.7892, -0.1003,  0.5688],
                [ 0.3637, -0.9906, -0.4752, -1.5197]])
        >>> torch.sum(a, 1)
        tensor([-0.4598, -0.1381,  1.3708, -2.6217])
        >>> b = torch.arange(4 * 5 * 6).view(4, 5, 6)
        >>> torch.sum(b, (2, 1))
        tensor([  435.,  1335.,  2235.,  3135.])
  }];
}

def ATen_SumInplaceOp: ATen_RefTensorOp<"sum.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$dim,
    ATen_BoolScalar:$keep_dim,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_GatherOp: ATen_ImmutableTensorOp<"gather", [NoSideEffect]> {
  let summary = "gather(input, dim, index, out=None, sparse_grad=False) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntScalar:$dim,
    ATen_AnyTensor:$index,
    ATen_BoolScalar:$sparse_grad
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Gathers values along an axis specified by `dim`.

    For a 3-D tensor the output is specified by::

        out[i][j][k] = input[index[i][j][k]][j][k]  # if dim == 0
        out[i][j][k] = input[i][index[i][j][k]][k]  # if dim == 1
        out[i][j][k] = input[i][j][index[i][j][k]]  # if dim == 2

    If :attr:`input` is an n-dimensional tensor with size
    :math:`(x_0, x_1..., x_{i-1}, x_i, x_{i+1}, ..., x_{n-1})`
    and ``dim = i``, then :attr:`index` must be an :math:`n`-dimensional tensor with
    size :math:`(x_0, x_1, ..., x_{i-1}, y, x_{i+1}, ..., x_{n-1})` where :math:`y \geq 1`
    and :attr:`out` will have the same size as :attr:`index`.

    Args:
        input (Tensor): the source tensor
        dim (int): the axis along which to index
        index (LongTensor): the indices of elements to gather
        out (Tensor, optional): the destination tensor
        sparse_grad(bool,optional): If ``True``, gradient w.r.t. :attr:`input` will be a sparse tensor.

    Example::

        >>> t = torch.tensor([[1,2],[3,4]])
        >>> torch.gather(t, 1, torch.tensor([[0,0],[1,0]]))
        tensor([[ 1,  1],
                [ 4,  3]])
  }];
}

def ATen_GatherInplaceOp: ATen_RefTensorOp<"gather.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntScalar:$dim,
    ATen_AnyTensor:$index,
    ATen_BoolScalar:$sparse_grad,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_NumpyTOp: ATen_ImmutableTensorOp<"numpy_T", [NoSideEffect]> {
  let summary = "Is this Tensor with its dimensions reversed.";
  let arguments = (ins
    ATen_AnyTensor:$input
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    If ``n`` is the number of dimensions in ``x``,
    ``x.T`` is equivalent to ``x.permute(n-1, n-2, ..., 0)``.
  }];
}

def ATen_AddmmOp: ATen_ImmutableTensorOp<"addmm", [NoSideEffect]> {
  let summary = "addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$mat1,
    ATen_AnyTensor:$mat2,
    ATen_AnyScalar:$beta,
    ATen_AnyScalar:$alpha
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`.
    The matrix :attr:`input` is added to the final result.

    If :attr:`mat1` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
    :math:`(m \times p)` tensor, then :attr:`input` must be
    :ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
    and :attr:`out` will be a :math:`(n \times p)` tensor.

    :attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
    :attr:`mat1` and :attr:`mat2` and the added matrix :attr:`input` respectively.

    .. math::
        \text{out} = \beta\ \text{input} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)

    For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
    :attr:`alpha` must be real numbers, otherwise they should be integers.

    Args:
        input (Tensor): matrix to be added
        mat1 (Tensor): the first matrix to be multiplied
        mat2 (Tensor): the second matrix to be multiplied
        beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
        alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
        out (Tensor, optional): the output tensor.

    Example::

        >>> M = torch.randn(2, 3)
        >>> mat1 = torch.randn(2, 3)
        >>> mat2 = torch.randn(3, 3)
        >>> torch.addmm(M, mat1, mat2)
        tensor([[-4.8716,  1.4671, -1.3746],
                [ 0.7573, -3.9555, -2.8681]])
  }];
}

def ATen_AddmmInplaceOp: ATen_RefTensorOp<"addmm.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$mat1,
    ATen_AnyTensor:$mat2,
    ATen_AnyScalar:$beta,
    ATen_AnyScalar:$alpha,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_DotOp: ATen_ImmutableTensorOp<"dot", [NoSideEffect]> {
  let summary = "dot(input, tensor) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$tensor
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Computes the dot product (inner product) of two tensors.

    .. note:: This function does not :ref:`broadcast <broadcasting-semantics>`.

    Example::

        >>> torch.dot(torch.tensor([2, 3]), torch.tensor([2, 1]))
        tensor(7)
  }];
}

def ATen_MatmulOp: ATen_ImmutableTensorOp<"matmul", [NoSideEffect]> {
  let summary = "matmul(input, other, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Matrix product of two tensors.

    The behavior depends on the dimensionality of the tensors as follows:

    - If both tensors are 1-dimensional, the dot product (scalar) is returned.
    - If both arguments are 2-dimensional, the matrix-matrix product is returned.
    - If the first argument is 1-dimensional and the second argument is 2-dimensional,
      a 1 is prepended to its dimension for the purpose of the matrix multiply.
      After the matrix multiply, the prepended dimension is removed.
    - If the first argument is 2-dimensional and the second argument is 1-dimensional,
      the matrix-vector product is returned.
    - If both arguments are at least 1-dimensional and at least one argument is
      N-dimensional (where N > 2), then a batched matrix multiply is returned.  If the first
      argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the
      batched matrix multiply and removed after.  If the second argument is 1-dimensional, a
      1 is appended to its dimension for the purpose of the batched matrix multiple and removed after.
      The non-matrix (i.e. batch) dimensions are :ref:`broadcasted <broadcasting-semantics>` (and thus
      must be broadcastable).  For example, if :attr:`input` is a
      :math:`(j \times 1 \times n \times m)` tensor and :attr:`other` is a :math:`(k \times m \times p)`
      tensor, :attr:`out` will be an :math:`(j \times k \times n \times p)` tensor.

    .. note::

        The 1-dimensional dot product version of this function does not support an :attr:`out` parameter.

    Arguments:
        input (Tensor): the first tensor to be multiplied
        other (Tensor): the second tensor to be multiplied
        out (Tensor, optional): the output tensor.

    Example::

        >>> # vector x vector
        >>> tensor1 = torch.randn(3)
        >>> tensor2 = torch.randn(3)
        >>> torch.matmul(tensor1, tensor2).size()
        torch.Size([])
        >>> # matrix x vector
        >>> tensor1 = torch.randn(3, 4)
        >>> tensor2 = torch.randn(4)
        >>> torch.matmul(tensor1, tensor2).size()
        torch.Size([3])
        >>> # batched matrix x broadcasted vector
        >>> tensor1 = torch.randn(10, 3, 4)
        >>> tensor2 = torch.randn(4)
        >>> torch.matmul(tensor1, tensor2).size()
        torch.Size([10, 3])
        >>> # batched matrix x batched matrix
        >>> tensor1 = torch.randn(10, 3, 4)
        >>> tensor2 = torch.randn(10, 4, 5)
        >>> torch.matmul(tensor1, tensor2).size()
        torch.Size([10, 3, 5])
        >>> # batched matrix x broadcasted matrix
        >>> tensor1 = torch.randn(10, 3, 4)
        >>> tensor2 = torch.randn(4, 5)
        >>> torch.matmul(tensor1, tensor2).size()
        torch.Size([10, 3, 5])
  }];
}

def ATen_MatmulInplaceOp: ATen_RefTensorOp<"matmul.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$other,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_MmOp: ATen_ImmutableTensorOp<"mm", [NoSideEffect]> {
  let summary = "mm(input, mat2, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$mat2
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Performs a matrix multiplication of the matrices :attr:`input` and :attr:`mat2`.

    If :attr:`input` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
    :math:`(m \times p)` tensor, :attr:`out` will be a :math:`(n \times p)` tensor.

    .. note:: This function does not :ref:`broadcast <broadcasting-semantics>`.
              For broadcasting matrix products, see :func:`torch.matmul`.

    Args:
        input (Tensor): the first matrix to be multiplied
        mat2 (Tensor): the second matrix to be multiplied
        out (Tensor, optional): the output tensor.

    Example::

        >>> mat1 = torch.randn(2, 3)
        >>> mat2 = torch.randn(3, 3)
        >>> torch.mm(mat1, mat2)
        tensor([[ 0.4851,  0.5037, -0.3633],
                [-0.0760, -3.6705,  2.4784]])
  }];
}

def ATen_MmInplaceOp: ATen_RefTensorOp<"mm.inplace", []> {
  let summary = "See non-inplace op variant.";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyTensor:$mat2,
    ATen_AnyRefTensor:$out
  );
  let results = (outs);
}

def ATen_HardtanhOp: ATen_ImmutableTensorOp<"hardtanh", [NoSideEffect]> {
  let summary = "    hardtanh(input, min_val=-1., max_val=1., inplace=False) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_FloatScalar:$min_val,
    ATen_FloatScalar:$max_val
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
        Applies the HardTanh function element-wise. See :class:`~torch.nn.Hardtanh` for more
        details.

  }];
}

def ATen_AvgPool1dOp: ATen_ImmutableTensorOp<"avg_pool1d", [NoSideEffect]> {
  let summary = "avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$kernel_size,
    ATen_IntList:$stride,
    ATen_IntList:$padding,
    ATen_BoolScalar:$ceil_mode,
    ATen_BoolScalar:$count_include_pad
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Applies a 1D average pooling over an input signal composed of several
    input planes.

    See :class:`~torch.nn.AvgPool1d` for details and output shape.

    Args:
        input: input tensor of shape :math:`(\text{minibatch} , \text{in\_channels} , iW)`
        kernel_size: the size of the window. Can be a single number or a
          tuple `(kW,)`
        stride: the stride of the window. Can be a single number or a tuple
          `(sW,)`. Default: :attr:`kernel_size`
        padding: implicit zero paddings on both sides of the input. Can be a
          single number or a tuple `(padW,)`. Default: 0
        ceil_mode: when True, will use `ceil` instead of `floor` to compute the
            output shape. Default: ``False``
        count_include_pad: when True, will include the zero-padding in the
            averaging calculation. Default: ``True``

    Examples::

        >>> # pool of square window of size=3, stride=2
        >>> input = torch.tensor([[[1, 2, 3, 4, 5, 6, 7]]], dtype=torch.float32)
        >>> F.avg_pool1d(input, kernel_size=3, stride=2)
        tensor([[[ 2.,  4.,  6.]]])
  }];
}

def ATen_MaxPool1dOp: ATen_ImmutableTensorOp<"max_pool1d", [NoSideEffect]> {
  let summary = "Applies a 1D max pooling over an input signal composed of several input";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$kernel_size,
    ATen_IntList:$stride,
    ATen_IntList:$padding,
    ATen_IntList:$dilation,
    ATen_BoolScalar:$ceil_mode
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{

        See :class:`~torch.nn.MaxPool1d` for details.

  }];
}

def ATen_AsStridedOp: ATen_ImmutableTensorOp<"as_strided", [NoSideEffect]> {
  let summary = "as_strided(input, size, stride, storage_offset=0) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$size,
    ATen_IntList:$stride,
    ATen_IntScalar:$storage_offset
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Create a view of an existing `torch.Tensor` :attr:`input` with specified
    :attr:`size`, :attr:`stride` and :attr:`storage_offset`.

    .. warning::
        More than one element of a created tensor may refer to a single memory
        location. As a result, in-place operations (especially ones that are
        vectorized) may result in incorrect behavior. If you need to write to
        the tensors, please clone them first.

        Many PyTorch functions, which return a view of a tensor, are internally
        implemented with this function. Those functions, like
        :meth:`torch.Tensor.expand`, are easier to read and are therefore more
        advisable to use.


    Args:
        input (Tensor): the input tensor.
        size (tuple or ints): the shape of the output tensor
        stride (tuple or ints): the stride of the output tensor
        storage_offset (int, optional): the offset in the underlying storage of the output tensor

    Example::

        >>> x = torch.randn(3, 3)
        >>> x
        tensor([[ 0.9039,  0.6291,  1.0795],
                [ 0.1586,  2.1939, -0.4900],
                [-0.1909, -0.7503,  1.9355]])
        >>> t = torch.as_strided(x, (2, 2), (1, 2))
        >>> t
        tensor([[0.9039, 1.0795],
                [0.6291, 0.1586]])
        >>> t = torch.as_strided(x, (2, 2), (1, 2), 1)
        tensor([[0.6291, 0.1586],
                [1.0795, 2.1939]])

    MLIR Specific Notes
    -------------------
    In PyTorch proper, this op creates a view that may internally alias. And
    have explicit warnings about avoiding inplace updates on such a
    view (without first cloning). For the moment, this op is formulated with
    value semantics that imply a copy instead of a view, and it is expected
    that any sharing can be recovered later by the compiler. The warning
    about not in-place updating of such a result should be treated as UB
    when compiled.
  }];
}

def ATen_ExpandOp: ATen_ImmutableTensorOp<"expand", [NoSideEffect]> {
  let summary = "expand(*sizes) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_AnyScalar:$sizes,
    ATen_BoolScalar:$implicit
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new view of the :attr:`self` tensor with singleton dimensions expanded
    to a larger size.

    Passing -1 as the size for a dimension means not changing the size of
    that dimension.

    Tensor can be also expanded to a larger number of dimensions, and the
    new ones will be appended at the front. For the new dimensions, the
    size cannot be set to -1.

    Expanding a tensor does not allocate new memory, but only creates a
    new view on the existing tensor where a dimension of size one is
    expanded to a larger size by setting the ``stride`` to 0. Any dimension
    of size 1 can be expanded to an arbitrary value without allocating new
    memory.

    Args:
        *sizes (torch.Size or int...): the desired expanded size

    .. warning::

        More than one element of an expanded tensor may refer to a single
        memory location. As a result, in-place operations (especially ones that
        are vectorized) may result in incorrect behavior. If you need to write
        to the tensors, please clone them first.

    Example::

        >>> x = torch.tensor([[1], [2], [3]])
        >>> x.size()
        torch.Size([3, 1])
        >>> x.expand(3, 4)
        tensor([[ 1,  1,  1,  1],
                [ 2,  2,  2,  2],
                [ 3,  3,  3,  3]])
        >>> x.expand(-1, 4)   # -1 means not changing the size of that dimension
        tensor([[ 1,  1,  1,  1],
                [ 2,  2,  2,  2],
                [ 3,  3,  3,  3]])

    MLIR Specific Notes
    -------------------
    See notes for the 'as_strided' op.
  }];
}

def ATen_SqueezeOp: ATen_ImmutableTensorOp<"squeeze", [NoSideEffect]> {
  let summary = "squeeze(input, dim=None, out=None) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntScalar:$dim
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a tensor with all the dimensions of :attr:`input` of size `1` removed.

    For example, if `input` is of shape:
    :math:`(A \times 1 \times B \times C \times 1 \times D)` then the `out` tensor
    will be of shape: :math:`(A \times B \times C \times D)`.

    When :attr:`dim` is given, a squeeze operation is done only in the given
    dimension. If `input` is of shape: :math:`(A \times 1 \times B)`,
    ``squeeze(input, 0)`` leaves the tensor unchanged, but ``squeeze(input, 1)``
    will squeeze the tensor to the shape :math:`(A \times B)`.

    .. note:: The returned tensor shares the storage with the input tensor,
              so changing the contents of one will change the contents of the other.

    .. warning:: If the tensor has a batch dimension of size 1, then `squeeze(input)`
              will also remove the batch dimension, which can lead to unexpected
              errors.

    Args:
        input (Tensor): the input tensor.
        dim (int, optional): if given, the input will be squeezed only in
               this dimension
        out (Tensor, optional): the output tensor.

    Example::

        >>> x = torch.zeros(2, 1, 2, 1, 2)
        >>> x.size()
        torch.Size([2, 1, 2, 1, 2])
        >>> y = torch.squeeze(x)
        >>> y.size()
        torch.Size([2, 2, 2])
        >>> y = torch.squeeze(x, 0)
        >>> y.size()
        torch.Size([2, 1, 2, 1, 2])
        >>> y = torch.squeeze(x, 1)
        >>> y.size()
        torch.Size([2, 2, 1, 2])

    MLIR Specific Notes
    -------------------
    See notes for the 'as_strided' op.
  }];
}

def ATen_ViewOp: ATen_ImmutableTensorOp<"view", [NoSideEffect]> {
  let summary = "view(*shape) -> Tensor";
  let arguments = (ins
    ATen_AnyTensor:$input,
    ATen_IntList:$size
  );
  let results = (outs
    ATen_AnyTensor:$result
  );
  let description = [{
    Returns a new tensor with the same data as the :attr:`self` tensor but of a
    different :attr:`shape`.

    The returned tensor shares the same data and must have the same number
    of elements, but may have a different size. For a tensor to be viewed, the new
    view size must be compatible with its original size and stride, i.e., each new
    view dimension must either be a subspace of an original dimension, or only span
    across original dimensions :math:`d, d+1, \dots, d+k` that satisfy the following
    contiguity-like condition that :math:`\forall i = d, \dots, d+k-1`,

    .. math::

      \text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]

    Otherwise, it will not be possible to view :attr:`self` tensor as :attr:`shape`
    without copying it (e.g., via :meth:`contiguous`). When it is unclear whether a
    :meth:`view` can be performed, it is advisable to use :meth:`reshape`, which
    returns a view if the shapes are compatible, and copies (equivalent to calling
    :meth:`contiguous`) otherwise.

    Args:
        shape (torch.Size or int...): the desired size

    Example::

        >>> x = torch.randn(4, 4)
        >>> x.size()
        torch.Size([4, 4])
        >>> y = x.view(16)
        >>> y.size()
        torch.Size([16])
        >>> z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
        >>> z.size()
        torch.Size([2, 8])

        >>> a = torch.randn(1, 2, 3, 4)
        >>> a.size()
        torch.Size([1, 2, 3, 4])
        >>> b = a.transpose(1, 2)  # Swaps 2nd and 3rd dimension
        >>> b.size()
        torch.Size([1, 3, 2, 4])
        >>> c = a.view(1, 3, 2, 4)  # Does not change tensor layout in memory
        >>> c.size()
        torch.Size([1, 3, 2, 4])
        >>> torch.equal(b, c)
        False


    MLIR Specific Notes
    -------------------
    See notes for the 'as_strided' op.
  }];
}