maxframe 0.1.0b5__cp38-cp38-macosx_11_0_arm64.whl

maxframe/tensor/arithmetic/fix.py

@@ -0,0 +1,69 @@
+#!/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 TensorFix(TensorUnaryOp):
+    _op_type_ = opcodes.FIX
+    _func_name = "fix"
+
+
+@infer_dtype(np.fix)
+def fix(x, out=None, **kwargs):
+    """
+    Round to nearest integer towards zero.
+
+    Round a tensor of floats element-wise to nearest integer towards zero.
+    The rounded values are returned as floats.
+
+    Parameters
+    ----------
+    x   : array_like
+        An tensor of floats to be rounded
+    out : Tensor, optional
+        Output tensor
+
+    Returns
+    -------
+    out : Tensor of floats
+        The array of rounded numbers
+
+    See Also
+    --------
+    trunc, floor, ceil
+    around : Round to given number of decimals
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.fix(3.14).execute()
+    3.0
+    >>> mt.fix(3).execute()
+    3.0
+    >>> mt.fix([2.1, 2.9, -2.1, -2.9]).execute()
+    array([ 2.,  2., -2., -2.])
+
+    """
+    op = TensorFix(**kwargs)
+    return op(x, out=out)

maxframe/tensor/arithmetic/float_power.py

