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

maxframe/tensor/linalg/norm.py

@@ -0,0 +1,249 @@
+# 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 collections.abc import Iterable
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, BoolField, FieldTypes, TupleField
+from ..arithmetic import sqrt
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import validate_axis
+from .svd import svd
+
+
+class TensorNorm(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.NORM
+
+    ord = AnyField("ord", default=None)
+    axis = TupleField("axis", FieldTypes.int32, default=0)
+    keepdims = BoolField("keepdims", default=None)
+
+    def __call__(self, x):
+        r = x.astype(self.dtype)
+        shape = self._norm(r, self.ord, self.axis, self.keepdims).shape
+        return self.new_tensor([x], shape)
+
+    @staticmethod
+    def _norm(r, ord, axis, keepdims):
+        if ord is None:
+            return sqrt((abs(r) ** 2).sum(axis=axis, keepdims=keepdims))
+        elif ord == "nuc":
+            if len(axis) == 1:
+                raise ValueError("Invalid norm order for vectors.")
+            return svd(r)[1][np.newaxis].sum(keepdims=keepdims)
+        elif ord == np.inf:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            r = abs(r)
+            if len(axis) == 1:
+                return r.max(axis=axis, keepdims=keepdims)
+            else:
+                return r.sum(axis=axis[1], keepdims=keepdims).max(keepdims=keepdims)
+        elif ord == -np.inf:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            r = abs(r)
+            if len(axis) == 1:
+                return r.min(axis=axis, keepdims=keepdims)
+            else:
+                return r.sum(axis=axis[1], keepdims=keepdims).min(keepdims=keepdims)
+        elif ord == 0:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            if len(axis) == 2:
+                raise ValueError("Invalid norm order for matrices.")
+            return (r != 0).astype(r.dtype).sum(axis=axis, keepdims=keepdims)
+        elif ord == 1:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            r = abs(r)
+            if len(axis) == 1:
+                return r.sum(axis=axis, keepdims=keepdims)
+            else:
+                return r.sum(axis=axis[0], keepdims=keepdims).max(keepdims=keepdims)
+        elif ord == -1 and len(axis) == 2:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            return abs(r).sum(axis=axis[0], keepdims=keepdims).min(keepdims=keepdims)
+        elif ord == 2 and len(axis) == 2:
+            return svd(r)[1][np.newaxis].max(keepdims=keepdims)
+        elif ord == -2 and len(axis) == 2:
+            return svd(r)[1][np.newaxis].min(keepdims=keepdims)
+        else:
+            if len(axis) == 2:
+                raise ValueError("Invalid norm order for matrices.")
+
+            return (abs(r) ** ord).sum(axis=axis, keepdims=keepdims) ** (1.0 / ord)
+
+
+def norm(x, ord=None, axis=None, keepdims=False):
+    r"""
+    Matrix or vector norm.
+
+    This function is able to return one of eight different matrix norms,
+    or one of an infinite number of vector norms (described below), depending
+    on the value of the ``ord`` parameter.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.  If `axis` is None, `x` must be 1-D or 2-D.
+    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
+        Order of the norm (see table under ``Notes``). inf means maxframe tensor's
+        `inf` object.
+    axis : {int, 2-tuple of ints, None}, optional
+        If `axis` is an integer, it specifies the axis of `x` along which to
+        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
+        axes that hold 2-D matrices, and the matrix norms of these matrices
+        are computed.  If `axis` is None then either a vector norm (when `x`
+        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
+    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.  With this option the result will
+        broadcast correctly against the original `x`.
+
+    Returns
+    -------
+    n : float or Tensor
+        Norm of the matrix or vector(s).
+
+    Notes
+    -----
+    For values of ``ord <= 0``, the result is, strictly speaking, not a
+    mathematical 'norm', but it may still be useful for various numerical
+    purposes.
+
+    The following norms can be calculated:
+
+    =====  ============================  ==========================
+    ord    norm for matrices             norm for vectors
+    =====  ============================  ==========================
+    None   Frobenius norm                2-norm
+    'fro'  Frobenius norm                --
+    'nuc'  nuclear norm                  --
+    inf    max(sum(abs(x), axis=1))      max(abs(x))
+    -inf   min(sum(abs(x), axis=1))      min(abs(x))
+    0      --                            sum(x != 0)
+    1      max(sum(abs(x), axis=0))      as below
+    -1     min(sum(abs(x), axis=0))      as below
+    2      2-norm (largest sing. value)  as below
+    -2     smallest singular value       as below
+    other  --                            sum(abs(x)**ord)**(1./ord)
+    =====  ============================  ==========================
+
+    The Frobenius norm is given by [1]_:
+
+        :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
+
+    The nuclear norm is the sum of the singular values.
+
+    References
+    ----------
+    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
+           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
+
+    Examples
+    --------
+    >>> from maxframe.tensor import linalg as LA
+    >>> import maxframe.tensor as mt
+    >>> a = mt.arange(9) - 4
+    >>> a.execute()
+    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
+    >>> b = a.reshape((3, 3))
+    >>> b.execute()
+    array([[-4, -3, -2],
+           [-1,  0,  1],
+           [ 2,  3,  4]])
+
+    >>> LA.norm(a).execute()
+    7.745966692414834
+    >>> LA.norm(b).execute()
+    7.745966692414834
+    >>> LA.norm(b, 'fro').execute()
+    7.745966692414834
+    >>> LA.norm(a, mt.inf).execute()
+    4.0
+    >>> LA.norm(b, mt.inf).execute()
+    9.0
+    >>> LA.norm(a, -mt.inf).execute()
+    0.0
+    >>> LA.norm(b, -mt.inf).execute()
+    2.0
+
+    >>> LA.norm(a, 1).execute()
+    20.0
+    >>> LA.norm(b, 1).execute()
+    7.0
+    >>> LA.norm(a, -1).execute()
+    0.0
+    >>> LA.norm(b, -1).execute()
+    6.0
+    >>> LA.norm(a, 2).execute()
+    7.745966692414834
+    >>> LA.norm(b, 2).execute()
+    7.3484692283495345
+
+    >>> LA.norm(a, -2).execute()
+    0.0
+    >>> LA.norm(b, -2).execute()
+    4.351066026358965e-18
+    >>> LA.norm(a, 3).execute()
+    5.8480354764257312
+    >>> LA.norm(a, -3).execute()
+    0.0
+
+    Using the `axis` argument to compute vector norms:
+
+    >>> c = mt.array([[ 1, 2, 3],
+    ...               [-1, 1, 4]])
+    >>> LA.norm(c, axis=0).execute()
+    array([ 1.41421356,  2.23606798,  5.        ])
+    >>> LA.norm(c, axis=1).execute()
+    array([ 3.74165739,  4.24264069])
+    >>> LA.norm(c, ord=1, axis=1).execute()
+    array([ 6.,  6.])
+
+    Using the `axis` argument to compute matrix norms:
+
+    >>> m = mt.arange(8).reshape(2,2,2)
+    >>> LA.norm(m, axis=(1,2)).execute()
+    array([  3.74165739,  11.22497216])
+    >>> LA.norm(m[0, :, :]).execute(), LA.norm(m[1, :, :]).execute()
+    (3.7416573867739413, 11.224972160321824)
+
+    """
+    x = astensor(x)
+    ndim = x.ndim
+
+    if ord == "fro":
+        ord = None
+    if axis is not None:
+        if isinstance(axis, Iterable):
+            axis = tuple(validate_axis(ndim, a) for a in axis)
+        else:
+            axis = (validate_axis(ndim, axis),)
+    else:
+        axis = tuple(range(x.ndim))
+
+    op = TensorNorm(
+        ord=ord,
+        axis=axis,
+        keepdims=keepdims,
+        dtype=np.result_type(x.dtype, np.float_),
+        sparse=x.issparse(),
+    )
+    return op(x)

maxframe/tensor/linalg/solve.py

@@ -0,0 +1,72 @@
+# 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 ..datasource import tensor as astensor
+from .cholesky import cholesky
+from .lu import lu
+from .solve_triangular import solve_triangular
+
+
+def solve(a, b, sym_pos=False, sparse=None):
+    """
+    Solve the equation ``a x = b`` for ``x``.
+
+    Parameters
+    ----------
+    a : (M, M) array_like
+        A square matrix.
+    b : (M,) or (M, N) array_like
+        Right-hand side matrix in ``a x = b``.
+    sym_pos : bool
+        Assume `a` is symmetric and positive definite. If ``True``, use Cholesky
+        decomposition.
+    sparse: bool, optional
+        Return sparse value or not.
+
+    Returns
+    -------
+    x : (M,) or (M, N) ndarray
+    Solution to the system ``a x = b``.  Shape of the return matches the
+    shape of `b`.
+
+    Raises
+    ------
+    LinAlgError
+    If `a` is singular.
+
+    Examples
+    --------
+    Given `a` and `b`, solve for `x`:
+
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
+    >>> b = mt.array([2, 4, -1])
+    >>> x = mt.linalg.solve(a, b)
+    >>> x.execute()
+    array([ 2., -2.,  9.])
+
+    >>> mt.dot(a, x).execute()  # Check the result
+    array([ 2., 4., -1.])
+    """
+    a = astensor(a)
+    b = astensor(b)
+    if sym_pos:
+        l_ = cholesky(a, lower=True)
+        u = l_.T
+    else:
+        p, l_, u = lu(a)
+        b = p.T.dot(b)
+    sparse = sparse if sparse is not None else a.issparse()
+    uy = solve_triangular(l_, b, lower=True, sparse=sparse)
+    return solve_triangular(u, uy, sparse=sparse)

maxframe/tensor/linalg/solve_triangular.py

@@ -30,8 +30,8 @@ class TensorSolveTriangular(TensorOperator, TensorOperatorMixin):
 
     a = KeyField("a")
     b = KeyField("b")
-    lower = BoolField("lower")
-    strict = BoolField("strict")
+    lower = BoolField("lower", default=None)
+    strict = BoolField("strict", default=None)
 
     @classmethod
     def _set_inputs(cls, op: "TensorSolveTriangular", inputs: List[EntityData]):

maxframe/tensor/linalg/vector_norm.py

@@ -0,0 +1,113 @@
+# 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 ..utils import normalize_axis_tuple
+
+
+def vector_norm(x, *, axis=None, keepdims=False, ord=2):
+    """
+    Computes the vector norm of a vector (or batch of vectors) ``x``.
+
+    This function is Array API compatible.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axis : {None, int, 2-tuple of ints}, optional
+        If an integer, ``axis`` specifies the axis (dimension) along which
+        to compute vector norms. If an n-tuple, ``axis`` specifies the axes
+        (dimensions) along which to compute batched vector norms. If ``None``,
+        the vector norm must be computed over all array values (i.e.,
+        equivalent to computing the vector norm of a flattened array).
+        Default: ``None``.
+    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 : {int, float, inf, -inf}, 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
+    --------
+    >>> from numpy import linalg as LA
+    >>> a = np.arange(9) + 1
+    >>> a
+    array([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> b = a.reshape((3, 3))
+    >>> b
+    array([[1, 2, 3],
+           [4, 5, 6],
+           [7, 8, 9]])
+
+    >>> LA.vector_norm(b)
+    16.881943016134134
+    >>> LA.vector_norm(b, ord=np.inf)
+    9.0
+    >>> LA.vector_norm(b, ord=-np.inf)
+    1.0
+
+    >>> LA.vector_norm(b, ord=0)
+    9.0
+    >>> LA.vector_norm(b, ord=1)
+    45.0
+    >>> LA.vector_norm(b, ord=-1)
+    0.3534857623790153
+    >>> LA.vector_norm(b, ord=2)
+    16.881943016134134
+    >>> LA.vector_norm(b, ord=-2)
+    0.8058837395885292
+
+    """
+    from ..datasource.array import asarray
+    from ..misc import transpose
+    from ..reduction import prod
+    from .norm import norm
+
+    x = asarray(x)
+    shape = list(x.shape)
+    if axis is None:
+        # Note: np.linalg.norm() doesn't handle 0-D arrays
+        x = x.ravel()
+        _axis = 0
+    elif isinstance(axis, tuple):
+        # Note: The axis argument supports any number of axes, whereas
+        # np.linalg.norm() only supports a single axis for vector norm.
+        normalized_axis = normalize_axis_tuple(axis, x.ndim)
+        rest = tuple(i for i in range(x.ndim) if i not in normalized_axis)
+        newshape = axis + rest
+        x = transpose(x, newshape).reshape(
+            (prod([x.shape[i] for i in axis], dtype=int), *[x.shape[i] for i in rest])
+        )
+        _axis = 0
+    else:
+        _axis = axis
+
+    res = norm(x, axis=_axis, ord=ord)
+
+    if keepdims:
+        # We can't reuse np.linalg.norm(keepdims) because of the reshape hacks
+        # above to avoid matrix norm logic.
+        _axis = normalize_axis_tuple(
+            range(len(shape)) if axis is None else axis, len(shape)
+        )
+        for i in _axis:
+            shape[i] = 1
+        res = res.reshape(tuple(shape))
+
+    return res

maxframe/tensor/misc/__init__.py

@@ -12,26 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .argwhere import TensorArgwhere, argwhere
+from .array_split import array_split
 from .astype import TensorAstype, astype
 from .atleast_1d import atleast_1d
 from .atleast_2d import atleast_2d
 from .atleast_3d import atleast_3d
+from .broadcast_arrays import broadcast_arrays
 from .broadcast_to import TensorBroadcastTo, broadcast_to
 from .copy import copy
+from .copyto import TensorCopyTo, copyto
+from .delete import TensorDelete, delete
 from .diff import TensorDiff, diff
+from .dsplit import dsplit
+from .ediff1d import ediff1d
+from .expand_dims import expand_dims
 from .flatten import flatten
+from .flip import flip
+from .fliplr import fliplr
+from .flipud import flipud
+from .hsplit import hsplit
 from .in1d import in1d
+from .insert import insert
 from .isin import TensorIsIn, isin
+from .moveaxis import moveaxis
 from .ndim import ndim
 from .ravel import ravel
 from .repeat import TensorRepeat, repeat
+from .result_type import result_type
+from .roll import roll
+from .rollaxis import rollaxis
 from .searchsorted import TensorSearchsorted, searchsorted
 from .setdiff1d import setdiff1d
+from .shape import TensorGetShape, shape
+from .split import TensorSplit, split
 from .squeeze import TensorSqueeze, squeeze
 from .swapaxes import TensorSwapAxes, swapaxes
+from .tile import tile
 from .transpose import TensorTranspose, transpose
 from .trapezoid import TensorTrapezoid, trapezoid
 from .unique import TensorUnique, unique
+from .vsplit import vsplit
 from .where import TensorWhere, where
 
 
@@ -41,8 +62,10 @@ def _install():
     for cls in (Tensor, TensorData):
         setattr(cls, "astype", astype)
         setattr(cls, "flatten", flatten)
-        setattr(cls, "swapaxes", swapaxes)
         setattr(cls, "ravel", ravel)
+        setattr(cls, "repeat", repeat)
+        setattr(cls, "squeeze", squeeze)
+        setattr(cls, "swapaxes", swapaxes)
 
 
 _install()

maxframe/tensor/misc/argwhere.py

@@ -0,0 +1,72 @@
+# 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 ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorArgwhere(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.ARGWHERE
+
+    def __call__(self, a):
+        shape = (np.nan, a.ndim)
+        return self.new_tensor([a], shape)
+
+
+def argwhere(a):
+    """
+    Find the indices of tensor elements that are non-zero, grouped by element.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+
+    Returns
+    -------
+    index_tensor : Tensor
+        Indices of elements that are non-zero. Indices are grouped by element.
+
+    See Also
+    --------
+    where, nonzero
+
+    Notes
+    -----
+    ``mt.argwhere(a)`` is the same as ``mt.transpose(mt.nonzero(a))``.
+
+    The output of ``argwhere`` is not suitable for indexing tensors.
+    For this purpose use ``nonzero(a)`` instead.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(6).reshape(2,3)
+    >>> x.execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> mt.argwhere(x>1).execute()
+    array([[0, 2],
+           [1, 0],
+           [1, 1],
+           [1, 2]])
+
+    """
+    a = astensor(a).astype(bool, order="A")
+    op = TensorArgwhere(dtype=np.dtype(np.intp))
+    return op(a)

maxframe/tensor/misc/array_split.py

@@ -0,0 +1,46 @@
+# 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 .split import _split
+
+
+def array_split(a, indices_or_sections, axis=0):
+    """
+    Split a tensor into multiple sub-tensors.
+
+    Please refer to the ``split`` documentation.  The only difference
+    between these functions is that ``array_split`` allows
+    `indices_or_sections` to be an integer that does *not* equally
+    divide the axis. For a tensor of length l that should be split
+    into n sections, it returns l % n sub-arrays of size l//n + 1
+    and the rest of size l//n.
+
+    See Also
+    --------
+    split : Split tensor into multiple sub-tensors of equal size.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(8.0)
+    >>> mt.array_split(x, 3).execute()
+        [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]
+
+    >>> x = mt.arange(7.0)
+    >>> mt.array_split(x, 3).execute()
+        [array([ 0.,  1.,  2.]), array([ 3.,  4.]), array([ 5.,  6.])]
+
+    """
+    return _split(a, indices_or_sections, axis=axis)

maxframe/tensor/misc/broadcast_arrays.py

@@ -0,0 +1,57 @@
+# 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 ...core import ExecutableTuple
+from ..datasource import tensor as astensor
+from ..utils import broadcast_shape
+from .broadcast_to import broadcast_to
+
+
+def broadcast_arrays(*args, **kwargs):
+    """
+    Broadcast any number of arrays against each other.
+
+    Parameters
+    ----------
+    `*args` : array_likes
+        The tensors to broadcast.
+
+    Returns
+    -------
+    broadcasted : list of tensors
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([[1,2,3]])
+    >>> y = mt.array([[1],[2],[3]])
+    >>> mt.broadcast_arrays(x, y).execute()
+    [array([[1, 2, 3],
+           [1, 2, 3],
+           [1, 2, 3]]), array([[1, 1, 1],
+           [2, 2, 2],
+           [3, 3, 3]])]
+
+    """
+    if kwargs:
+        raise TypeError(
+            "broadcast_arrays() got an unexpected keyword "
+            f"argument {next(iter(kwargs.keys()))!r}"
+        )
+
+    args = [astensor(arg) for arg in args]
+
+    shape = broadcast_shape(*[arg.shape for arg in args])
+    return ExecutableTuple([broadcast_to(a, shape) for a in args])