maxframe 0.1.0b5__cp310-cp310-macosx_11_0_arm64.whl

maxframe/tensor/__init__.py

@@ -0,0 +1,183 @@
+# 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.
+
+from . import fetch, random
+from .arithmetic import absolute
+from .arithmetic import absolute as abs
+from .arithmetic import (
+    add,
+    angle,
+    arccos,
+    arccosh,
+    arcsin,
+    arcsinh,
+    arctan,
+    arctan2,
+    arctanh,
+    around,
+)
+from .arithmetic import bitand as bitwise_and
+from .arithmetic import bitor as bitwise_or
+from .arithmetic import bitxor as bitwise_xor
+from .arithmetic import (
+    cbrt,
+    ceil,
+    clip,
+    conj,
+    conjugate,
+    copysign,
+    cos,
+    cosh,
+    deg2rad,
+    degrees,
+    divide,
+    equal,
+    exp,
+    exp2,
+    expm1,
+    fabs,
+    fix,
+    float_power,
+    floor,
+)
+from .arithmetic import floordiv as floor_divide
+from .arithmetic import fmax, fmin, fmod, frexp, greater, greater_equal, hypot, i0, imag
+from .arithmetic import invert
+from .arithmetic import invert as bitwise_not
+from .arithmetic import (
+    isclose,
+    iscomplex,
+    isfinite,
+    isinf,
+    isnan,
+    isreal,
+    ldexp,
+    less,
+    less_equal,
+    log,
+    log1p,
+    log2,
+    log10,
+    logaddexp,
+    logaddexp2,
+    logical_and,
+    logical_not,
+    logical_or,
+    logical_xor,
+)
+from .arithmetic import lshift as left_shift
+from .arithmetic import (
+    maximum,
+    minimum,
+    mod,
+    modf,
+    multiply,
+    nan_to_num,
+    negative,
+    nextafter,
+    not_equal,
+    positive,
+    power,
+    rad2deg,
+    radians,
+    real,
+    reciprocal,
+    remainder,
+    rint,
+)
+from .arithmetic import round_
+from .arithmetic import round_ as round
+from .arithmetic import rshift as right_shift
+from .arithmetic import (
+    sign,
+    signbit,
+    sin,
+    sinc,
+    sinh,
+    spacing,
+    sqrt,
+    square,
+    subtract,
+    tan,
+    tanh,
+)
+from .arithmetic import truediv as true_divide
+from .arithmetic import trunc
+from .base import broadcast_to, transpose, unique, where
+from .core import Tensor
+from .datasource import (
+    arange,
+    array,
+    asarray,
+    ascontiguousarray,
+    asfortranarray,
+    empty,
+    empty_like,
+    from_dataframe,
+    full,
+    full_like,
+    ones,
+    ones_like,
+    scalar,
+    tensor,
+    zeros,
+)
+from .indexing import (
+    choose,
+    compress,
+    extract,
+    fill_diagonal,
+    flatnonzero,
+    nonzero,
+    take,
+    unravel_index,
+)
+from .merge import stack
+from .rechunk import rechunk
+from .reduction import (
+    all,
+    allclose,
+    any,
+    argmax,
+    argmin,
+    array_equal,
+    count_nonzero,
+    cumprod,
+    cumsum,
+)
+from .reduction import max
+from .reduction import max as amax
+from .reduction import mean
+from .reduction import min
+from .reduction import min as amin
+from .reduction import (
+    nanargmax,
+    nanargmin,
+    nancumprod,
+    nancumsum,
+    nanmax,
+    nanmean,
+    nanmin,
+    nanprod,
+    nanstd,
+    nansum,
+    nanvar,
+)
+from .reduction import prod
+from .reduction import prod as product
+from .reduction import std, sum, var
+from .reshape import reshape
+from .ufunc import ufunc
+
+del fetch, ufunc

maxframe/tensor/arithmetic/__init__.py

