maxframe 1.3.1__cp38-cp38-win32.whl → 2.0.0b2__cp38-cp38-win32.whl

maxframe/tensor/linalg/lu.py

@@ -0,0 +1,115 @@
+# 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 numpy.linalg import LinAlgError
+
+from ... import opcodes
+from ...core import ExecutableTuple
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorLU(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.LU
+
+    @property
+    def output_limit(self):
+        return 3
+
+    def __call__(self, a):
+        import scipy.linalg
+
+        a = astensor(a)
+        if a.ndim != 2:
+            raise LinAlgError(
+                f"{a.ndim}-dimensional array given. Tensor must be two-dimensional"
+            )
+
+        if a.shape[0] > a.shape[1]:
+            p_shape = (a.shape[0],) * 2
+            l_shape = a.shape
+            u_shape = (a.shape[1],) * 2
+        elif a.shape[0] < a.shape[1]:
+            p_shape = (a.shape[0],) * 2
+            l_shape = (a.shape[0],) * 2
+            u_shape = a.shape
+        else:
+            p_shape, l_shape, u_shape = (a.shape,) * 3
+
+        tiny_p, tiny_l, tiny_u = scipy.linalg.lu(
+            np.array([[1, 2], [2, 5]], dtype=a.dtype)
+        )
+
+        order = a.order
+        p, l, u = self.new_tensors(
+            [a],
+            kws=[
+                {"side": "p", "dtype": tiny_p.dtype, "shape": p_shape, "order": order},
+                {"side": "l", "dtype": tiny_l.dtype, "shape": l_shape, "order": order},
+                {"side": "u", "dtype": tiny_u.dtype, "shape": u_shape, "order": order},
+            ],
+        )
+        return ExecutableTuple([p, l, u])
+
+
+def lu(a):
+    """
+    LU decomposition
+
+    The decomposition is::
+        A = P L U
+    where P is a permutation matrix, L lower triangular with unit diagonal elements,
+    and U upper triangular.
+
+    Parameters
+    ----------
+    a : (M, N) array_like
+        Array to decompose
+
+    Returns
+    -------
+    p : (M, M) ndarray
+        Permutation matrix
+    l : (M, K) ndarray
+        Lower triangular or trapezoidal matrix with unit diagonal.
+        K = min(M, N)
+    u : (K, N) ndarray
+        Upper triangular or trapezoidal matrix
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> A = mt.array([[1,2],[2,3]])
+    >>> A.execute()
+    array([[ 1,  2],
+           [ 2,  3]])
+    >>> P, L, U = mt.linalg.lu(A)
+    >>> P.execute()
+    array([[ 0,  1],
+           [ 1,  0]])
+    >>> L.execute()
+    array([[ 1,  0],
+           [ 0.5,  1]])
+    >>> U.execute()
+    array([[ 2,  3],
+           [ 0,  0.5]])
+    >>> mt.dot(P.dot(L), U).execute() # verify that PL * U = A
+    array([[ 1,  2],
+           [ 2,  3]])
+
+    """
+    op = TensorLU(sparse=a.issparse())
+    return op(a)

maxframe/tensor/linalg/matmul.py

@@ -0,0 +1,225 @@
+# 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.
+
+from typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import KeyField, StringField
+from ..core import Tensor, TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+from ..utils import broadcast_shape, check_order, check_out_param
+
+
+class TensorMatmul(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.MATMUL
+
+    a = KeyField("a")
+    b = KeyField("b")
+    casting = StringField("casting", default="same_kind")
+    order = StringField("order", default="K")
+
+    def __init__(self, **kw):
+        super().__init__(**kw)
+        check_order(self.order)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorMatmul", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.a = op._inputs[0]
+        op.b = op._inputs[1]
+
+    def _calc_order(self, a, b, out):
+        if out is not None:
+            return out.order
+
+        if self.order in "A":
+            if a.order == TensorOrder.C_ORDER or b.order == TensorOrder.C_ORDER:
+                return TensorOrder.C_ORDER
+            else:
+                return TensorOrder.F_ORDER
+        elif self.order in "CK":
+            return TensorOrder.C_ORDER
+        else:
+            return TensorOrder.F_ORDER
+
+    def __call__(self, a, b, out=None):
+        from ..misc import broadcast_to
+
+        if a.ndim == 0 or b.ndim == 0:
+            raise ValueError("Scalar operands are not allowed, use '*' instead")
+        if out is not None and not isinstance(out, Tensor):
+            raise TypeError(f"out must be a Tensor, got {type(out)} instead")
+
+        a_is_1d = False
+        if a.ndim == 1:
+            a_is_1d = True
+            a = a[np.newaxis, :]
+
+        b_is_1d = False
+        if b.ndim == 1:
+            b_is_1d = True
+            b = b[:, np.newaxis]
+
+        if a.ndim < b.ndim:
+            a = a[(b.ndim - a.ndim) * (np.newaxis,)]
+        elif a.ndim > b.ndim:
+            b = b[(a.ndim - b.ndim) * (np.newaxis,)]
+
+        if a.shape[-1] != b.shape[-2]:
+            raise ValueError(
+                f"shape {a.shape} and {b.shape} not aligned: "
+                f"{a.shape[-1]} (dim {a.ndim - 1}) != {b.shape[-2]} (dim {b.ndim - 2})"
+            )
+
+        shape = broadcast_shape(a.shape[:-2], b.shape[:-2]) + (a.shape[-2], b.shape[-1])
+        order = self._calc_order(a, b, out)
+        t = self.new_tensor([a, b], shape, order=order)
+
+        if a_is_1d:
+            t = t[..., 0, :]
+        if b_is_1d:
+            t = t[..., 0]
+
+        if out is not None:
+            check_out_param(out, t, self.casting)
+            t = broadcast_to(t, out.shape)
+            out.data = t.data
+            return out
+
+        return t
+
+
+def matmul(a, b, sparse=None, out=None, **kw):
+    """
+    Matrix product of two tensors.
+
+    The behavior depends on the arguments in the following way.
+
+    - If both arguments are 2-D they are multiplied like conventional
+      matrices.
+    - If either argument is N-D, N > 2, it is treated as a stack of
+      matrices residing in the last two indexes and broadcast accordingly.
+    - If the first argument is 1-D, it is promoted to a matrix by
+      prepending a 1 to its dimensions. After matrix multiplication
+      the prepended 1 is removed.
+    - If the second argument is 1-D, it is promoted to a matrix by
+      appending a 1 to its dimensions. After matrix multiplication
+      the appended 1 is removed.
+
+    Multiplication by a scalar is not allowed, use ``*`` instead. Note that
+    multiplying a stack of matrices with a vector will result in a stack of
+    vectors, but matmul will not recognize it as such.
+
+    ``matmul`` differs from ``dot`` in two important ways.
+
+    - Multiplication by scalars is not allowed.
+    - Stacks of matrices are broadcast together as if the matrices
+      were elements.
+
+    Parameters
+    ----------
+    a : array_like
+        First argument.
+    b : array_like
+        Second argument.
+    out : Tensor, optional
+        Output argument. This must have the exact kind that would be returned
+        if it was not used. In particular, it must have the right type,
+        and its dtype must be the dtype that would be returned
+        for `dot(a,b)`. This is a performance feature. Therefore, if these
+        conditions are not met, an exception is raised, instead of attempting
+        to be flexible.
+
+    Returns
+    -------
+    output : Tensor
+        Returns the dot product of `a` and `b`.  If `a` and `b` are both
+        1-D arrays then a scalar is returned; otherwise an array is
+        returned.  If `out` is given, then it is returned.
+
+    Raises
+    ------
+    ValueError
+        If the last dimension of `a` is not the same size as
+        the second-to-last dimension of `b`.
+
+        If scalar value is passed.
+
+    See Also
+    --------
+    vdot : Complex-conjugating dot product.
+    tensordot : Sum products over arbitrary axes.
+    dot : alternative matrix product with different broadcasting rules.
+
+    Notes
+    -----
+    The matmul function implements the semantics of the `@` operator introduced
+    in Python 3.5 following PEP465.
+
+    Examples
+    --------
+    For 2-D arrays it is the matrix product:
+
+    >>> import maxframe.tensor as mt
+
+    >>> a = [[1, 0], [0, 1]]
+    >>> b = [[4, 1], [2, 2]]
+    >>> mt.matmul(a, b).execute()
+    array([[4, 1],
+           [2, 2]])
+
+    For 2-D mixed with 1-D, the result is the usual.
+
+    >>> a = [[1, 0], [0, 1]]
+    >>> b = [1, 2]
+    >>> mt.matmul(a, b).execute()
+    array([1, 2])
+    >>> mt.matmul(b, a).execute()
+    array([1, 2])
+
+
+    Broadcasting is conventional for stacks of arrays
+
+    >>> a = mt.arange(2*2*4).reshape((2,2,4))
+    >>> b = mt.arange(2*2*4).reshape((2,4,2))
+    >>> mt.matmul(a,b).shape
+    (2, 2, 2)
+    >>> mt.matmul(a,b)[0,1,1].execute()
+    98
+    >>> mt.sum(a[0,1,:] * b[0,:,1]).execute()
+    98
+
+    Vector, vector returns the scalar inner product, but neither argument
+    is complex-conjugated:
+
+    >>> mt.matmul([2j, 3j], [2j, 3j]).execute()
+    (-13+0j)
+
+    Scalar multiplication raises an error.
+
+    >>> mt.matmul([1,2], 3)
+    Traceback (most recent call last):
+    ...
+    ValueError: Scalar operands are not allowed, use '*' instead
+    """
+    a = astensor(a)
+    b = astensor(b)
+
+    sparse = sparse if sparse is not None else a.issparse() and b.issparse()
+    op = TensorMatmul(dtype=np.promote_types(a.dtype, b.dtype), sparse=sparse, **kw)
+    return op(a, b, out=out)

maxframe/tensor/linalg/qr.py

@@ -0,0 +1,124 @@
+# 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 numpy.linalg import LinAlgError
+
+from ... import opcodes
+from ...core import ExecutableTuple
+from ...serialization.serializables import StringField
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorQR(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.QR
+
+    method = StringField("method")
+
+    @property
+    def output_limit(self):
+        return 2
+
+    def __call__(self, a):
+        a = astensor(a)
+
+        if a.ndim != 2:
+            raise LinAlgError(
+                f"{a.ndim}-dimensional tensor given. Tensor must be two-dimensional"
+            )
+
+        tiny_q, tiny_r = np.linalg.qr(np.ones((1, 1), dtype=a.dtype))
+
+        x, y = a.shape
+        q_shape, r_shape = (a.shape, (y, y)) if x > y else ((x, x), a.shape)
+        q, r = self.new_tensors(
+            [a],
+            kws=[
+                {
+                    "side": "q",
+                    "dtype": tiny_q.dtype,
+                    "shape": q_shape,
+                    "order": TensorOrder.C_ORDER,
+                },
+                {
+                    "side": "r",
+                    "dtype": tiny_r.dtype,
+                    "shape": r_shape,
+                    "order": TensorOrder.C_ORDER,
+                },
+            ],
+        )
+        return ExecutableTuple([q, r])
+
+
+def qr(a, method="tsqr"):
+    """
+    Compute the qr factorization of a matrix.
+
+    Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is
+    upper-triangular.
+
+    Parameters
+    ----------
+    a : array_like, shape (M, N)
+        Matrix to be factored.
+    method: {'tsqr', 'sfqr'}, optional
+        method to calculate qr factorization, tsqr as default
+
+        TSQR is presented in:
+
+            A. Benson, D. Gleich, and J. Demmel.
+            Direct QR factorizations for tall-and-skinny matrices in
+            MapReduce architectures.
+            IEEE International Conference on Big Data, 2013.
+            http://arxiv.org/abs/1301.1071
+
+        FSQR is a QR decomposition for fat and short matrix:
+            A = [A1, A2, A3, ...], A1 may be decomposed as A1 = Q1 * R1,
+            for A = Q * R, Q = Q1, R = [R1, R2, R3, ...] where A2 = Q1 * R2, A3 = Q1 * R3, ...
+
+    Returns
+    -------
+    q : Tensor of float or complex, optional
+        A matrix with orthonormal columns. When mode = 'complete' the
+        result is an orthogonal/unitary matrix depending on whether or not
+        a is real/complex. The determinant may be either +/- 1 in that
+        case.
+    r : Tensor of float or complex, optional
+        The upper-triangular matrix.
+
+    Raises
+    ------
+    LinAlgError
+        If factoring fails.
+
+    Notes
+    -----
+    For more information on the qr factorization, see for example:
+    http://en.wikipedia.org/wiki/QR_factorization
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.random.randn(9, 6)
+    >>> q, r = mt.linalg.qr(a)
+    >>> mt.allclose(a, mt.dot(q, r)).execute()  # a does equal qr
+    True
+
+    """
+    op = TensorQR(method=method)
+    return op(a)

maxframe/tensor/linalg/solve_triangular.py

@@ -0,0 +1,103 @@
+# 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.
+
+from typing import List
+
+import numpy as np
+from numpy.linalg import LinAlgError
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import BoolField, KeyField
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+
+
+class TensorSolveTriangular(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.SOLVE_TRIANGULAR
+
+    a = KeyField("a")
+    b = KeyField("b")
+    lower = BoolField("lower")
+    strict = BoolField("strict")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorSolveTriangular", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.a, op.b = op._inputs
+
+    def __call__(self, a, b):
+        shape = (a.shape[1],) if len(b.shape) == 1 else (a.shape[1], b.shape[1])
+        return self.new_tensor([a, b], shape, order=TensorOrder.F_ORDER)
+
+
+def solve_triangular(a, b, lower=False, sparse=None):
+    """
+    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
+
+    Parameters
+    ----------
+    a : (M, M) array_like
+        A triangular matrix
+    b : (M,) or (M, N) array_like
+        Right-hand side matrix in `a x = b`
+    lower : bool, optional
+        Use only data contained in the lower triangle of `a`.
+        Default is to use upper triangle.
+    sparse: bool, optional
+        Return sparse value or not.
+
+    Returns
+    -------
+    x : (M,) or (M, N) ndarray
+        Solution to the system `a x = b`.  Shape of return matches `b`.
+
+    Examples
+    --------
+    Solve the lower triangular system a x = b, where::
+             [3  0  0  0]       [4]
+        a =  [2  1  0  0]   b = [2]
+             [1  0  1  0]       [4]
+             [1  1  1  1]       [2]
+
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
+    >>> b = mt.array([4, 2, 4, 2])
+    >>> x = mt.linalg.solve_triangular(a, b, lower=True)
+    >>> x.execute()
+    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
+
+    >>> a.dot(x).execute()  # Check the result
+    array([ 4.,  2.,  4.,  2.])
+    """
+    import scipy.linalg
+
+    a = astensor(a)
+    b = astensor(b)
+
+    if a.ndim != 2:
+        raise LinAlgError("a must be 2 dimensional")
+    if b.ndim <= 2:
+        if a.shape[1] != b.shape[0]:
+            raise LinAlgError("a.shape[1] and b.shape[0] must be equal")
+    else:
+        raise LinAlgError("b must be 1 or 2 dimensional")
+
+    tiny_x = scipy.linalg.solve_triangular(
+        np.array([[2, 0], [2, 1]], dtype=a.dtype), np.array([[2], [3]], dtype=b.dtype)
+    )
+    sparse = sparse if sparse is not None else a.issparse()
+    op = TensorSolveTriangular(lower=lower, dtype=tiny_x.dtype, sparse=sparse)
+    return op(a, b)