maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/random/rand.py

@@ -0,0 +1,80 @@
+# 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 ..utils import gen_random_seeds
+from .core import TensorRandomOperatorMixin, TensorSimpleRandomData
+
+
+class TensorRand(TensorSimpleRandomData, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_RAND
+    _func_name = "rand"
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def rand(random_state, *dn, **kw):
+    """
+    Random values in a given shape.
+
+    Create a tensor of the given shape and populate it with
+    random samples from a uniform distributionc
+    over ``[0, 1)``.
+
+    Parameters
+    ----------
+    d0, d1, ..., dn : int, optional
+        The dimensions of the returned tensor, should all be positive.
+        If no argument is given a single Python float is returned.
+
+    Returns
+    -------
+    out : Tensor, shape ``(d0, d1, ..., dn)``
+        Random values.
+
+    See Also
+    --------
+    random
+
+    Notes
+    -----
+    This is a convenience function. If you want an interface that
+    takes a shape-tuple as the first argument, refer to
+    mt.random.random_sample .
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.rand(3, 2).execute()
+    array([[ 0.14022471,  0.96360618],  #random
+           [ 0.37601032,  0.25528411],  #random
+           [ 0.49313049,  0.94909878]]) #random
+    """
+    if len(dn) == 1 and isinstance(dn[0], (tuple, list)):
+        raise TypeError("'tuple' object cannot be interpreted as an integer")
+    if "dtype" not in kw:
+        kw["dtype"] = np.dtype("f8")
+    chunk_size = kw.pop("chunk_size", None)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRand(seed=seed, size=dn, **kw)
+
+    for key in op.extra_params:
+        if not key.startswith("_"):
+            raise ValueError(f"rand got unexpected key arguments {key}")
+
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/randint.py

@@ -0,0 +1,119 @@
+# 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 Float64Field, Int64Field
+from ..utils import gen_random_seeds
+from .core import TensorRandomOperatorMixin, TensorSimpleRandomData
+
+
+class TensorRandint(TensorSimpleRandomData, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_RANDINT
+
+    _fields_ = "low", "high", "density", "size"
+    low = Int64Field("low")
+    high = Int64Field("high")
+    density = Float64Field("density")
+    _func_name = "randint"
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def randint(
+    random_state,
+    low,
+    high=None,
+    size=None,
+    dtype="l",
+    density=None,
+    chunk_size=None,
+    gpu=None,
+):
+    """
+    Return random integers from `low` (inclusive) to `high` (exclusive).
+
+    Return random integers from the "discrete uniform" distribution of
+    the specified dtype in the "half-open" interval [`low`, `high`). If
+    `high` is None (the default), then results are from [0, `low`).
+
+    Parameters
+    ----------
+    low : int
+        Lowest (signed) integer to be drawn from the distribution (unless
+        ``high=None``, in which case this parameter is one above the
+        *highest* such integer).
+    high : int, optional
+        If provided, one above the largest (signed) integer to be drawn
+        from the distribution (see above for behavior if ``high=None``).
+    size : int or tuple of ints, optional
+        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
+        ``m * n * k`` samples are drawn.  Default is None, in which case a
+        single value is returned.
+    dtype : dtype, optional
+        Desired dtype of the result. All dtypes are determined by their
+        name, i.e., 'int64', 'int', etc, so byteorder is not available
+        and a specific precision may have different C types depending
+        on the platform. The default value is 'np.int'.
+    density: float, optional
+        if density specified, a sparse tensor will be created
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    dtype : data-type, optional
+      Data-type of the returned tensor.
+
+    Returns
+    -------
+    out : int or Tensor of ints
+        `size`-shaped tensor of random integers from the appropriate
+        distribution, or a single such random int if `size` not provided.
+
+    See Also
+    --------
+    random.random_integers : similar to `randint`, only for the closed
+        interval [`low`, `high`], and 1 is the lowest value if `high` is
+        omitted. In particular, this other one is the one to use to generate
+        uniformly distributed discrete non-integers.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.randint(2, size=10).execute()
+    array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])
+    >>> mt.random.randint(1, size=10).execute()
+    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+
+    Generate a 2 x 4 tensor of ints between 0 and 4, inclusive:
+
+    >>> mt.random.randint(5, size=(2, 4)).execute()
+    array([[4, 0, 2, 1],
+           [3, 2, 2, 0]])
+    """
+    sparse = bool(density)
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandint(
+        seed=seed,
+        low=low,
+        high=high,
+        size=size,
+        dtype=dtype,
+        gpu=gpu,
+        sparse=sparse,
+        density=density,
+    )
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/randn.py

@@ -0,0 +1,94 @@
+# 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 ..utils import gen_random_seeds
+from .core import TensorRandomOperatorMixin, TensorSimpleRandomData
+
+
+class TensorRandn(TensorSimpleRandomData, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_RANDN
+    _func_name = "randn"
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def randn(random_state, *dn, **kw):
+    r"""
+    Return a sample (or samples) from the "standard normal" distribution.
+
+    If positive, int_like or int-convertible arguments are provided,
+    `randn` generates an array of shape ``(d0, d1, ..., dn)``, filled
+    with random floats sampled from a univariate "normal" (Gaussian)
+    distribution of mean 0 and variance 1 (if any of the :math:`d_i` are
+    floats, they are first converted to integers by truncation). A single
+    float randomly sampled from the distribution is returned if no
+    argument is provided.
+
+    This is a convenience function.  If you want an interface that takes a
+    tuple as the first argument, use `numpy.random.standard_normal` instead.
+
+    Parameters
+    ----------
+    d0, d1, ..., dn : int, optional
+        The dimensions of the returned tensor, should be all positive.
+        If no argument is given a single Python float is returned.
+
+    Returns
+    -------
+    Z : Tensor or float
+        A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from
+        the standard normal distribution, or a single such float if
+        no parameters were supplied.
+
+    See Also
+    --------
+    random.standard_normal : Similar, but takes a tuple as its argument.
+
+    Notes
+    -----
+    For random samples from :math:`N(\mu, \sigma^2)`, use:
+
+    ``sigma * mt.random.randn(...) + mu``
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.randn().execute()
+    2.1923875335537315 #random
+
+    Two-by-four tensor of samples from N(3, 6.25):
+
+    >>> (2.5 * mt.random.randn(2, 4) + 3).execute()
+    array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],  #random
+           [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]]) #random
+    """
+    if len(dn) == 1 and isinstance(dn[0], (tuple, list)):
+        raise TypeError("'tuple' object cannot be interpreted as an integer")
+    if "dtype" not in kw:
+        kw["dtype"] = np.dtype("f8")
+    chunk_size = kw.pop("chunk_size", None)
+
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandn(seed=seed, size=dn, **kw)
+
+    for key in op.extra_params:
+        if not key.startswith("_"):
+            raise ValueError(f"randn got unexpected key arguments {key}")
+
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/random_integers.py

@@ -0,0 +1,121 @@
+# 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 ...serialization.serializables import Int64Field
+from ..utils import gen_random_seeds
+from .core import TensorRandomOperatorMixin, TensorSimpleRandomData
+
+
+class TensorRandomIntegers(TensorSimpleRandomData, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_RANDOM_INTEGERS
+
+    _fields_ = "low", "high", "size"
+    low = Int64Field("low")
+    high = Int64Field("high")
+    _func_name = "random_integers"
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def random_integers(random_state, low, high=None, size=None, chunk_size=None, gpu=None):
+    """
+    Random integers of type mt.int between `low` and `high`, inclusive.
+
+    Return random integers of type mt.int from the "discrete uniform"
+    distribution in the closed interval [`low`, `high`].  If `high` is
+    None (the default), then results are from [1, `low`]. The np.int
+    type translates to the C long type used by Python 2 for "short"
+    integers and its precision is platform dependent.
+
+    This function has been deprecated. Use randint instead.
+
+    Parameters
+    ----------
+    low : int
+        Lowest (signed) integer to be drawn from the distribution (unless
+        ``high=None``, in which case this parameter is the *highest* such
+        integer).
+    high : int, optional
+        If provided, the largest (signed) integer to be drawn from the
+        distribution (see above for behavior if ``high=None``).
+    size : int or tuple of ints, optional
+        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
+        ``m * n * k`` samples are drawn.  Default is None, in which case a
+        single value is returned.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+
+    Returns
+    -------
+    out : int or Tensor of ints
+        `size`-shaped array of random integers from the appropriate
+        distribution, or a single such random int if `size` not provided.
+
+    See Also
+    --------
+    random.randint : Similar to `random_integers`, only for the half-open
+        interval [`low`, `high`), and 0 is the lowest value if `high` is
+        omitted.
+
+    Notes
+    -----
+    To sample from N evenly spaced floating-point numbers between a and b,
+    use::
+
+      a + (b - a) * (np.random.random_integers(N) - 1) / (N - 1.)
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.random_integers(5).execute()
+    4
+    >>> type(mt.random.random_integers(5).execute())
+    <type 'int'>
+    >>> mt.random.random_integers(5, size=(3,2)).execute()
+    array([[5, 4],
+           [3, 3],
+           [4, 5]])
+
+    Choose five random numbers from the set of five evenly-spaced
+    numbers between 0 and 2.5, inclusive (*i.e.*, from the set
+    :math:`{0, 5/8, 10/8, 15/8, 20/8}`):
+
+    >>> (2.5 * (mt.random.random_integers(5, size=(5,)) - 1) / 4.).execute()
+    array([ 0.625,  1.25 ,  0.625,  0.625,  2.5  ])
+
+    Roll two six sided dice 1000 times and sum the results:
+
+    >>> d1 = mt.random.random_integers(1, 6, 1000)
+    >>> d2 = mt.random.random_integers(1, 6, 1000)
+    >>> dsums = d1 + d2
+
+    Display results as a histogram:
+
+    >>> import matplotlib.pyplot as plt
+    >>> count, bins, ignored = plt.hist(dsums.execute(), 11, normed=True)
+    >>> plt.show()
+    """
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandomIntegers(
+        seed=seed, size=size, dtype=np.dtype(int), low=low, high=high, gpu=gpu
+    )
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/random_sample.py

@@ -0,0 +1,84 @@
+# 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 ..utils import gen_random_seeds
+from .core import TensorRandomOperatorMixin, TensorSimpleRandomData
+
+
+class TensorRandomSample(TensorSimpleRandomData, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_RANDOM_SAMPLE
+
+    _fields_ = ("size",)
+    _func_name = "random_sample"
+
+    def __call__(self, chunk_size):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def random_sample(random_state, size=None, chunk_size=None, gpu=None, dtype=None):
+    """
+    Return random floats in the half-open interval [0.0, 1.0).
+
+    Results are from the "continuous uniform" distribution over the
+    stated interval.  To sample :math:`Unif[a, b), b > a` multiply
+    the output of `random_sample` by `(b-a)` and add `a`::
+
+      (b - a) * random_sample() + a
+
+    Parameters
+    ----------
+    size : int or tuple of ints, optional
+        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
+        ``m * n * k`` samples are drawn.  Default is None, in which case a
+        single value is returned.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    dtype : data-type, optional
+      Data-type of the returned tensor.
+
+    Returns
+    -------
+    out : float or Tensor of floats
+        Array of random floats of shape `size` (unless ``size=None``, in which
+        case a single float is returned).
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.random_sample().execute()
+    0.47108547995356098
+    >>> type(mt.random.random_sample().execute())
+    <type 'float'>
+    >>> mt.random.random_sample((5,)).execute()
+    array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])
+
+    Three-by-two array of random numbers from [-5, 0):
+
+    >>> (5 * mt.random.random_sample((3, 2)) - 5).execute()
+    array([[-3.99149989, -0.52338984],
+           [-2.99091858, -0.79479508],
+           [-1.23204345, -1.75224494]])
+    """
+    if dtype is None:
+        dtype = np.dtype("f8")
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandomSample(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/rayleigh.py

@@ -0,0 +1,108 @@
+# 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 ...serialization.serializables import AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorRayleigh(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["scale"]
+    _op_type_ = opcodes.RAND_RAYLEIGH
+
+    _fields_ = "scale", "size"
+    scale = AnyField("scale")
+    _func_name = "rayleigh"
+
+    def __call__(self, scale, chunk_size=None):
+        return self.new_tensor([scale], None, raw_chunk_size=chunk_size)
+
+
+def rayleigh(random_state, scale=1.0, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Rayleigh distribution.
+
+    The :math:`\chi` and Weibull distributions are generalizations of the
+    Rayleigh.
+
+    Parameters
+    ----------
+    scale : float or array_like of floats, optional
+        Scale, also equals the mode. Should be >= 0. Default is 1.
+    size : int or tuple of ints, optional
+        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
+        ``m * n * k`` samples are drawn.  If size is ``None`` (default),
+        a single value is returned if ``scale`` is a scalar.  Otherwise,
+        ``mt.array(scale).size`` samples are drawn.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    dtype : data-type, optional
+      Data-type of the returned tensor.
+
+    Returns
+    -------
+    out : Tensor or scalar
+        Drawn samples from the parameterized Rayleigh distribution.
+
+    Notes
+    -----
+    The probability density function for the Rayleigh distribution is
+
+    .. math:: P(x;scale) = \frac{x}{scale^2}e^{\frac{-x^2}{2 \cdotp scale^2}}
+
+    The Rayleigh distribution would arise, for example, if the East
+    and North components of the wind velocity had identical zero-mean
+    Gaussian distributions.  Then the wind speed would have a Rayleigh
+    distribution.
+
+    References
+    ----------
+    .. [1] Brighton Webs Ltd., "Rayleigh Distribution,"
+           http://www.brighton-webs.co.uk/distributions/rayleigh.asp
+    .. [2] Wikipedia, "Rayleigh distribution"
+           http://en.wikipedia.org/wiki/Rayleigh_distribution
+
+    Examples
+    --------
+    Draw values from the distribution and plot the histogram
+
+    >>> import matplotlib.pyplot as plt
+    >>> import maxframe.tensor as mt
+
+    >>> values = plt.hist(mt.random.rayleigh(3, 100000).execute(), bins=200, normed=True)
+
+    Wave heights tend to follow a Rayleigh distribution. If the mean wave
+    height is 1 meter, what fraction of waves are likely to be larger than 3
+    meters?
+
+    >>> meanvalue = 1
+    >>> modevalue = mt.sqrt(2 / mt.pi) * meanvalue
+    >>> s = mt.random.rayleigh(modevalue, 1000000)
+
+    The percentage of waves larger than 3 meters is:
+
+    >>> (100.*mt.sum(s>3)/1000000.).execute()
+    0.087300000000000003
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().rayleigh(handle_array(scale), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRayleigh(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(scale, chunk_size=chunk_size)

maxframe/tensor/random/shuffle.py

@@ -0,0 +1,61 @@
+# 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 TENSOR_TYPE
+from ..datasource import tensor as astensor
+
+
+def shuffle(random_state, x, axis=0):
+    r"""
+    Modify a sequence in-place by shuffling its contents.
+    The order of sub-arrays is changed but their contents remains the same.
+
+    Parameters
+    ----------
+    x : array_like
+        The array or list to be shuffled.
+    axis : int, optional
+        The axis which `x` is shuffled along. Default is 0.
+
+    Returns
+    -------
+    None
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> rng = mt.random.RandomState()
+    >>> arr = mt.arange(10)
+    >>> rng.shuffle(arr)
+    >>> arr.execute()
+    array([0, 1, 4, 2, 8, 6, 5, 9, 3, 7]) # random
+
+    >>> arr = mt.arange(9).reshape((3, 3))
+    >>> rng.shuffle(arr)
+    >>> arr.execute()
+    array([[6, 7, 8], # random
+           [0, 1, 2],
+           [3, 4, 5]])
+    """
+    from .permutation import permutation
+
+    if isinstance(x, (list, np.ndarray, TENSOR_TYPE)):
+        x = astensor(x)
+    else:
+        raise TypeError("x should be list, numpy ndarray or tensor")
+
+    ret = permutation(random_state, x, axis=axis)
+    x.data = ret.data