maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/arithmetic/signbit.py

@@ -0,0 +1,63 @@
+# 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 TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="unary")
+class TensorSignbit(TensorUnaryOp):
+    _op_type_ = opcodes.SIGNBIT
+    _func_name = "signbit"
+
+
+@inject_dtype(np.bool_)
+def signbit(x, out=None, where=None, **kwargs):
+    """
+    Returns element-wise True where signbit is set (less than zero).
+
+    Parameters
+    ----------
+    x : array_like
+        The input value(s).
+    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
+    -------
+    result : Tensor of bool
+        Output tensor, or reference to `out` if that was supplied.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.signbit(-1.2).execute()
+    True
+    >>> mt.signbit(mt.array([1, -2.3, 2.1])).execute()
+    array([False,  True, False])
+    """
+    op = TensorSignbit(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/sin.py

@@ -0,0 +1,96 @@
+# 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 TensorSin(TensorUnaryOp):
+    _op_type_ = opcodes.SIN
+    _func_name = "sin"
+
+
+@infer_dtype(np.sin)
+def sin(x, out=None, where=None, **kwargs):
+    r"""
+    Trigonometric sine, element-wise.
+
+    Parameters
+    ----------
+    x : array_like
+        Angle, in radians (:math:`2 \pi` rad equals 360 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 : array_like
+        The sine of each element of x.
+
+    See Also
+    --------
+    arcsin, sinh, cos
+
+    Notes
+    -----
+    The sine is one of the fundamental functions of trigonometry (the
+    mathematical study of triangles).  Consider a circle of radius 1
+    centered on the origin.  A ray comes in from the :math:`+x` axis, makes
+    an angle at the origin (measured counter-clockwise from that axis), and
+    departs from the origin.  The :math:`y` coordinate of the outgoing
+    ray's intersection with the unit circle is the sine of that angle.  It
+    ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.`  The
+    function has zeroes where the angle is a multiple of :math:`\pi`.
+    Sines of angles between :math:`\pi` and :math:`2\pi` are negative.
+    The numerous properties of the sine and related functions are included
+    in any standard trigonometry text.
+
+    Examples
+    --------
+    Print sine of one angle:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.sin(mt.pi/2.).execute()
+    1.0
+
+    Print sines of an array of angles given in degrees:
+
+    >>> mt.sin(mt.array((0., 30., 45., 60., 90.)) * mt.pi / 180. ).execute()
+    array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])
+
+    Plot the sine function:
+
+    >>> import matplotlib.pylab as plt
+    >>> x = mt.linspace(-mt.pi, mt.pi, 201)
+    >>> plt.plot(x.execute(), mt.sin(x).execute())
+    >>> plt.xlabel('Angle [rad]')
+    >>> plt.ylabel('sin(x)')
+    >>> plt.axis('tight')
+    >>> plt.show()
+    """
+    op = TensorSin(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/sinc.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 TensorUnaryOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="always_false")
+class TensorSinc(TensorUnaryOp):
+    _op_type_ = opcodes.SINC
+    _func_name = "sinc"
+
+
+@infer_dtype(np.sinc)
+def sinc(x, **kwargs):
+    r"""
+    Return the sinc function.
+
+    The sinc function is :math:`\\sin(\\pi x)/(\\pi x)`.
+
+    Parameters
+    ----------
+    x : Tensor
+        Tensor (possibly multi-dimensional) of values for which to to
+        calculate ``sinc(x)``.
+
+    Returns
+    -------
+    out : Tensor
+        ``sinc(x)``, which has the same shape as the input.
+
+    Notes
+    -----
+    ``sinc(0)`` is the limit value 1.
+
+    The name sinc is short for "sine cardinal" or "sinus cardinalis".
+
+    The sinc function is used in various signal processing applications,
+    including in anti-aliasing, in the construction of a Lanczos resampling
+    filter, and in interpolation.
+
+    For bandlimited interpolation of discrete-time signals, the ideal
+    interpolation kernel is proportional to the sinc function.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web
+           Resource. http://mathworld.wolfram.com/SincFunction.html
+    .. [2] Wikipedia, "Sinc function",
+           http://en.wikipedia.org/wiki/Sinc_function
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.linspace(-4, 4, 41)
+    >>> mt.sinc(x).execute()
+    array([ -3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02,
+            -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
+             6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
+             8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
+            -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
+             3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
+             7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
+             9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
+             2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
+            -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
+            -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
+             1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
+            -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
+            -4.92362781e-02,  -3.89804309e-17])
+
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(x.execute(), np.sinc(x).execute())
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title("Sinc Function")
+    <matplotlib.text.Text object at 0x...>
+    >>> plt.ylabel("Amplitude")
+    <matplotlib.text.Text object at 0x...>
+    >>> plt.xlabel("X")
+    <matplotlib.text.Text object at 0x...>
+    >>> plt.show()
+    """
+    op = TensorSinc(**kwargs)
+    return op(x)

maxframe/tensor/arithmetic/sinh.py

@@ -0,0 +1,91 @@
+# 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 TensorSinh(TensorUnaryOp):
+    _op_type_ = opcodes.SINH
+    _func_name = "sinh"
+
+
+@infer_dtype(np.sinh)
+def sinh(x, out=None, where=None, **kwargs):
+    """
+    Hyperbolic sine, element-wise.
+
+    Equivalent to ``1/2 * (mt.exp(x) - mt.exp(-x))`` or
+    ``-1j * mt.sin(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
+    -------
+    y : Tensor
+        The corresponding hyperbolic sine 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, pg. 83.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.sinh(0).execute()
+    0.0
+    >>> mt.sinh(mt.pi*1j/2).execute()
+    1j
+    >>> mt.sinh(mt.pi*1j).execute() # (exact value is 0)
+    1.2246063538223773e-016j
+    >>> # Discrepancy due to vagaries of floating point arithmetic.
+
+    >>> # Example of providing the optional output parameter
+    >>> out1 = mt.zeros(1)
+    >>> out2 = mt.sinh([0.1], out1)
+    >>> out2 is out1
+    True
+
+    >>> # Example of ValueError due to provision of shape mis-matched `out`
+    >>> mt.sinh(mt.zeros((3,3)),mt.zeros((2,2))).execute()
+    Traceback (most recent call last):
+    ...
+    ValueError:  operators could not be broadcast together with shapes (3,3) (2,2)
+    """
+    op = TensorSinh(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/spacing.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="always_false")
+class TensorSpacing(TensorUnaryOp):
+    _op_type_ = opcodes.SPACING
+    _func_name = "spacing"
+
+
+@infer_dtype(np.spacing)
+def spacing(x, out=None, where=None, **kwargs):
+    """
+    Return the distance between x and the nearest adjacent number.
+
+    Parameters
+    ----------
+    x : array_like
+        Values to find the spacing of.
+    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
+        The spacing of values of `x1`.
+
+    Notes
+    -----
+    It can be considered as a generalization of EPS:
+    ``spacing(mt.float64(1)) == mt.finfo(mt.float64).eps``, and there
+    should not be any representable number between ``x + spacing(x)`` and
+    x for any finite x.
+
+    Spacing of +- inf and NaN is NaN.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> (mt.spacing(1) == mt.finfo(mt.float64).eps).execute()
+    True
+    """
+    op = TensorSpacing(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/sqrt.py

@@ -0,0 +1,79 @@
+# 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 TensorSqrt(TensorUnaryOp):
+    _op_type_ = opcodes.SQRT
+    _func_name = "sqrt"
+
+
+@infer_dtype(np.sqrt)
+def sqrt(x, out=None, where=None, **kwargs):
+    """
+    Return the positive square-root of an tensor, element-wise.
+
+    Parameters
+    ----------
+    x : array_like
+        The values whose square-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 positive
+        square-root of each element in `x`.  If any element in `x` is
+        complex, a complex tensor is returned (and the square-roots of
+        negative reals are calculated).  If all of the elements in `x`
+        are real, so is `y`, with negative elements returning ``nan``.
+        If `out` was provided, `y` is a reference to it.
+
+    Notes
+    -----
+    *sqrt* has--consistent with common convention--as its branch cut the
+    real "interval" [`-inf`, 0), and is continuous from above on it.
+    A branch cut is a curve in the complex plane across which a given
+    complex function fails to be continuous.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.sqrt([1,4,9]).execute()
+    array([ 1.,  2.,  3.])
+
+    >>> mt.sqrt([4, -1, -3+4J]).execute()
+    array([ 2.+0.j,  0.+1.j,  1.+2.j])
+
+    >>> mt.sqrt([4, -1, mt.inf]).execute()
+    array([  2.,  NaN,  Inf])
+    """
+    op = TensorSqrt(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/square.py

@@ -0,0 +1,67 @@
+# 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 TensorSquare(TensorUnaryOp):
+    _op_type_ = opcodes.SQUARE
+    _func_name = "square"
+
+
+@infer_dtype(np.square)
+def square(x, out=None, where=None, **kwargs):
+    """
+    Return the element-wise square of the input.
+
+    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 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
+        Element-wise `x*x`, of the same shape and dtype as `x`.
+        Returns scalar if `x` is a scalar.
+
+    See Also
+    --------
+    sqrt
+    power
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.square([-1j, 1]).execute()
+    array([-1.-0.j,  1.+0.j])
+    """
+    op = TensorSquare(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/subtract.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 TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorSubtract(TensorBinOp):
+    _op_type_ = opcodes.SUB
+    _func_name = "subtract"
+
+    @classmethod
+    def _is_sparse_with_scalar(cls, scalar_val, lhs):
+        return isinstance(scalar_val, (int, float)) and scalar_val == 0
+
+
+@infer_dtype(np.subtract)
+def subtract(x1, x2, out=None, where=None, **kwargs):
+    """
+    Subtract arguments, element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        The tensors to be subtracted from each other.
+    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 difference of `x1` and `x2`, element-wise.  Returns a scalar if
+        both  `x1` and `x2` are scalars.
+
+    Notes
+    -----
+    Equivalent to ``x1 - x2`` in terms of tensor broadcasting.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.subtract(1.0, 4.0).execute()
+    -3.0
+
+    >>> x1 = mt.arange(9.0).reshape((3, 3))
+    >>> x2 = mt.arange(3.0)
+    >>> mt.subtract(x1, x2).execute()
+    array([[ 0.,  0.,  0.],
+           [ 3.,  3.,  3.],
+           [ 6.,  6.,  6.]])
+    """
+    op = TensorSubtract(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.subtract, reverse=True)
+def rsubtract(x1, x2, **kwargs):
+    op = TensorSubtract(**kwargs)
+    return op.rcall(x1, x2)