[API Compatibility] Add out support for 11 APIs

paddle/fluid/eager/api/manual/eager_manual/forwards/multiply_fwd_func.cc

@@ -140,7 +140,7 @@ paddle::Tensor multiply_ad_func(const paddle::Tensor& x,
   }
 
   // Forward API Call
-  auto api_result = paddle::experimental::multiply(x, y);
+  auto api_result = paddle::experimental::multiply(x, y, input_out);
   // Check NaN and Inf if needed
 
   if (FLAGS_check_nan_inf) {

python/paddle/nn/quant/functional_layers.py

@@ -28,68 +28,68 @@ def __init__(self):
         super().__init__()
 
     def forward(self, x, y, name=None):
-        return math.add(x, y, name)
+        return math.add(x, y, name=name)
 
 
 class subtract(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, y, name=None):
-        return math.subtract(x, y, name)
+        return math.subtract(x, y, name=name)
 
 
 class multiply(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, y, name=None):
-        return math.multiply(x, y, name)
+        return math.multiply(x, y, name=name)
 
 
 class divide(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, y, name=None):
-        return math.divide(x, y, name)
+        return math.divide(x, y, name=name)
 
 
 class reshape(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, shape, name=None):
-        return manipulation.reshape(x, shape, name)
+        return manipulation.reshape(x, shape, name=name)
 
 
 class transpose(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, perm, name=None):
-        return manipulation.transpose(x, perm, name)
+        return manipulation.transpose(x, perm, name=name)
 
 
 class concat(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, axis=0, name=None):
-        return manipulation.concat(x, axis, name)
+        return manipulation.concat(x, axis, name=name)
 
 
 class flatten(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, start_axis=0, stop_axis=-1, name=None):
-        return manipulation.flatten(x, start_axis, stop_axis, name)
+        return manipulation.flatten(x, start_axis, stop_axis, name=name)
 
 
 class matmul(FloatFunctionalLayer):
     def __init__(self):
         super().__init__()
 
     def forward(self, x, y, transpose_x=False, transpose_y=False, name=None):
-        return linalg.matmul(x, y, transpose_x, transpose_y, name)
+        return linalg.matmul(x, y, transpose_x, transpose_y, name=name)

python/paddle/tensor/creation.py

@@ -3170,7 +3170,11 @@ def _memcpy(input, place=None, output=None) -> paddle.Tensor:
 
 
 def complex(
-    real: paddle.Tensor, imag: paddle.Tensor, out=None, name: str | None = None
+    real: paddle.Tensor,
+    imag: paddle.Tensor,
+    name: str | None = None,
+    *,
+    out: paddle.Tensor | None = None,
 ) -> paddle.Tensor:
     """Return a complex tensor given the real and image component.
 
@@ -3392,14 +3396,19 @@ def triu_indices(
 
 
 def polar(
-    abs: paddle.Tensor, angle: paddle.Tensor, name: str | None = None
+    abs: paddle.Tensor,
+    angle: paddle.Tensor,
+    name: str | None = None,
+    *,
+    out: paddle.Tensor | None = None,
 ) -> paddle.Tensor:
     """Return a Cartesian coordinates corresponding to the polar coordinates complex tensor given the ``abs`` and ``angle`` component.
 
     Args:
         abs (Tensor): The abs component. The data type should be 'float32' or 'float64'.
         angle (Tensor): The angle component. The data type should be the same as ``abs``.
-        name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
+        name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
+        out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None.
 
     Returns:
         Tensor, The output tensor. The data type is 'complex64' or 'complex128', with the same precision as ``abs`` and ``angle``.
@@ -3428,7 +3437,9 @@ def polar(
         angle, 'angle', ['float32', 'float64'], 'paddle.polar'
     )
 
-    return paddle.complex(abs * paddle.cos(angle), abs * paddle.sin(angle))
+    return paddle.complex(
+        abs * paddle.cos(angle), abs * paddle.sin(angle), out=out, name=name
+    )
 
 
 @dygraph_only

python/paddle/tensor/manipulation.py

@@ -2187,8 +2187,13 @@ def roll(
         return out
 
 
+@ParamAliasDecorator({"x": ["tensors"], "axis": ["dim"]})
 def stack(
-    x: Sequence[Tensor], axis: int = 0, name: str | None = None
+    x: Sequence[Tensor],
+    axis: int = 0,
+    name: str | None = None,
+    *,
+    out: Tensor | None = None,
 ) -> Tensor:
     """
     Stacks all the input tensors ``x`` along ``axis`` dimension.
@@ -2284,11 +2289,12 @@ def stack(
 
     Args:
         x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x``
-                                     must be of the same shape and dtype. Supported data types: float32, float64, int32, int64.
+                                     must be of the same shape and dtype. Supported data types: float32, float64, int32, int64. Alias: ``tensors``.
         axis (int, optional): The axis along which all inputs are stacked. ``axis`` range is ``[-(R+1), R+1)``,
                               where ``R`` is the number of dimensions of the first input tensor ``x[0]``.
-                              If ``axis < 0``, ``axis = axis+R+1``. The default value of axis is 0.
+                              If ``axis < 0``, ``axis = axis+R+1``. The default value of axis is 0. Alias: ``dim``.
         name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+        out (Tensor, optional): The output tensor. If set, the output will be written to this tensor.
 
     Returns:
         Tensor, The stacked tensor with same data type as input.
@@ -2342,7 +2348,7 @@ def stack(
     axis = 0 if axis is None else axis
 
     if in_dynamic_mode():
-        return _C_ops.stack(x, axis)
+        return _C_ops.stack(x, axis, out=out)
 
     if not isinstance(x, list) and not isinstance(x, tuple):
         # NOTE:(zhiqiu) Only support Variable as input if the Variable is a DENSE_TENSOR_ARRAY create by create_array, array_write, array_read, etc.

python/paddle/tensor/math.py

@@ -153,7 +153,10 @@ def _get_reduce_axis_with_tensor(axis, x):
     return reduce_all, axis
 
 
-def log(x: Tensor, name: str | None = None) -> Tensor:
+@ParamAliasDecorator({"x": ["input"]})
+def log(
+    x: Tensor, name: str | None = None, *, out: Tensor | None = None
+) -> Tensor:
     r"""
     Calculates the natural log of the given input Tensor, element-wise.
 
@@ -162,8 +165,9 @@ def log(x: Tensor, name: str | None = None) -> Tensor:
         Out = \ln(x)
 
     Args:
-        x (Tensor): Input Tensor. Must be one of the following types: int32, int64, float16, bfloat16, float32, float64, complex64, complex128.
+        x (Tensor): Input Tensor. Must be one of the following types: int32, int64, float16, bfloat16, float32, float64, complex64, complex128. Alias: ``input``.
         name (str|None): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+        out (Tensor, optional): The output Tensor. If set, the result will be stored in this tensor. Default is None.
 
 
     Returns:
@@ -183,7 +187,7 @@ def log(x: Tensor, name: str | None = None) -> Tensor:
              [1.94591010, 2.07944155, 2.19722462]])
     """
     if in_dynamic_or_pir_mode():
-        return _C_ops.log(x)
+        return _C_ops.log(x, out=out)
     else:
         check_variable_and_dtype(
             x,
@@ -519,7 +523,13 @@ def scale_(
 
 
 @ParamAliasDecorator({"x": ["input"], "y": ["exponent"]})
-def pow(x: Tensor, y: float | Tensor, name: str | None = None) -> Tensor:
+def pow(
+    x: Tensor,
+    y: float | Tensor,
+    name: str | None = None,
+    *,
+    out: Tensor | None = None,
+) -> Tensor:
     """
     Compute the power of Tensor elements. The equation is:
 
