maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/cos.py

@@ -0,0 +1,83 @@
+# 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="always_false")
+class TensorCos(TensorUnaryOp):
+    _op_type_ = opcodes.COS
+    _func_name = "cos"
+
+
+@infer_dtype(np.cos)
+def cos(x, out=None, where=None, **kwargs):
+    """
+    Cosine element-wise.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor in radians.
+    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 array 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
+        The corresponding cosine values.
+
+    Notes
+    -----
+    If `out` is provided, the function writes the result into it,
+    and returns a reference to `out`.  (See Examples)
+
+    References
+    ----------
+    M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+    New York, NY: Dover, 1972.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.cos(mt.array([0, mt.pi/2, mt.pi])).execute()
+    array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])
+    >>>
+    >>> # Example of providing the optional output parameter
+    >>> out1 = mt.empty(1)
+    >>> out2 = mt.cos([0.1], out1)
+    >>> out2 is out1
+    True
+    >>>
+    >>> # Example of ValueError due to provision of shape mis-matched `out`
+    >>> mt.cos(mt.zeros((3,3)),mt.zeros((2,2)))
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    ValueError: operators could not be broadcast together with shapes (3,3) (2,2)
+    """
+    op = TensorCos(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/cosh.py

@@ -0,0 +1,70 @@
+# 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 TensorCosh(TensorUnaryOp):
+    _op_type_ = opcodes.COSH
+    _func_name = "cosh"
+
+
+@infer_dtype(np.cosh)
+def cosh(x, out=None, where=None, **kwargs):
+    """
+    Hyperbolic cosine, element-wise.
+
+    Equivalent to ``1/2 * (mt.exp(x) + mt.exp(-x))`` and ``mt.cos(1j*x)``.
+
+    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
+        Output array of same shape as `x`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.cosh(0).execute()
+    1.0
+
+    The hyperbolic cosine describes the shape of a hanging cable:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = mt.linspace(-4, 4, 1000)
+    >>> plt.plot(x.execute(), mt.cosh(x).execute())
+    >>> plt.show()
+    """
+    op = TensorCosh(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/deg2rad.py

@@ -0,0 +1,70 @@
+# 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 TensorDeg2rad(TensorUnaryOp):
+    _op_type_ = opcodes.DEG2RAD
+    _func_name = "deg2rad"
+
+
+@infer_dtype(np.deg2rad)
+def deg2rad(x, out=None, where=None, **kwargs):
+    """
+    Convert angles from degrees to radians.
+
+    Parameters
+    ----------
+    x : array_like
+        Angles in degrees.
+    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
+        The corresponding angle in radians.
+
+    See Also
+    --------
+    rad2deg : Convert angles from radians to degrees.
+    unwrap : Remove large jumps in angle by wrapping.
+
+    Notes
+    -----
+    ``deg2rad(x)`` is ``x * pi / 180``.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.deg2rad(180).execute()
+    3.1415926535897931
+    """
+    op = TensorDeg2rad(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/degrees.py

@@ -0,0 +1,75 @@
+# 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 TensorDegrees(TensorUnaryOp):
+    _op_type_ = opcodes.DEGREES
+    _func_name = "degrees"
+
+
+@infer_dtype(np.degrees)
+def degrees(x, out=None, where=None, **kwargs):
+    """
+    Convert angles from radians to degrees.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor in radians.
+    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 of floats
+        The corresponding degree values; if `out` was supplied this is a
+        reference to it.
+
+    See Also
+    --------
+    rad2deg : equivalent function
+
+    Examples
+    --------
+    Convert a radian array to degrees
+
+    >>> import maxframe.tensor as mt
+
+    >>> rad = mt.arange(12.)*mt.pi/6
+    >>> mt.degrees(rad).execute()
+    array([   0.,   30.,   60.,   90.,  120.,  150.,  180.,  210.,  240.,
+            270.,  300.,  330.])
+
+    >>> out = mt.zeros((rad.shape))
+    >>> r = mt.degrees(out)
+    >>> mt.all(r == out).execute()
+    True
+    """
+    op = TensorDegrees(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/divide.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 ..utils import infer_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator
+class TensorDivide(TensorBinOp):
+    _op_type_ = opcodes.DIV
+    _func_name = "divide"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if not np.isscalar(x1) and not np.isscalar(x2):
+            return False
+        if hasattr(x1, "issparse") and x1.issparse():
+            if x2 != 0:
+                return True
+            else:
+                raise ZeroDivisionError("float division by zero")
+
+
+@infer_dtype(np.divide)
+def divide(x1, x2, out=None, where=None, **kwargs):
+    """
+    Divide arguments element-wise.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Dividend tensor.
+    x2 : array_like
+        Divisor 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 array 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
+        The quotient `x1/x2`, element-wise. Returns a scalar if both `x1` and `x2` are scalars.
+
+    Notes
+    -----
+    Equivalent to `x1` / `x2` in terms of array-broadcasting.
+
+    Behavior on division by zero can be changed using `seterr`.
+
+    In Python 2, when both `x1` and `x2` are of an integer type, `divide` will behave like `floor_divide`.
+    In Python 3, it behaves like `true_divide`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.divide(2.0, 4.0).execute()
+    0.5
+    >>> x1 = mt.arange(9.0).reshape((3, 3))
+    >>> x2 = mt.arange(3.0)
+    >>> mt.divide(x1, x2).execute()
+    array([[ NaN,  1. ,  1. ],
+           [ Inf,  4. ,  2.5],
+           [ Inf,  7. ,  4. ]])
+    Note the behavior with integer types (Python 2 only):
+    >>> mt.divide(2, 4).execute()
+    0
+    >>> mt.divide(2, 4.).execute()
+    0.5
+    Division by zero always yields zero in integer arithmetic (again, Python 2 only),
+    and does not raise an exception or a warning:
+    >>> mt.divide(mt.array([0, 1], dtype=int), mt.array([0, 0], dtype=int)).execute()
+    array([0, 0])
+    Division by zero can, however, be caught using seterr:
+    >>> old_err_state = mt.seterr(divide='raise')
+    >>> mt.divide(1, 0).execute()
+    Traceback (most recent call last):
+    ...
+    FloatingPointError: divide by zero encountered in divide
+    >>> ignored_states = mt.seterr(**old_err_state)
+    >>> mt.divide(1, 0).execute()
+    0
+    """
+    op = TensorDivide(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.divide, reverse=True)
+def rdivide(x1, x2, **kwargs):
+    op = TensorDivide(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/equal.py

@@ -0,0 +1,74 @@
+# 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 inject_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorEqual(TensorBinOp):
+    _op_type_ = opcodes.EQ
+    _func_name = "equal"
+
+
+@inject_dtype(np.bool_)
+def equal(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return (x1 == x2) element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        Input tensors of the same shape.
+    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 array 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
+        For other keyword-only arguments, see the
+        :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    Returns
+    -------
+    out : Tensor or bool
+        Output tensor of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    not_equal, greater_equal, less_equal, greater, less
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.equal([0, 1, 3], mt.arange(3)).execute()
+    array([ True,  True, False])
+
+    What is compared are values, not types. So an int (1) and a tensor of
+    length one can evaluate as True:
+
+    >>> mt.equal(1, mt.ones(1))
+    array([ True])
+    """
+
+    op = TensorEqual(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/exp.py

@@ -0,0 +1,104 @@
+# 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="always_false")
+class TensorExp(TensorUnaryOp):
+    _op_type_ = opcodes.EXP
+    _func_name = "exp"
+
+
+@infer_dtype(np.exp)
+def exp(x, out=None, where=None, **kwargs):
+    r"""
+    Calculate the exponential of all elements in the input tensor.
+
+    Parameters
+    ----------
+    x : array_like
+        Input values.
+    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
+        For other keyword-only arguments, see the
+        :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    Returns
+    -------
+    out : Tensor
+        Output tensor, element-wise exponential of `x`.
+
+    See Also
+    --------
+    expm1 : Calculate ``exp(x) - 1`` for all elements in the array.
+    exp2  : Calculate ``2**x`` for all elements in the array.
+
+    Notes
+    -----
+    The irrational number ``e`` is also known as Euler's number.  It is
+    approximately 2.718281, and is the base of the natural logarithm,
+    ``ln`` (this means that, if :math:`x = \ln y = \log_e y`,
+    then :math:`e^x = y`. For real input, ``exp(x)`` is always positive.
+
+    For complex arguments, ``x = a + ib``, we can write
+    :math:`e^x = e^a e^{ib}`.  The first term, :math:`e^a`, is already
+    known (it is the real argument, described above).  The second term,
+    :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with
+    magnitude 1 and a periodic phase.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Exponential function",
+           http://en.wikipedia.org/wiki/Exponential_function
+    .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions
+           with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69,
+           http://www.math.sfu.ca/~cbm/aands/page_69.htm
+
+    Examples
+    --------
+    Plot the magnitude and phase of ``exp(x)`` in the complex plane:
+
+    >>> import maxframe.tensor as mt
+    >>> import matplotlib.pyplot as plt
+
+    >>> x = mt.linspace(-2*mt.pi, 2*mt.pi, 100)
+    >>> xx = x + 1j * x[:, mt.newaxis] # a + ib over complex plane
+    >>> out = mt.exp(xx)
+
+    >>> plt.subplot(121)
+    >>> plt.imshow(mt.abs(out).execute(),
+    ...            extent=[-2*mt.pi, 2*mt.pi, -2*mt.pi, 2*mt.pi], cmap='gray')
+    >>> plt.title('Magnitude of exp(x)')
+
+    >>> plt.subplot(122)
+    >>> plt.imshow(mt.angle(out).execute(),
+    ...            extent=[-2*mt.pi, 2*mt.pi, -2*mt.pi, 2*mt.pi], cmap='hsv')
+    >>> plt.title('Phase (angle) of exp(x)')
+    >>> plt.show()
+    """
+    op = TensorExp(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/exp2.py

@@ -0,0 +1,65 @@
+# 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 TensorExp2(TensorUnaryOp):
+    _op_type_ = opcodes.EXP2
+    _func_name = "exp2"
+
+
+@infer_dtype(np.exp2)
+def exp2(x, out=None, where=None, **kwargs):
+    """
+    Calculate `2**p` for all `p` in the input tensor.
+
+    Parameters
+    ----------
+    x : array_like
+        Input values.
+    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
+        Element-wise 2 to the power `x`.
+
+    See Also
+    --------
+    power
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.exp2([2, 3]).execute()
+    array([ 4.,  8.])
+    """
+    op = TensorExp2(**kwargs)
+    return op(x, out=out, where=where)