@@ -0,0 +1,103 @@
+#!/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 inject_dtype
+from .core import TensorBinOp
+from .utils import arithmetic_operator
+
+
+@arithmetic_operator
+class TensorFloatPower(TensorBinOp):
+    _op_type_ = opcodes.FLOAT_POWER
+    _func_name = "float_power"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse():
+            return True
+        return False
+
+
+@inject_dtype(np.float64)
+def float_power(x1, x2, out=None, where=None, **kwargs):
+    """
+    First tensor elements raised to powers from second array, element-wise.
+
+    Raise each base in `x1` to the positionally-corresponding power in `x2`.
+    `x1` and `x2` must be broadcastable to the same shape. This differs from
+    the power function in that integers, float16, and float32  are promoted to
+    floats with a minimum precision of float64 so that the result is always
+    inexact.  The intent is that the function will return a usable result for
+    negative powers and seldom overflow for positive powers.
+
+    Parameters
+    ----------
+    x1 : array_like
+        The bases.
+    x2 : array_like
+        The exponents.
+    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 bases in `x1` raised to the exponents in `x2`.
+
+    See Also
+    --------
+    power : power function that preserves type
+
+    Examples
+    --------
+    Cube each element in a list.
+
+    >>> import maxframe.tensor as mt
+
+    >>> x1 = range(6)
+    >>> x1
+    [0, 1, 2, 3, 4, 5]
+    >>> mt.float_power(x1, 3).execute()
+    array([   0.,    1.,    8.,   27.,   64.,  125.])
+
+    Raise the bases to different exponents.
+
+    >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
+    >>> mt.float_power(x1, x2).execute()
+    array([  0.,   1.,   8.,  27.,  16.,   5.])
+
+    The effect of broadcasting.
+
+    >>> x2 = mt.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
+    >>> x2.execute()
+    array([[1, 2, 3, 3, 2, 1],
+           [1, 2, 3, 3, 2, 1]])
+    >>> mt.float_power(x1, x2).execute()
+    array([[  0.,   1.,   8.,  27.,  16.,   5.],
+           [  0.,   1.,   8.,  27.,  16.,   5.]])
+    """
+    op = TensorFloatPower(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/floor.py

@@ -0,0 +1,77 @@
+#!/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 TensorFloor(TensorUnaryOp):
+    _op_type_ = opcodes.FLOOR
+    _func_name = "floor"
+
+
+@infer_dtype(np.floor)
+def floor(x, out=None, where=None, **kwargs):
+    r"""
+    Return the floor of the input, element-wise.
+
+    The floor of the scalar `x` is the largest integer `i`, such that
+    `i <= x`.  It is often denoted as :math:`\lfloor x \rfloor`.
+
+    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 floor of each element in `x`.
+
+    See Also
+    --------
+    ceil, trunc, rint
+
+    Notes
+    -----
+    Some spreadsheet programs calculate the "floor-towards-zero", in other
+    words ``floor(-2.5) == -2``.  NumPy instead uses the definition of
+    `floor` where `floor(-2.5) == -3`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+    >>> mt.floor(a).execute()
+    array([-2., -2., -1.,  0.,  1.,  1.,  2.])
+    """
+    op = TensorFloor(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/floordiv.py

@@ -0,0 +1,94 @@
+#!/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
+class TensorFloorDiv(TensorBinOp):
+    _op_type_ = opcodes.FLOORDIV
+    _func_name = "floor_divide"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse():
+            if x2 != 0:
+                return True
+            else:
+                raise ZeroDivisionError("float division by zero")
+        return False
+
+
+@infer_dtype(np.floor_divide)
+def floordiv(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return the largest integer smaller or equal to the division of the inputs.
+    It is equivalent to the Python ``//`` operator and pairs with the
+    Python ``%`` (`remainder`), function so that ``b = a % b + b * (a // b)``
+    up to roundoff.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Numerator.
+    x2 : array_like
+        Denominator.
+    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
+        y = floor(`x1`/`x2`)
+
+
+    See Also
+    --------
+    remainder : Remainder complementary to floor_divide.
+    divmod : Simultaneous floor division and remainder.
+    divide : Standard division.
+    floor : Round a number to the nearest integer toward minus infinity.
+    ceil : Round a number to the nearest integer toward infinity.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.floor_divide(7,3).execute()
+    2
+    >>> mt.floor_divide([1., 2., 3., 4.], 2.5).execute()
+    array([ 0.,  0.,  1.,  1.])
+    """
+    op = TensorFloorDiv(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.floor_divide, reverse=True)
+def rfloordiv(x1, x2, **kwargs):
+    op = TensorFloorDiv(**kwargs)
+    return op.rcall(x1, x2)

maxframe/tensor/arithmetic/fmax.py

@@ -0,0 +1,105 @@
+#!/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
+class TensorFMax(TensorBinOp):
+    _op_type_ = opcodes.FMAX
+    _func_name = "fmax"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse() and np.isscalar(x2) and x2 <= 0:
+            return True
+        if hasattr(x2, "issparse") and x2.issparse() and np.isscalar(x1) and x1 <= 0:
+            return True
+        return False
+
+
+@infer_dtype(np.fmax)
+def fmax(x1, x2, out=None, where=None, **kwargs):
+    """
+    Element-wise maximum of array elements.
+
+    Compare two tensors and returns a new tensor containing the element-wise
+    maxima. If one of the elements being compared is a NaN, then the
+    non-nan element is returned. If both elements are NaNs then the first
+    is returned.  The latter distinction is important for complex NaNs,
+    which are defined as at least one of the real or imaginary parts being
+    a NaN. The net effect is that NaNs are ignored when possible.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        The tensors holding the elements to be compared. They must have
+        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 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 maximum of `x1` and `x2`, element-wise.  Returns scalar if
+        both  `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    fmin :
+        Element-wise minimum of two tensors, ignores NaNs.
+    maximum :
+        Element-wise maximum of two tensors, propagates NaNs.
+    amax :
+        The maximum value of an tensor along a given axis, propagates NaNs.
+    nanmax :
+        The maximum value of an tensor along a given axis, ignores NaNs.
+
+    minimum, amin, nanmin
+
+    Notes
+    -----
+    The fmax is equivalent to ``mt.where(x1 >= x2, x1, x2)`` when neither
+    x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.fmax([2, 3, 4], [1, 5, 2]).execute()
+    array([ 2.,  5.,  4.])
+
+    >>> mt.fmax(mt.eye(2), [0.5, 2]).execute()
+    array([[ 1. ,  2. ],
+           [ 0.5,  2. ]])
+
+    >>> mt.fmax([mt.nan, 0, mt.nan],[0, mt.nan, mt.nan]).execute()
+    array([  0.,   0.,  NaN])
+    """
+    op = TensorFMax(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/fmin.py

@@ -0,0 +1,106 @@
+#!/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
+class TensorFMin(TensorBinOp):
+    _op_type_ = opcodes.FMIN
+    _func_name = "fmin"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse() and np.isscalar(x2) and x2 >= 0:
+            return True
+        if hasattr(x2, "issparse") and x2.issparse() and np.isscalar(x1) and x1 >= 0:
+            return True
+        return False
+
+
+@infer_dtype(np.fmin)
+def fmin(x1, x2, out=None, where=None, **kwargs):
+    """
+    Element-wise minimum of array elements.
+
+    Compare two tensors and returns a new tensor containing the element-wise
+    minima. If one of the elements being compared is a NaN, then the
+    non-nan element is returned. If both elements are NaNs then the first
+    is returned.  The latter distinction is important for complex NaNs,
+    which are defined as at least one of the real or imaginary parts being
+    a NaN. The net effect is that NaNs are ignored when possible.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        The tensors holding the elements to be compared. They must have
+        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 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 minimum of `x1` and `x2`, element-wise.  Returns scalar if
+        both  `x1` and `x2` are scalars.
+
+    See Also
+    --------
+    fmax :
+        Element-wise maximum of two tensors, ignores NaNs.
+    minimum :
+        Element-wise minimum of two tensors, propagates NaNs.
+    amin :
+        The minimum value of a tensor along a given axis, propagates NaNs.
+    nanmin :
+        The minimum value of a tensor along a given axis, ignores NaNs.
+
+    maximum, amax, nanmax
+
+    Notes
+    -----
+
+    The fmin is equivalent to ``mt.where(x1 <= x2, x1, x2)`` when neither
+    x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.fmin([2, 3, 4], [1, 5, 2]).execute()
+    array([1, 3, 2])
+
+    >>> mt.fmin(mt.eye(2), [0.5, 2]).execute()
+    array([[ 0.5,  0. ],
+           [ 0. ,  1. ]])
+
+    >>> mt.fmin([mt.nan, 0, mt.nan],[0, mt.nan, mt.nan]).execute()
+    array([  0.,   0.,  NaN])
+    """
+    op = TensorFMin(**kwargs)
+    return op(x1, x2, out=out, where=where)

maxframe/tensor/arithmetic/fmod.py

@@ -0,0 +1,99 @@
+#!/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 TensorFMod(TensorBinOp):
+    _op_type_ = opcodes.FMOD
+    _func_name = "fmod"
+
+
+@infer_dtype(np.fmod)
+def fmod(x1, x2, out=None, where=None, **kwargs):
+    """
+    Return the element-wise remainder of division.
+
+    This is the NumPy implementation of the C library function fmod, the
+    remainder has the same sign as the dividend `x1`. It is equivalent to
+    the Matlab(TM) ``rem`` function and should not be confused with the
+    Python modulus operator ``x1 % x2``.
+
+    Parameters
+    ----------
+    x1 : array_like
+      Dividend.
+    x2 : array_like
+      Divisor.
+    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
+    -------
+    y : Tensor_like
+      The remainder of the division of `x1` by `x2`.
+
+    See Also
+    --------
+    remainder : Equivalent to the Python ``%`` operator.
+    divide
+
+    Notes
+    -----
+    The result of the modulo operation for negative dividend and divisors
+    is bound by conventions. For `fmod`, the sign of result is the sign of
+    the dividend, while for `remainder` the sign of the result is the sign
+    of the divisor. The `fmod` function is equivalent to the Matlab(TM)
+    ``rem`` function.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.fmod([-3, -2, -1, 1, 2, 3], 2).execute()
+    array([-1,  0, -1,  1,  0,  1])
+    >>> mt.remainder([-3, -2, -1, 1, 2, 3], 2).execute()
+    array([1, 0, 1, 1, 0, 1])
+
+    >>> mt.fmod([5, 3], [2, 2.]).execute()
+    array([ 1.,  1.])
+    >>> a = mt.arange(-3, 3).reshape(3, 2)
+    >>> a.execute()
+    array([[-3, -2],
+           [-1,  0],
+           [ 1,  2]])
+    >>> mt.fmod(a, [2,2]).execute()
+    array([[-1,  0],
+           [-1,  0],
+           [ 1,  0]])
+    """
+    op = TensorFMod(**kwargs)
+    return op(x1, x2, out=out, where=where)