@@ -0,0 +1,315 @@
+#!/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.
+
+from ...core import is_build_mode
+from .abs import TensorAbs, abs
+from .absolute import TensorAbsolute, absolute
+from .add import TensorAdd, add
+from .angle import TensorAngle, angle
+from .arccos import TensorArccos, arccos
+from .arccosh import TensorArccosh, arccosh
+from .arcsin import TensorArcsin, arcsin
+from .arcsinh import TensorArcsinh, arcsinh
+from .arctan import TensorArctan, arctan
+from .arctan2 import TensorArctan2, arctan2
+from .arctanh import TensorArctanh, arctanh
+from .around import TensorAround
+from .around import around
+from .around import around as round_
+from .bitand import TensorBitand, bitand
+from .bitor import TensorBitor, bitor
+from .bitxor import TensorBitxor, bitxor
+from .cbrt import TensorCbrt, cbrt
+from .ceil import TensorCeil, ceil
+from .clip import TensorClip, clip
+from .conj import TensorConj
+from .conj import conj
+from .conj import conj as conjugate
+from .copysign import TensorCopysign, copysign
+from .cos import TensorCos, cos
+from .cosh import TensorCosh, cosh
+from .deg2rad import TensorDeg2rad, deg2rad
+from .degrees import TensorDegrees, degrees
+from .divide import TensorDivide, divide
+from .equal import TensorEqual, equal
+from .exp import TensorExp, exp
+from .exp2 import TensorExp2, exp2
+from .expm1 import TensorExpm1, expm1
+from .fabs import TensorFabs, fabs
+from .fix import TensorFix, fix
+from .float_power import TensorFloatPower, float_power
+from .floor import TensorFloor, floor
+from .floordiv import TensorFloorDiv, floordiv
+from .fmax import TensorFMax, fmax
+from .fmin import TensorFMin, fmin
+from .fmod import TensorFMod, fmod
+from .frexp import TensorFrexp, frexp
+from .greater import TensorGreaterThan, greater
+from .greater_equal import TensorGreaterEqual, greater_equal
+from .hypot import TensorHypot, hypot
+from .i0 import TensorI0, i0
+from .imag import TensorImag, imag
+from .invert import TensorInvert, invert
+from .isclose import TensorIsclose, isclose
+from .iscomplex import TensorIsComplex, iscomplex
+from .isfinite import TensorIsFinite, isfinite
+from .isinf import TensorIsInf, isinf
+from .isnan import TensorIsNan, isnan
+from .isreal import TensorIsReal, isreal
+from .ldexp import TensorLdexp, ldexp
+from .less import TensorLessThan, less
+from .less_equal import TensorLessEqual, less_equal
+from .log import TensorLog, log
+from .log1p import TensorLog1p, log1p
+from .log2 import TensorLog2, log2
+from .log10 import TensorLog10, log10
+from .logaddexp import TensorLogAddExp, logaddexp
+from .logaddexp2 import TensorLogAddExp2, logaddexp2
+from .logical_and import TensorAnd, logical_and
+from .logical_not import TensorNot, logical_not
+from .logical_or import TensorOr, logical_or
+from .logical_xor import TensorXor, logical_xor
+from .lshift import TensorLshift, lshift
+from .maximum import TensorMaximum, maximum
+from .minimum import TensorMinimum, minimum
+from .mod import TensorMod
+from .mod import mod
+from .mod import mod as remainder
+from .modf import TensorModf, modf
+from .multiply import TensorMultiply, multiply
+from .nan_to_num import TensorNanToNum, nan_to_num
+from .negative import TensorNegative, negative
+from .nextafter import TensorNextafter, nextafter
+from .not_equal import TensorNotEqual, not_equal
+from .positive import TensorPositive, positive
+from .power import TensorPower, power
+from .rad2deg import TensorRad2deg, rad2deg
+from .radians import TensorRadians, radians
+from .real import TensorReal, real
+from .reciprocal import TensorReciprocal, reciprocal
+from .rint import TensorRint, rint
+from .rshift import TensorRshift, rshift
+from .setimag import TensorSetImag
+from .setreal import TensorSetReal
+from .sign import TensorSign, sign
+from .signbit import TensorSignbit, signbit
+from .sin import TensorSin, sin
+from .sinc import TensorSinc, sinc
+from .sinh import TensorSinh, sinh
+from .spacing import TensorSpacing, spacing
+from .sqrt import TensorSqrt, sqrt
+from .square import TensorSquare, square
+from .subtract import TensorSubtract, subtract
+from .tan import TensorTan, tan
+from .tanh import TensorTanh, tanh
+from .truediv import TensorTrueDiv, truediv
+from .trunc import TensorTrunc, trunc
+
+
+def _wrap_iop(func):
+    def inner(self, *args, **kwargs):
+        kwargs["out"] = self
+        return func(self, *args, **kwargs)
+
+    return inner
+
+
+def _install():
+    from ..core import TENSOR_TYPE, Tensor, TensorData
+    from ..datasource import tensor as astensor
+    from .add import add, radd
+    from .bitand import bitand, rbitand
+    from .bitor import bitor, rbitor
+    from .bitxor import bitxor, rbitxor
+    from .divide import divide, rdivide
+    from .floordiv import floordiv, rfloordiv
+    from .lshift import lshift, rlshift
+    from .mod import mod, rmod
+    from .multiply import multiply, rmultiply
+    from .power import power, rpower
+    from .rshift import rrshift, rshift
+    from .subtract import rsubtract, subtract
+    from .truediv import rtruediv, truediv
+
+    def _wrap_equal(func):
+        def eq(x1, x2, **kwargs):
+            if is_build_mode():
+                return astensor(x1)._equals(x2)
+            return func(x1, x2, **kwargs)
+
+        return eq
+
+    for cls in TENSOR_TYPE:
+        setattr(cls, "__add__", add)
+        setattr(cls, "__iadd__", _wrap_iop(add))
+        setattr(cls, "__radd__", radd)
+        setattr(cls, "__sub__", subtract)
+        setattr(cls, "__isub__", _wrap_iop(subtract))
+        setattr(cls, "__rsub__", rsubtract)
+        setattr(cls, "__mul__", multiply)
+        setattr(cls, "__imul__", _wrap_iop(multiply))
+        setattr(cls, "__rmul__", rmultiply)
+        setattr(cls, "__div__", divide)
+        setattr(cls, "__idiv__", _wrap_iop(divide))
+        setattr(cls, "__rdiv__", rdivide)
+        setattr(cls, "__truediv__", truediv)
+        setattr(cls, "__itruediv__", _wrap_iop(truediv))
+        setattr(cls, "__rtruediv__", rtruediv)
+        setattr(cls, "__floordiv__", floordiv)
+        setattr(cls, "__ifloordiv__", _wrap_iop(floordiv))
+        setattr(cls, "__rfloordiv__", rfloordiv)
+        setattr(cls, "__pow__", power)
+        setattr(cls, "__ipow__", _wrap_iop(power))
+        setattr(cls, "__rpow__", rpower)
+        setattr(cls, "__mod__", mod)
+        setattr(cls, "__imod__", _wrap_iop(mod))
+        setattr(cls, "__rmod__", rmod)
+        setattr(cls, "__lshift__", lshift)
+        setattr(cls, "__ilshift__", _wrap_iop(lshift))
+        setattr(cls, "__rlshift__", rlshift)
+        setattr(cls, "__rshift__", rshift)
+        setattr(cls, "__irshift__", _wrap_iop(rshift))
+        setattr(cls, "__rrshift__", rrshift)
+
+        setattr(cls, "__eq__", _wrap_equal(equal))
+        setattr(cls, "__ne__", not_equal)
+        setattr(cls, "__lt__", less)
+        setattr(cls, "__le__", less_equal)
+        setattr(cls, "__gt__", greater)
+        setattr(cls, "__ge__", greater_equal)
+        setattr(cls, "__and__", bitand)
+        setattr(cls, "__iand__", _wrap_iop(bitand))
+        setattr(cls, "__rand__", rbitand)
+        setattr(cls, "__or__", bitor)
+        setattr(cls, "__ior__", _wrap_iop(bitor))
+        setattr(cls, "__ror__", rbitor)
+        setattr(cls, "__xor__", bitxor)
+        setattr(cls, "__ixor__", _wrap_iop(bitxor))
+        setattr(cls, "__rxor__", rbitxor)
+
+        setattr(cls, "__neg__", negative)
+        setattr(cls, "__pos__", positive)
+        setattr(cls, "__abs__", abs)
+        setattr(cls, "__invert__", invert)
+
+    setattr(Tensor, "round", round_)
+    setattr(Tensor, "conj", conj)
+    setattr(Tensor, "conjugate", conjugate)
+    setattr(TensorData, "round", round_)
+    setattr(TensorData, "conj", conj)
+    setattr(TensorData, "conjugate", conjugate)
+
+
+_install()
+del _install
+
+
+BIN_UFUNC = {
+    add,
+    subtract,
+    multiply,
+    divide,
+    truediv,
+    floordiv,
+    power,
+    mod,
+    fmod,
+    logaddexp,
+    logaddexp2,
+    equal,
+    not_equal,
+    less,
+    less_equal,
+    greater,
+    greater_equal,
+    arctan2,
+    hypot,
+    bitand,
+    bitor,
+    bitxor,
+    lshift,
+    rshift,
+    logical_and,
+    logical_or,
+    logical_xor,
+    maximum,
+    minimum,
+    float_power,
+    remainder,
+    fmax,
+    fmin,
+    copysign,
+    nextafter,
+    ldexp,
+}
+
+UNARY_UFUNC = {
+    square,
+    arcsinh,
+    rint,
+    sign,
+    conj,
+    tan,
+    absolute,
+    deg2rad,
+    log,
+    fabs,
+    exp2,
+    invert,
+    negative,
+    sqrt,
+    arctan,
+    positive,
+    cbrt,
+    log10,
+    sin,
+    rad2deg,
+    log2,
+    arcsin,
+    expm1,
+    arctanh,
+    cosh,
+    sinh,
+    cos,
+    reciprocal,
+    tanh,
+    log1p,
+    exp,
+    arccos,
+    arccosh,
+    around,
+    logical_not,
+    conjugate,
+    isfinite,
+    isinf,
+    isnan,
+    signbit,
+    spacing,
+    floor,
+    ceil,
+    trunc,
+    degrees,
+    radians,
+    angle,
+    isreal,
+    iscomplex,
+    real,
+    imag,
+    fix,
+    i0,
+    sinc,
+    nan_to_num,
+}

