maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/around.py

@@ -0,0 +1,112 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import Int32Field
+from ..datasource import tensor as astensor
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(init=False, sparse_mode="unary")
+class TensorAround(TensorUnaryOp):
+    _op_type_ = opcodes.AROUND
+    _func_name = "around"
+
+    decimals = Int32Field("decimals", default=None)
+
+    def __init__(self, casting="same_kind", err=None, dtype=None, sparse=False, **kw):
+        err = err if err is not None else np.geterr()
+        super().__init__(casting=casting, err=err, dtype=dtype, sparse=sparse, **kw)
+
+    @property
+    def ufunc_extra_params(self):
+        return {"decimals": self.decimals}
+
+
+def around(a, decimals=0, out=None):
+    """
+    Evenly round to the given number of decimals.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    decimals : int, optional
+        Number of decimal places to round to (default: 0).  If
+        decimals is negative, it specifies the number of positions to
+        the left of the decimal point.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+
+    Returns
+    -------
+    rounded_array : Tensor
+        An tensor of the same type as `a`, containing the rounded values.
+        Unless `out` was specified, a new tensor is created.  A reference to
+        the result is returned.
+
+        The real and imaginary parts of complex numbers are rounded
+        separately.  The result of rounding a float is a float.
+
+    See Also
+    --------
+    Tensor.round : equivalent method
+
+    ceil, fix, floor, rint, trunc
+
+
+    Notes
+    -----
+    For values exactly halfway between rounded decimal values, NumPy
+    rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
+    -0.5 and 0.5 round to 0.0, etc. Results may also be surprising due
+    to the inexact representation of decimal fractions in the IEEE
+    floating point standard [1]_ and errors introduced when scaling
+    by powers of ten.
+
+    References
+    ----------
+    .. [1] "Lecture Notes on the Status of  IEEE 754", William Kahan,
+           http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF
+    .. [2] "How Futile are Mindless Assessments of
+           Roundoff in Floating-Point Computation?", William Kahan,
+           http://www.cs.berkeley.edu/~wkahan/Mindless.pdf
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.around([0.37, 1.64]).execute()
+    array([ 0.,  2.])
+    >>> mt.around([0.37, 1.64], decimals=1).execute()
+    array([ 0.4,  1.6])
+    >>> mt.around([.5, 1.5, 2.5, 3.5, 4.5]).execute() # rounds to nearest even value
+    array([ 0.,  2.,  2.,  4.,  4.])
+    >>> mt.around([1,2,3,11], decimals=1).execute() # tensor of ints is returned
+    array([ 1,  2,  3, 11])
+    >>> mt.around([1,2,3,11], decimals=-1).execute()
+    array([ 0,  0,  0, 10])
+
+    """
+    dtype = astensor(a).dtype
+    op = TensorAround(decimals=decimals, dtype=dtype)
+    return op(a, out=out)
+
+
+round_ = around

maxframe/tensor/arithmetic/bitand.py

