maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/tensor/linalg/cholesky.py

@@ -0,0 +1,117 @@
+# 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 ...serialization.serializables import BoolField
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorCholesky(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.CHOLESKY
+
+    lower = BoolField("lower")
+
+    def __call__(self, a):
+        return self.new_tensor([a], a.shape, order=TensorOrder.C_ORDER)
+
+
+def cholesky(a, lower=False):
+    """
+    Cholesky decomposition.
+
+    Return the Cholesky decomposition, `L * L.H`, of the square matrix `a`,
+    where `L` is lower-triangular and .H is the conjugate transpose operator
+    (which is the ordinary transpose if `a` is real-valued).  `a` must be
+    Hermitian (symmetric if real-valued) and positive-definite.  Only `L` is
+    actually returned.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Hermitian (symmetric if all elements are real), positive-definite
+        input matrix.
+    lower : bool
+        Whether to compute the upper or lower triangular Cholesky
+        factorization.  Default is upper-triangular.
+
+    Returns
+    -------
+    L : (..., M, M) array_like
+        Upper or lower-triangular Cholesky factor of `a`.
+
+    Raises
+    ------
+    LinAlgError
+       If the decomposition fails, for example, if `a` is not
+       positive-definite.
+
+    Notes
+    -----
+
+    Broadcasting rules apply, see the `mt.linalg` documentation for
+    details.
+
+    The Cholesky decomposition is often used as a fast way of solving
+
+    .. math:: A \\mathbf{x} = \\mathbf{b}
+
+    (when `A` is both Hermitian/symmetric and positive-definite).
+
+    First, we solve for :math:`\\mathbf{y}` in
+
+    .. math:: L \\mathbf{y} = \\mathbf{b},
+
+    and then for :math:`\\mathbf{x}` in
+
+    .. math:: L.H \\mathbf{x} = \\mathbf{y}.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> A = mt.array([[1,-2j],[2j,5]])
+    >>> A.execute()
+    array([[ 1.+0.j,  0.-2.j],
+           [ 0.+2.j,  5.+0.j]])
+    >>> L = mt.linalg.cholesky(A, lower=True)
+    >>> L.execute()
+    array([[ 1.+0.j,  0.+0.j],
+           [ 0.+2.j,  1.+0.j]])
+    >>> mt.dot(L, L.T.conj()).execute() # verify that L * L.H = A
+    array([[ 1.+0.j,  0.-2.j],
+           [ 0.+2.j,  5.+0.j]])
+    >>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
+    >>> mt.linalg.cholesky(A, lower=True).execute()
+    array([[ 1.+0.j,  0.+0.j],
+           [ 0.+2.j,  1.+0.j]])
+
+    """
+    a = astensor(a)
+
+    if a.ndim != 2:  # pragma: no cover
+        raise LinAlgError(
+            f"{a.ndim}-dimensional array given. Tensor must be two-dimensional"
+        )
+    if a.shape[0] != a.shape[1]:  # pragma: no cover
+        raise LinAlgError("Input must be square")
+
+    cho = np.linalg.cholesky(np.array([[1, 2], [2, 5]], dtype=a.dtype))
+
+    op = TensorCholesky(lower=lower, dtype=cho.dtype)
+    return op(a)

maxframe/tensor/linalg/einsum.py

@@ -0,0 +1,339 @@
+# 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 ... import opcodes
+from ...serialization.serializables import AnyField, StringField
+from ..core import TensorOrder
+from ..operators import TensorOperator, TensorOperatorMixin
+from ._einsumfunc import einsum_path, parse_einsum_input
+
+
+class TensorEinsum(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.EINSUM
+
+    subscripts = StringField("subscripts")
+    optimize = AnyField("optimize")
+    order = StringField("order")
+    casting = StringField("casting")
+
+    def __call__(self, input_tensors, shape):
+        if self.order in "KA":
+            if any(t.order == TensorOrder.C_ORDER for t in input_tensors):
+                order = TensorOrder.C_ORDER
+            else:
+                order = TensorOrder.F_ORDER
+        else:
+            if self.order == "C":
+                order = TensorOrder.C_ORDER
+            else:
+                order = TensorOrder.F_ORDER
+        return self.new_tensor(
+            input_tensors, shape=shape, dtype=self.dtype, order=order
+        )
+
+
+def einsum(
+    subscripts, *operands, dtype=None, order="K", casting="safe", optimize=False
+):
+    """
+    Evaluates the Einstein summation convention on the operands.
+
+    Using the Einstein summation convention, many common multi-dimensional,
+    linear algebraic array operations can be represented in a simple fashion.
+    In *implicit* mode `einsum` computes these values.
+
+    In *explicit* mode, `einsum` provides further flexibility to compute
+    other array operations that might not be considered classical Einstein
+    summation operations, by disabling, or forcing summation over specified
+    subscript labels.
+
+    See the notes and examples for clarification.
+
+    Parameters
+    ----------
+    subscripts : str
+        Specifies the subscripts for summation as comma separated list of
+        subscript labels. An implicit (classical Einstein summation)
+        calculation is performed unless the explicit indicator '->' is
+        included as well as subscript labels of the precise output form.
+    operands : list of array_like
+        These are the arrays for the operation.
+    dtype : {data-type, None}, optional
+        If provided, forces the calculation to use the data type specified.
+        Note that you may have to also give a more liberal `casting`
+        parameter to allow the conversions. Default is None.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the output. 'C' means it should
+        be C contiguous. 'F' means it should be Fortran contiguous,
+        'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
+        'K' means it should be as close to the layout as the inputs as
+        is possible, including arbitrarily permuted axes.
+        Default is 'K'.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur.  Setting this to
+        'unsafe' is not recommended, as it can adversely affect accumulations.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+
+        Default is 'safe'.
+    optimize : {False, True, 'greedy', 'optimal'}, optional
+        Controls if intermediate optimization should occur. No optimization
+        will occur if False and True will default to the 'greedy' algorithm.
+        Also accepts an explicit contraction list from the ``np.einsum_path``
+        function. See ``np.einsum_path`` for more details. Defaults to False.
+
+    Returns
+    -------
+    output : maxframe.tensor.Tensor
+        The calculation based on the Einstein summation convention.
+
+    The Einstein summation convention can be used to compute
+    many multi-dimensional, linear algebraic array operations. `einsum`
+    provides a succinct way of representing these.
+
+    A non-exhaustive list of these operations,
+    which can be computed by `einsum`, is shown below along with examples:
+
+    * Trace of an array, :py:func:`numpy.trace`.
+    * Return a diagonal, :py:func:`numpy.diag`.
+    * Array axis summations, :py:func:`numpy.sum`.
+    * Transpositions and permutations, :py:func:`numpy.transpose`.
+    * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`.
+    * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`.
+    * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`.
+    * Tensor contractions, :py:func:`numpy.tensordot`.
+    * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`.
+
+    The subscripts string is a comma-separated list of subscript labels,
+    where each label refers to a dimension of the corresponding operand.
+    Whenever a label is repeated it is summed, so ``mt.einsum('i,i', a, b)``
+    is equivalent to :py:func:`mt.inner(a,b) <maxframe.tensor.inner>`. If a label
+    appears only once, it is not summed, so ``mt.einsum('i', a)`` produces a
+    view of ``a`` with no changes. A further example ``mt.einsum('ij,jk', a, b)``
+    describes traditional matrix multiplication and is equivalent to
+    :py:func:`mt.matmul(a,b) <maxframe.tensor.matmul>`.
+
+    In *implicit mode*, the chosen subscripts are important
+    since the axes of the output are reordered alphabetically.  This
+    means that ``mt.einsum('ij', a)`` doesn't affect a 2D array, while
+    ``mt.einsum('ji', a)`` takes its transpose. Additionally,
+    ``mt.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,
+    ``mt.einsum('ij,jh', a, b)`` returns the transpose of the
+    multiplication since subscript 'h' precedes subscript 'i'.
+
+    In *explicit mode* the output can be directly controlled by
+    specifying output subscript labels.  This requires the
+    identifier '->' as well as the list of output subscript labels.
+    This feature increases the flexibility of the function since
+    summing can be disabled or forced when required. The call
+    ``mt.einsum('i->', a)`` is like :py:func:`mt.sum(a, axis=-1) <maxframe.tensor.sum>`,
+    and ``mt.einsum('ii->i', a)`` is like :py:func:`mt.diag(a) <maxframe.tensor.diag>`.
+    The difference is that `einsum` does not allow broadcasting by default.
+    Additionally ``mt.einsum('ij,jh->ih', a, b)`` directly specifies the
+    order of the output subscript labels and therefore returns matrix
+    multiplication, unlike the example above in implicit mode.
+
+    To enable and control broadcasting, use an ellipsis.  Default
+    NumPy-style broadcasting is done by adding an ellipsis
+    to the left of each term, like ``mt.einsum('...ii->...i', a)``.
+    To take the trace along the first and last axes,
+    you can do ``mt.einsum('i...i', a)``, or to do a matrix-matrix
+    product with the left-most indices instead of rightmost, one can do
+    ``mt.einsum('ij...,jk...->ik...', a, b)``.
+
+    When there is only one operand, no axes are summed, and no output
+    parameter is provided, a view into the operand is returned instead
+    of a new array.  Thus, taking the diagonal as ``mt.einsum('ii->i', a)``
+    produces a view (changed in version 1.10.0).
+
+    `einsum` also provides an alternative way to provide the subscripts
+    and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``.
+    If the output shape is not provided in this format `einsum` will be
+    calculated in implicit mode, otherwise it will be performed explicitly.
+    The examples below have corresponding `einsum` calls with the two
+    parameter methods.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> a = mt.arange(25).reshape(5,5)
+    >>> b = mt.arange(5)
+    >>> c = mt.arange(6).reshape(2,3)
+    Trace of a matrix:
+    >>> mt.einsum('ii', a).execute()
+    60
+    >>> mt.einsum(a, [0,0]).execute()
+    60
+    Extract the diagonal (requires explicit form):
+    >>> mt.einsum('ii->i', a).execute()
+    array([ 0,  6, 12, 18, 24])
+    >>> mt.einsum(a, [0,0], [0]).execute()
+    array([ 0,  6, 12, 18, 24])
+    >>> mt.diag(a).execute()
+    array([ 0,  6, 12, 18, 24])
+    Sum over an axis (requires explicit form):
+    >>> mt.einsum('ij->i', a).execute()
+    array([ 10,  35,  60,  85, 110])
+    >>> mt.einsum(a, [0,1], [0]).execute()
+    array([ 10,  35,  60,  85, 110])
+    >>> mt.sum(a, axis=1).execute()
+    array([ 10,  35,  60,  85, 110])
+    For higher dimensional arrays summing a single axis can be done with ellipsis:
+    >>> mt.einsum('...j->...', a).execute()
+    array([ 10,  35,  60,  85, 110])
+    >>> mt.einsum(a, [Ellipsis,1], [Ellipsis]).execute()
+    array([ 10,  35,  60,  85, 110])
+    Compute a matrix transpose, or reorder any number of axes:
+    >>> mt.einsum('ji', c).execute()
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> mt.einsum('ij->ji', c).execute()
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> mt.einsum(c, [1,0]).execute()
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> mt.transpose(c).execute()
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    Vector inner products:
+    >>> mt.einsum('i,i', b, b).execute()
+    30
+    >>> mt.einsum(b, [0], b, [0]).execute()
+    30
+    >>> mt.inner(b,b).execute()
+    30
+    Matrix vector multiplication:
+    >>> mt.einsum('ij,j', a, b).execute()
+    array([ 30,  80, 130, 180, 230])
+    >>> mt.einsum(a, [0,1], b, [1]).execute()
+    array([ 30,  80, 130, 180, 230])
+    >>> mt.dot(a, b).execute()
+    array([ 30,  80, 130, 180, 230])
+    >>> mt.einsum('...j,j', a, b).execute()
+    array([ 30,  80, 130, 180, 230])
+    Broadcasting and scalar multiplication:
+    >>> mt.einsum('..., ...', 3, c).execute()
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> mt.einsum(',ij', 3, c).execute()
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> mt.einsum(3, [Ellipsis], c, [Ellipsis]).execute()
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> mt.multiply(3, c).execute()
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    Vector outer product:
+    >>> mt.einsum('i,j', mt.arange(2)+1, b).execute()
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    >>> mt.einsum(mt.arange(2)+1, [0], b, [1]).execute()
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    >>> mt.outer(mt.arange(2)+1, b).execute()
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    Tensor contraction:
+    >>> a = mt.arange(60.).reshape(3,4,5)
+    >>> b = mt.arange(24.).reshape(4,3,2)
+    >>> mt.einsum('ijk,jil->kl', a, b).execute()
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> mt.einsum(a, [0,1,2], b, [1,0,3], [2,3]).execute()
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> mt.tensordot(a,b, axes=([1,0],[0,1])).execute()
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    Writeable returned arrays (since version 1.10.0):
+    >>> a = mt.zeros((3, 3))
+    >>> mt.einsum('ii->i', a)[:] = 1
+    >>> a.execute()
+    array([[1., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 1.]])
+    Example of ellipsis use:
+    >>> a = mt.arange(6).reshape((3,2))
+    >>> b = mt.arange(12).reshape((4,3))
+    >>> mt.einsum('ki,jk->ij', a, b).execute()
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    >>> mt.einsum('ki,...k->i...', a, b).execute()
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    >>> mt.einsum('k...,jk', a, b).execute()
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    Chained array operations. For more complicated contractions, speed ups
+    might be achieved by repeatedly computing a 'greedy' path or pre-computing the
+    'optimal' path and repeatedly applying it, using an
+    `einsum_path` insertion (since version 1.12.0). Performance improvements can be
+    particularly significant with larger arrays:
+    >>> a = mt.ones(64).reshape(2,4,8)
+    Basic `einsum`: ~1520ms  (benchmarked on 3.1GHz Intel i5.)
+    >>> for iteration in range(500):
+    ...     _ = mt.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)
+    Sub-optimal `einsum` (due to repeated path calculation time): ~330ms
+    >>> for iteration in range(500):
+    ...     _ = mt.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')
+    Greedy `einsum` (faster optimal path approximation): ~160ms
+    >>> for iteration in range(500):
+    ...     _ = mt.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')
+    Optimal `einsum` (best usage pattern in some use cases): ~110ms
+    >>> path = mt.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]
+    >>> for iteration in range(500):
+    ...     _ = mt.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)
+
+    """
+
+    all_inputs = [subscripts] + list(operands)
+    inputs, outputs, operands = parse_einsum_input(all_inputs)
+    subscripts = "->".join((inputs, outputs))
+    axes_shape = dict()
+    for axes, op in zip(inputs.split(","), operands):
+        for ax, s in zip(axes, op.shape):
+            axes_shape[ax] = s
+
+    if optimize:
+        optimize, _ = einsum_path(*all_inputs, optimize=optimize)
+
+    shape = tuple(axes_shape[ax] for ax in outputs)
+    op = TensorEinsum(
+        subscripts=subscripts,
+        optimize=optimize,
+        dtype=dtype or operands[0].dtype,
+        order=order,
+        casting=casting,
+    )
+    return op(operands, shape)

maxframe/tensor/linalg/lstsq.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 ...core import ExecutableTuple
+from ...udf import builtin_function
+from .svd import svd
+
+
+@builtin_function
+def _cut_residuals(residuals, full_rank):
+    return residuals if full_rank else np.array([], dtype=residuals.dtype)
+
+
+def lstsq(a, b, rcond=None):
+    """
+    Return the least-squares solution to a linear matrix equation.
+
+    Computes the vector `x` that approximately solves the equation
+    ``a @ x = b``. The equation may be under-, well-, or over-determined
+    (i.e., the number of linearly independent rows of `a` can be less than,
+    equal to, or greater than its number of linearly independent columns).
+    If `a` is square and of full rank, then `x` (but for round-off error)
+    is the "exact" solution of the equation. Else, `x` minimizes the
+    Euclidean 2-norm :math:`||b - ax||`. If there are multiple minimizing
+    solutions, the one with the smallest 2-norm :math:`||x||` is returned.
+
+    Parameters
+    ----------
+    a : (M, N) array_like
+        "Coefficient" matrix.
+    b : {(M,), (M, K)} array_like
+        Ordinate or "dependent variable" values. If `b` is two-dimensional,
+        the least-squares solution is calculated for each of the `K` columns
+        of `b`.
+    rcond : float, optional
+        Cut-off ratio for small singular values of `a`.
+        For the purposes of rank determination, singular values are treated
+        as zero if they are smaller than `rcond` times the largest singular
+        value of `a`.
+        The default uses the machine precision times ``max(M, N)``.  Passing
+        ``-1`` will use machine precision.
+
+    Returns
+    -------
+    x : {(N,), (N, K)} ndarray
+        Least-squares solution. If `b` is two-dimensional,
+        the solutions are in the `K` columns of `x`.
+    residuals : {(1,), (K,), (0,)} ndarray
+        Sums of squared residuals: Squared Euclidean 2-norm for each column in
+        ``b - a @ x``.
+        If the rank of `a` is < N or M <= N, this is an empty array.
+        If `b` is 1-dimensional, this is a (1,) shape array.
+        Otherwise the shape is (K,).
+    rank : int
+        Rank of matrix `a`.
+    s : (min(M, N),) ndarray
+        Singular values of `a`.
+
+    Raises
+    ------
+    LinAlgError
+        If computation does not converge.
+
+    Notes
+    -----
+    If `b` is a matrix, then all array results are returned as matrices.
+    """
+    # fixme when has_unknown_shape(a)
+
+    rcond = rcond if rcond is not None and rcond < 1 else None
+    if rcond is None:
+        rcond = max(a.shape) * np.finfo(a.dtype).eps
+    elif rcond == -1:
+        rcond = np.finfo(np.float64).eps
+
+    u, s, vt = svd(a)
+    cutoff = (s > s.max() * rcond).astype(int)
+    # v^T diag(1.0 / s) u_1^T b
+    x = vt.T * (1.0 / s * cutoff) @ u.T[: a.shape[1], :] @ b
+    residuals = b - a.dot(x)
+    residuals = abs(residuals**2).sum(axis=0, keepdims=b.ndim == 1)
+
+    rank = cutoff.sum()
+    residuals = residuals.mf.apply_chunk(
+        _cut_residuals, dtype=residuals.dtype, full_rank=rank == min(a.shape)
+    )
+    return ExecutableTuple((x, residuals, rank, s))

maxframe/tensor/linalg/matrix_norm.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.
+
+from .norm import norm
+
+
+def matrix_norm(x, *, keepdims=False, ord="fro"):
+    """
+    Computes the matrix norm of a matrix (or a stack of matrices) ``x``.
+
+    This function is Array API compatible.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array having shape (..., M, N) and whose two innermost
+        dimensions form ``MxN`` matrices.
+    keepdims : bool, optional
+        If this is set to True, the axes which are normed over are left in
+        the result as dimensions with size one. Default: False.
+    ord : {1, -1, 2, -2, inf, -inf, 'fro', 'nuc'}, optional
+        The order of the norm. For details see the table under ``Notes``
+        in `numpy.linalg.norm`.
+
+    See Also
+    --------
+    numpy.linalg.norm : Generic norm function
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> from maxframe.tensor import linalg as LA
+    >>> a = mt.arange(9) - 4
+    >>> a.execute()
+    array([-4, -3, -2, ...,  2,  3,  4])
+    >>> b = a.reshape((3, 3))
+    >>> b.execute()
+    array([[-4, -3, -2],
+           [-1,  0,  1],
+           [ 2,  3,  4]])
+
+    >>> LA.matrix_norm(b).execute()
+    7.745966692414834
+    >>> LA.matrix_norm(b, ord='fro').execute()
+    7.745966692414834
+    >>> LA.matrix_norm(b, ord=np.inf).execute()
+    9.0
+    >>> LA.matrix_norm(b, ord=-np.inf).execute()
+    2.0
+
+    >>> LA.matrix_norm(b, ord=1).execute()
+    7.0
+    >>> LA.matrix_norm(b, ord=-1).execute()
+    6.0
+    >>> LA.matrix_norm(b, ord=2).execute()
+    7.3484692283495345
+    >>> LA.matrix_norm(b, ord=-2).execute()
+    1.8570331885190563e-016 # may vary
+
+    """
+    from ..datasource.array import asarray
+
+    x = asarray(x)
+    return norm(x, axis=(-2, -1), keepdims=keepdims, ord=ord)