@@ -541,6 +551,7 @@ def pow(x: Tensor, y: float | Tensor, name: str | None = None) -> Tensor:
         y (float|int|Tensor): If it is an N-D Tensor, its data type should be the same as `x`.
         exponent: An alias for ``y`` , with identical behavior.
         name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+        out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None.
 
     Returns:
         N-D Tensor. A location into which the result is stored. Its dimension and data type are the same as `x`.
@@ -575,9 +586,9 @@ def pow(x: Tensor, y: float | Tensor, name: str | None = None) -> Tensor:
     # in dynamic graph mode
     if in_dynamic_or_pir_mode():
         if isinstance(y, (int, float)):
-            return _C_ops.pow(x, y)
+            return _C_ops.pow(x, y, out=out)
         elif isinstance(y, (paddle.Tensor, Variable, paddle.pir.Value)):
-            return _C_ops.elementwise_pow(x, y)
+            return _C_ops.elementwise_pow(x, y, out=out)
         else:
             raise TypeError(
                 f"y must be scalar, Tensor(in dygraph mode), Value(in pir mode) but received: {type(y)}"
@@ -1120,7 +1131,10 @@ def remainder_(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
     """
 
 
-def multiply(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
+@ParamAliasDecorator({"x": ["input"], "y": ["other"]})
+def multiply(
+    x: Tensor, y: Tensor, name: str | None = None, *, out: Tensor | None = None
+) -> Tensor:
     """
     multiply two tensors element-wise. The equation is:
 
@@ -1136,9 +1150,10 @@ def multiply(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
         .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor
 
     Args:
-        x (Tensor): the input tensor, its data type should be one of bfloat16, float16, float32, float64, int32, int64, bool, complex64, complex128.
-        y (Tensor): the input tensor, its data type should be one of bfloat16, float16, float32, float64, int32, int64, bool, complex64, complex128.
+        x (Tensor): the input tensor, its data type should be one of bfloat16, float16, float32, float64, int32, int64, bool, complex64, complex128. Alias: input.
+        y (Tensor): the input tensor, its data type should be one of bfloat16, float16, float32, float64, int32, int64, bool, complex64, complex128. Alias: other.
         name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+        out (Tensor|None, optional): The output tensor. If set, the result will be stored in this tensor. Default is None.
 
     Returns:
         N-D Tensor. A location into which the result is stored. If :attr:`x`, :attr:`y` have different shapes and are "broadcastable", the resulting tensor shape is the shape of :attr:`x` and :attr:`y` after broadcasting. If :attr:`x`, :attr:`y` have the same shape, its shape is the same as :attr:`x` and :attr:`y`.
@@ -1166,7 +1181,7 @@ def multiply(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
 
     """
     if in_dynamic_or_pir_mode():
-        return _C_ops.multiply(x, y)
+        return _C_ops.multiply(x, y, out=out)
     else:
         return _elementwise_op(LayerHelper('elementwise_mul', **locals()))
 
@@ -5077,13 +5092,17 @@ def prod(
         return out
 
 
-def sign(x: Tensor, name: str | None = None) -> Tensor:
+@ParamAliasDecorator({"x": ["input"]})
+def sign(
+    x: Tensor, name: str | None = None, *, out: Tensor | None = None
+) -> Tensor:
     """
     Returns sign of every element in `x`: For real numbers, 1 for positive, -1 for negative and 0 for zero. For complex numbers, the return value is a complex number with unit magnitude. If a complex number element is zero, the result is 0+0j.
 
     Args:
-        x (Tensor): The input tensor. The data type can be uint8, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64 or complex128.
+        x (Tensor): The input tensor. The data type can be uint8, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64 or complex128. Alias: ``input``.
         name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+        out (Tensor|None, optional): The output tensor. If set, the result will be stored in this tensor. Default is None.
 
     Returns:
         Tensor: The output sign tensor with identical shape and data type to the input :attr:`x`.
@@ -5100,7 +5119,7 @@ def sign(x: Tensor, name: str | None = None) -> Tensor:
             [ 1.,  0., -1.,  1.])
     """
     if in_dynamic_or_pir_mode():
-        return _C_ops.sign(x)
+        return _C_ops.sign(x, out=out)
     else:
         check_variable_and_dtype(
             x,