@@ -0,0 +1,93 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_or")
+class TensorBitand(TensorBinOp):
+    _op_type_ = opcodes.BITAND
+    _func_name = "bitwise_and"
+
+
+@infer_dtype(np.bitwise_and)
+def bitand(x1, x2, out=None, where=None, **kwargs):
+    """
+    Compute the bit-wise AND of two tensors element-wise.
+
+    Computes the bit-wise AND of the underlying binary representation of
+    the integers in the input arrays. This ufunc implements the C/Python
+    operator ``&``.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Only integer and boolean types are handled.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    out : array_like
+        Result.
+
+    See Also
+    --------
+    logical_and
+    bitwise_or
+    bitwise_xor
+
+    Examples
+    --------
+    The number 13 is represented by ``00001101``.  Likewise, 17 is
+    represented by ``00010001``.  The bit-wise AND of 13 and 17 is
+    therefore ``000000001``, or 1:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.bitwise_and(13, 17).execute()
+    1
+
+    >>> mt.bitwise_and(14, 13).execute()
+    12
+    >>> mt.bitwise_and([14,3], 13).execute()
+    array([12,  1])
+
+    >>> mt.bitwise_and([11,7], [4,25]).execute()
+    array([0, 1])
+    >>> mt.bitwise_and(mt.array([2,5,255]), mt.array([3,14,16])).execute()
+    array([ 2,  4, 16])
+    >>> mt.bitwise_and([True, True], [False, True]).execute()
+    array([False,  True])
+    """
+    op = TensorBitand(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.bitwise_and, reverse=True)
+def rbitand(x1, x2, **kwargs):
+    op = TensorBitand(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/bitor.py

@@ -0,0 +1,100 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorBitor(TensorBinOp):
+    _op_type_ = opcodes.BITOR
+    _func_name = "bitwise_or"
+
+
+@infer_dtype(np.bitwise_or)
+def bitor(x1, x2, out=None, where=None, **kwargs):
+    """
+    Compute the bit-wise OR of two tensors element-wise.
+
+    Computes the bit-wise OR of the underlying binary representation of
+    the integers in the input arrays. This ufunc implements the C/Python
+    operator ``|``.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Only integer and boolean types are handled.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    out : array_like
+        Result.
+
+    See Also
+    --------
+    logical_or
+    bitwise_and
+    bitwise_xor
+    binary_repr :
+        Return the binary representation of the input number as a string.
+
+    Examples
+    --------
+    The number 13 has the binaray representation ``00001101``. Likewise,
+    16 is represented by ``00010000``.  The bit-wise OR of 13 and 16 is
+    then ``000111011``, or 29:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.bitwise_or(13, 16).execute()
+    29
+
+    >>> mt.bitwise_or(32, 2).execute()
+    34
+    >>> mt.bitwise_or([33, 4], 1).execute()
+    array([33,  5])
+    >>> mt.bitwise_or([33, 4], [1, 2]).execute()
+    array([33,  6])
+
+    >>> mt.bitwise_or(mt.array([2, 5, 255]), mt.array([4, 4, 4])).execute()
+    array([  6,   5, 255])
+    >>> (mt.array([2, 5, 255]) | mt.array([4, 4, 4])).execute()
+    array([  6,   5, 255])
+    >>> mt.bitwise_or(mt.array([2, 5, 255, 2147483647], dtype=mt.int32),
+    ...               mt.array([4, 4, 4, 2147483647], dtype=mt.int32)).execute()
+    array([         6,          5,        255, 2147483647])
+    >>> mt.bitwise_or([True, True], [False, True]).execute()
+    array([ True,  True])
+    """
+    op = TensorBitor(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.bitwise_or, reverse=True)
+def rbitor(x1, x2, **kwargs):
+    op = TensorBitor(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/bitxor.py

@@ -0,0 +1,93 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorBitxor(TensorBinOp):
+    _op_type_ = opcodes.BITXOR
+    _func_name = "bitwise_xor"
+
+
+@infer_dtype(np.bitwise_xor)
+def bitxor(x1, x2, out=None, where=None, **kwargs):
+    """
+    Compute the bit-wise XOR of two arrays element-wise.
+
+    Computes the bit-wise XOR of the underlying binary representation of
+    the integers in the input arrays. This ufunc implements the C/Python
+    operator ``^``.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Only integer and boolean types are handled.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    out : array_like
+        Result.
+
+    See Also
+    --------
+    logical_xor
+    bitwise_and
+    bitwise_or
+    binary_repr :
+        Return the binary representation of the input number as a string.
+
+    Examples
+    --------
+    The number 13 is represented by ``00001101``. Likewise, 17 is
+    represented by ``00010001``.  The bit-wise XOR of 13 and 17 is
+    therefore ``00011100``, or 28:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.bitwise_xor(13, 17).execute()
+    28
+
+    >>> mt.bitwise_xor(31, 5).execute()
+    26
+    >>> mt.bitwise_xor([31,3], 5).execute()
+    array([26,  6])
+
+    >>> mt.bitwise_xor([31,3], [5,6]).execute()
+    array([26,  5])
+    >>> mt.bitwise_xor([True, True], [False, True]).execute()
+    array([ True, False])
+    """
+    op = TensorBitxor(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.bitwise_xor, reverse=True)
+def rbitxor(x1, x2, **kwargs):
+    op = TensorBitxor(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/cbrt.py

@@ -0,0 +1,64 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorCbrt(TensorUnaryOp):
+    _op_type_ = opcodes.CBRT
+    _func_name = "cbrt"
+
+
+@infer_dtype(np.cbrt)
+def cbrt(x, out=None, where=None, **kwargs):
+    """
+    Return the cube-root of an tensor, element-wise.
+
+    Parameters
+    ----------
+    x : array_like
+        The values whose cube-roots are required.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : Tensor
+        An tensor of the same shape as `x`, containing the cube
+        cube-root of each element in `x`.
+        If `out` was provided, `y` is a reference to it.
+
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.cbrt([1,8,27]).execute()
+    array([ 1.,  2.,  3.])
+    """
+    op = TensorCbrt(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/ceil.py

@@ -0,0 +1,69 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ..utils import infer_dtype
+from .core import TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorCeil(TensorUnaryOp):
+    _op_type_ = opcodes.CEIL
+    _func_name = "ceil"
+
+
+@infer_dtype(np.ceil)
+def ceil(x, out=None, where=None, **kwargs):
+    r"""
+    Return the ceiling of the input, element-wise.
+
+    The ceil of the scalar `x` is the smallest integer `i`, such that
+    `i >= x`.  It is often denoted as :math:`\lceil x \rceil`.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data.
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    y : Tensor or scalar
+        The ceiling of each element in `x`, with `float` dtype.
+
+    See Also
+    --------
+    floor, trunc, rint
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+    >>> mt.ceil(a).execute()
+    array([-1., -1., -0.,  1.,  2.,  2.,  2.])
+    """
+    op = TensorCeil(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/clip.py

@@ -0,0 +1,165 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from numbers import Number
+from typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, EntityData
+from ...serialization.serializables import AnyField, KeyField
+from ..core import Tensor
+from ..datasource import tensor as astensor
+from ..utils import broadcast_shape
+from .core import TensorElementWise, TensorOperator, filter_inputs
+
+
+class TensorClip(TensorOperator, TensorElementWise):
+    _op_type_ = opcodes.CLIP
+
+    a = KeyField("a", default=None)
+    a_min = AnyField("a_min", default=None)
+    a_max = AnyField("a_max", default=None)
+    out = KeyField("out", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorClip", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
+        op.a = next(inputs_iter)
+        if isinstance(op.a_min, ENTITY_TYPE):
+            op.a_min = next(inputs_iter)
+        if isinstance(op.a_max, ENTITY_TYPE):
+            op.a_max = next(inputs_iter)
+        if getattr(op, "_out", None) is not None:
+            op.out = next(inputs_iter)
+
+    def __call__(self, a, a_min, a_max, out=None):
+        a = astensor(a)
+        tensors = [a]
+        sparse = a.issparse()
+
+        if isinstance(a_min, Number):
+            if a_min > 0:
+                sparse = False
+            a_min_dtype = np.array(a_min).dtype
+        elif a_min is not None:
+            a_min = astensor(a_min)
+            tensors.append(a_min)
+            if not a_min.issparse():
+                sparse = False
+            a_min_dtype = a_min.dtype
+        else:
+            a_min_dtype = None
+        self.a_min = a_min
+
+        if isinstance(a_max, Number):
+            if a_max < 0:
+                sparse = False
+            a_max_dtype = np.array(a_max).dtype
+        elif a_max is not None:
+            a_max = astensor(a_max)
+            tensors.append(a_max)
+            if not a_max.issparse():
+                sparse = False
+            a_max_dtype = a_max.dtype
+        else:
+            a_max_dtype = None
+        self.a_max = a_max
+
+        if out is not None:
+            if isinstance(out, Tensor):
+                self.out = out
+            else:
+                raise TypeError(f"out should be Tensor object, got {type(out)} instead")
+
+        dtypes = [dt for dt in [a.dtype, a_min_dtype, a_max_dtype] if dt is not None]
+        dtype = np.result_type(*dtypes)
+        # check broadcast
+        shape = broadcast_shape(*[t.shape for t in tensors])
+
+        setattr(self, "sparse", sparse)
+        inputs = filter_inputs([a, a_min, a_max, out])
+        t = self.new_tensor(inputs, shape)
+
+        if out is None:
+            setattr(self, "dtype", dtype)
+            return t
+
+        # if `out` is specified, use out's dtype and shape
+        out_shape, out_dtype = out.shape, out.dtype
+
+        if t.shape != out_shape:
+            t = self.new_tensor(inputs, out_shape)
+        setattr(self, "dtype", out_dtype)
+
+        out.data = t.data
+        return out
+
+
+def clip(a, a_min, a_max, out=None):
+    """
+    Clip (limit) the values in a tensor.
+
+    Given an interval, values outside the interval are clipped to
+    the interval edges.  For example, if an interval of ``[0, 1]``
+    is specified, values smaller than 0 become 0, and values larger
+    than 1 become 1.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing elements to clip.
+    a_min : scalar or array_like or `None`
+        Minimum value. If `None`, clipping is not performed on lower
+        interval edge. Not more than one of `a_min` and `a_max` may be
+        `None`.
+    a_max : scalar or array_like or `None`
+        Maximum value. If `None`, clipping is not performed on upper
+        interval edge. Not more than one of `a_min` and `a_max` may be
+        `None`. If `a_min` or `a_max` are array_like, then the three
+        arrays will be broadcasted to match their shapes.
+    out : Tensor, optional
+        The results will be placed in this tensor. It may be the input
+        array for in-place clipping.  `out` must be of the right shape
+        to hold the output.  Its type is preserved.
+
+    Returns
+    -------
+    clipped_array : Tensor
+        An tensor with the elements of `a`, but where values
+        < `a_min` are replaced with `a_min`, and those > `a_max`
+        with `a_max`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(10)
+    >>> mt.clip(a, 1, 8).execute()
+    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
+    >>> a.execute()
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> mt.clip(a, 3, 6, out=a).execute()
+    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
+    >>> a = mt.arange(10)
+    >>> a.execute()
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> mt.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8).execute()
+    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
+
+    """
+    op = TensorClip(a=a, a_min=a_min, a_max=a_max, out=out)
+    return op(a, a_min, a_max, out=out)