maxframe/tensor/arithmetic/abs.py

@@ -0,0 +1,68 @@
+#!/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 TensorAbs(TensorUnaryOp):
+    _op_type_ = opcodes.ABS
+    _func_name = "abs"
+
+
+@infer_dtype(np.abs)
+def abs(x, out=None, where=None, **kwargs):
+    r"""
+    Calculate the absolute value 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
+    -------
+    absolute : Tensor
+        An tensor containing the absolute value of
+        each element in `x`.  For complex input, ``a + ib``, the
+        absolute value is :math:`\sqrt{ a^2 + b^2 }`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([-1.2, 1.2])
+    >>> mt.absolute(x).execute()
+    array([ 1.2,  1.2])
+    >>> mt.absolute(1.2 + 1j).execute()
+    1.5620499351813308
+    """
+    op = TensorAbs(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/absolute.py

@@ -0,0 +1,68 @@
+#!/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 TensorAbsolute(TensorUnaryOp):
+    _op_type_ = opcodes.ABSOLUTE
+    _func_name = "absolute"
+
+
+@infer_dtype(np.absolute)
+def absolute(x, out=None, where=None, **kwargs):
+    r"""
+    Calculate the absolute value 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
+    -------
+    absolute : Tensor
+        An tensor containing the absolute value of
+        each element in `x`.  For complex input, ``a + ib``, the
+        absolute value is :math:`\sqrt{ a^2 + b^2 }`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([-1.2, 1.2])
+    >>> mt.absolute(x).execute()
+    array([ 1.2,  1.2])
+    >>> mt.absolute(1.2 + 1j).execute()
+    1.5620499351813308
+    """
+    op = TensorAbsolute(**kwargs)
+    return op(x, out=out, where=where)

maxframe/tensor/arithmetic/add.py

@@ -0,0 +1,82 @@
+#!/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_and")
+class TensorAdd(TensorBinOp):
+    _op_type_ = opcodes.ADD
+    _func_name = "add"
+
+
+@infer_dtype(np.add)
+def add(x1, x2, out=None, where=None, **kwargs):
+    """
+    Add arguments element-wise.
+
+    Parameters
+    ----------
+    x1, x2 : array_like
+        The tensors to be added.  If ``x1.shape != x2.shape``, they must be
+        broadcastable to a common shape (which may be the shape of one or
+        the 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
+    -------
+    add : Tensor or scalar
+        The sum 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.add(1.0, 4.0).execute()
+    5.0
+    >>> x1 = mt.arange(9.0).reshape((3, 3))
+    >>> x2 = mt.arange(3.0)
+    >>> mt.add(x1, x2).execute()
+    array([[  0.,   2.,   4.],
+           [  3.,   5.,   7.],
+           [  6.,   8.,  10.]])
+    """
+    op = TensorAdd(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
+
+@infer_dtype(np.add, reverse=True)
+def radd(x1, x2, **kwargs):
+    op = TensorAdd(**kwargs)
+    return op.rcall(x1, x2)