maxframe 0.1.0b5__cp311-cp311-macosx_11_0_arm64.whl

maxframe/tensor/arithmetic/arctanh.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 TensorArctanh(TensorUnaryOp):
+    _op_type_ = opcodes.ARCTANH
+    _func_name = "arctanh"
+
+
+@infer_dtype(np.arctanh)
+def arctanh(x, out=None, where=None, **kwargs):
+    """
+    Inverse hyperbolic tangent element-wise.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.
+    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 : Tensor
+        Array of the same shape as `x`.
+
+    Notes
+    -----
+    `arctanh` is a multivalued function: for each `x` there are infinitely
+    many numbers `z` such that `tanh(z) = x`. The convention is to return
+    the `z` whose imaginary part lies in `[-pi/2, pi/2]`.
+
+    For real-valued input data types, `arctanh` always returns real output.
+    For each value that cannot be expressed as a real number or infinity,
+    it yields ``nan`` and sets the `invalid` floating point error flag.
+
+    For complex-valued input, `arctanh` is a complex analytical function
+    that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
+    above on the former and from below on the latter.
+
+    The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.
+
+    References
+    ----------
+    .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
+           10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+    .. [2] Wikipedia, "Inverse hyperbolic function",
+           http://en.wikipedia.org/wiki/Arctanh
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.arctanh([0, -0.5]).execute()
+    array([ 0.        , -0.54930614])
+    """
+    op = TensorArctanh(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/around.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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,95 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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,102 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 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,95 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 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,66 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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)