maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/tensor/random/standard_cauchy.py

@@ -0,0 +1,105 @@
+#!/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 gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin
+
+
+class TensorStandardCauchy(TensorDistribution, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_STANDARD_CAUCHY
+    _func_name = "standard_cauchy"
+    _fields_ = ("size",)
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def standard_cauchy(random_state, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a standard Cauchy distribution with mode = 0.
+
+    Also known as the Lorentz distribution.
+
+    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
+    -------
+    samples : Tensor or scalar
+        The drawn samples.
+
+    Notes
+    -----
+    The probability density function for the full Cauchy distribution is
+
+    .. math:: P(x; x_0, \gamma) = \frac{1}{\pi \gamma \bigl[ 1+
+              (\frac{x-x_0}{\gamma})^2 \bigr] }
+
+    and the Standard Cauchy distribution just sets :math:`x_0=0` and
+    :math:`\gamma=1`
+
+    The Cauchy distribution arises in the solution to the driven harmonic
+    oscillator problem, and also describes spectral line broadening. It
+    also describes the distribution of values at which a line tilted at
+    a random angle will cut the x axis.
+
+    When studying hypothesis tests that assume normality, seeing how the
+    tests perform on data from a Cauchy distribution is a good indicator of
+    their sensitivity to a heavy-tailed distribution, since the Cauchy looks
+    very much like a Gaussian distribution, but with heavier tails.
+
+    References
+    ----------
+    .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, "Cauchy
+          Distribution",
+          http://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm
+    .. [2] Weisstein, Eric W. "Cauchy Distribution." From MathWorld--A
+          Wolfram Web Resource.
+          http://mathworld.wolfram.com/CauchyDistribution.html
+    .. [3] Wikipedia, "Cauchy distribution"
+          http://en.wikipedia.org/wiki/Cauchy_distribution
+
+    Examples
+    --------
+    Draw samples and plot the distribution:
+
+    >>> import maxframe.tensor as mt
+    >>> import matplotlib.pyplot as plt
+
+    >>> s = mt.random.standard_cauchy(1000000)
+    >>> s = s[(s>-25) & (s<25)]  # truncate distribution so it plots well
+    >>> plt.hist(s.execute(), bins=100)
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().standard_cauchy(size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorStandardCauchy(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/standard_exponential.py

@@ -0,0 +1,72 @@
+#!/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 gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin
+
+
+class TensorStandardExponential(TensorDistribution, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_STANDARD_EXPONENTIAL
+    _func_name = "standard_exponential"
+    _fields_ = ("size",)
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def standard_exponential(
+    random_state, size=None, chunk_size=None, gpu=None, dtype=None
+):
+    """
+    Draw samples from the standard exponential distribution.
+
+    `standard_exponential` is identical to the exponential distribution
+    with a scale parameter of 1.
+
+    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
+        Drawn samples.
+
+    Examples
+    --------
+    Output a 3x8000 tensor:
+
+    >>> import maxframe.tensor as mt
+    >>> n = mt.random.standard_exponential((3, 8000))
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().standard_exponential(size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorStandardExponential(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/standard_gamma.py

@@ -0,0 +1,120 @@
+#!/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 ...serialization.serializables import AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorStandardGamma(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["shape"]
+    _op_type_ = opcodes.RAND_STANDARD_GAMMMA
+
+    _fields_ = "shape", "size"
+    shape = AnyField("shape")
+    _func_name = "standard_gamma"
+
+    def __call__(self, shape, chunk_size=None):
+        return self.new_tensor([shape], None, raw_chunk_size=chunk_size)
+
+
+def standard_gamma(
+    random_state, shape, size=None, chunk_size=None, gpu=None, dtype=None
+):
+    r"""
+    Draw samples from a standard Gamma distribution.
+
+    Samples are drawn from a Gamma distribution with specified parameters,
+    shape (sometimes designated "k") and scale=1.
+
+    Parameters
+    ----------
+    shape : float or array_like of floats
+        Parameter, should be > 0.
+    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 ``shape`` is a scalar.  Otherwise,
+        ``mt.array(shape).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 standard gamma distribution.
+
+    See Also
+    --------
+    scipy.stats.gamma : probability density function, distribution or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the Gamma distribution is
+
+    .. math:: p(x) = x^{k-1}\frac{e^{-x/\theta}}{\theta^k\Gamma(k)},
+
+    where :math:`k` is the shape and :math:`\theta` the scale,
+    and :math:`\Gamma` is the Gamma function.
+
+    The Gamma distribution is often used to model the times to failure of
+    electronic components, and arises naturally in processes for which the
+    waiting times between Poisson distributed events are relevant.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Gamma Distribution." From MathWorld--A
+           Wolfram Web Resource.
+           http://mathworld.wolfram.com/GammaDistribution.html
+    .. [2] Wikipedia, "Gamma distribution",
+           http://en.wikipedia.org/wiki/Gamma_distribution
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> shape, scale = 2., 1. # mean and width
+    >>> s = mt.random.standard_gamma(shape, 1000000)
+
+    Display the histogram of the samples, along with
+    the probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> import scipy.special as sps
+    >>> count, bins, ignored = plt.hist(s.execute(), 50, normed=True)
+    >>> y = bins**(shape-1) * ((mt.exp(-bins/scale))/ \
+    ...                       (sps.gamma(shape) * scale**shape))
+    >>> plt.plot(bins, y.execute(), linewidth=2, color='r')
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState().standard_gamma(handle_array(shape), size=(0,)).dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorStandardGamma(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(shape, chunk_size=chunk_size)

maxframe/tensor/random/standard_normal.py

@@ -0,0 +1,74 @@
+#!/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 gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin
+
+
+class TensorStandardNormal(TensorDistribution, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_STANDARD_NORMAL
+    _func_name = "standard_normal"
+    _fields_ = ("size",)
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def standard_normal(random_state, size=None, chunk_size=None, gpu=None, dtype=None):
+    """
+    Draw samples from a standard Normal distribution (mean=0, stdev=1).
+
+    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
+        Drawn samples.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> s = mt.random.standard_normal(8000)
+    >>> s.execute()
+    array([ 0.6888893 ,  0.78096262, -0.89086505, ...,  0.49876311, #random
+           -0.38672696, -0.4685006 ])                               #random
+    >>> s.shape
+    (8000,)
+    >>> s = mt.random.standard_normal(size=(3, 4, 2))
+    >>> s.shape
+    (3, 4, 2)
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().standard_normal(size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorStandardNormal(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/standard_t.py

@@ -0,0 +1,135 @@
+#!/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 ...serialization.serializables import AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorStandardT(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["df"]
+    _op_type_ = opcodes.RAND_STANDARD_T
+
+    _fields_ = "df", "size"
+    df = AnyField("df")
+    _func_name = "standard_t"
+
+    def __call__(self, df, chunk_size=None):
+        return self.new_tensor([df], None, raw_chunk_size=chunk_size)
+
+
+def standard_t(random_state, df, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a standard Student's t distribution with `df` degrees
+    of freedom.
+
+    A special case of the hyperbolic distribution.  As `df` gets
+    large, the result resembles that of the standard normal
+    distribution (`standard_normal`).
+
+    Parameters
+    ----------
+    df : float or array_like of floats
+        Degrees of freedom, should be > 0.
+    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 ``df`` is a scalar.  Otherwise,
+        ``mt.array(df).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 standard Student's t distribution.
+
+    Notes
+    -----
+    The probability density function for the t distribution is
+
+    .. math:: P(x, df) = \frac{\Gamma(\frac{df+1}{2})}{\sqrt{\pi df}
+              \Gamma(\frac{df}{2})}\Bigl( 1+\frac{x^2}{df} \Bigr)^{-(df+1)/2}
+
+    The t test is based on an assumption that the data come from a
+    Normal distribution. The t test provides a way to test whether
+    the sample mean (that is the mean calculated from the data) is
+    a good estimate of the true mean.
+
+    The derivation of the t-distribution was first published in
+    1908 by William Gosset while working for the Guinness Brewery
+    in Dublin. Due to proprietary issues, he had to publish under
+    a pseudonym, and so he used the name Student.
+
+    References
+    ----------
+    .. [1] Dalgaard, Peter, "Introductory Statistics With R",
+           Springer, 2002.
+    .. [2] Wikipedia, "Student's t-distribution"
+           http://en.wikipedia.org/wiki/Student's_t-distribution
+
+    Examples
+    --------
+    From Dalgaard page 83 [1]_, suppose the daily energy intake for 11
+    women in Kj is:
+
+    >>> import maxframe.tensor as mt
+
+    >>> intake = mt.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \
+    ...                    7515, 8230, 8770])
+
+    Does their energy intake deviate systematically from the recommended
+    value of 7725 kJ?
+
+    We have 10 degrees of freedom, so is the sample mean within 95% of the
+    recommended value?
+
+    >>> s = mt.random.standard_t(10, size=100000)
+    >>> mt.mean(intake).execute()
+    6753.636363636364
+    >>> intake.std(ddof=1).execute()
+    1142.1232221373727
+
+    Calculate the t statistic, setting the ddof parameter to the unbiased
+    value so the divisor in the standard deviation will be degrees of
+    freedom, N-1.
+
+    >>> t = (mt.mean(intake)-7725)/(intake.std(ddof=1)/mt.sqrt(len(intake)))
+    >>> import matplotlib.pyplot as plt
+    >>> h = plt.hist(s.execute(), bins=100, normed=True)
+
+    For a one-sided t-test, how far out in the distribution does the t
+    statistic appear?
+
+    >>> (mt.sum(s<t) / float(len(s))).execute()
+    0.0090699999999999999  #random
+
+    So the p-value is about 0.009, which says the null hypothesis has a
+    probability of about 99% of being true.
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().standard_t(handle_array(df), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorStandardT(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(df, chunk_size=chunk_size)

maxframe/tensor/random/tests/__init__.py

@@ -0,0 +1,15 @@
+#!/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.

maxframe/tensor/random/tests/test_random.py

@@ -0,0 +1,167 @@
+#!/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
+import pytest
+
+from ....serialization import deserialize, serialize
+from ....serialization.serializables import Serializable
+from ...datasource import tensor as from_ndarray
+from .. import (
+    RandomState,
+    TensorPermutation,
+    beta,
+    choice,
+    multivariate_normal,
+    permutation,
+    rand,
+    randint,
+    randn,
+    shuffle,
+)
+from ..core import RandomStateField
+
+
+class ObjWithRandomStateField(Serializable):
+    random_state = RandomStateField("random_state")
+
+
+@pytest.mark.parametrize("rs", [None, np.random.RandomState()])
+def test_serial_random_state_field(rs):
+    res = deserialize(*serialize(ObjWithRandomStateField(rs)))
+    if rs is None:
+        assert res.random_state is None
+    else:
+        original_state = rs.get_state()
+        new_state = res.random_state.get_state()
+        assert original_state[0] == new_state[0]
+        np.testing.assert_array_equal(original_state[1], new_state[1])
+
+
+def test_random():
+    arr = rand(2, 3)
+
+    assert arr.dtype is not None
+
+    arr = beta(1, 2, chunk_size=2)
+    assert arr.shape == ()
+
+    arr = beta([1, 2], [3, 4], chunk_size=2)
+    assert arr.shape == (2,)
+
+    arr = beta(
+        [[2, 3]],
+        from_ndarray([[4, 6], [5, 2]], chunk_size=2),
+        chunk_size=1,
+        size=(3, 2, 2),
+    )
+    assert arr.shape == (3, 2, 2)
+
+
+def test_same_key():
+    assert RandomState(0).rand(10).key == RandomState(0).rand(10).key
+
+
+def test_choice():
+    t = choice(5, chunk_size=1)
+    assert t.shape == ()
+
+    t = choice(5, 3, chunk_size=1)
+    assert t.shape == (3,)
+
+    t = choice(5, 3, replace=False)
+    assert t.shape == (3,)
+
+    with pytest.raises(ValueError):
+        choice(-1)
+
+    # a should be 1-d
+    with pytest.raises(ValueError):
+        choice(np.random.rand(2, 2))
+
+    # p sum != 1
+    with pytest.raises(ValueError):
+        choice(np.random.rand(3), p=[0.2, 0.2, 0.2])
+
+    # p should b 1-d
+    with pytest.raises(ValueError):
+        choice(np.random.rand(3), p=[[0.2, 0.6, 0.2]])
+
+    # replace=False, choice size cannot be greater than a.size
+    with pytest.raises(ValueError):
+        choice(np.random.rand(10), 11, replace=False)
+
+    # replace=False, choice size cannot be greater than a.size
+    with pytest.raises(ValueError):
+        choice(np.random.rand(10), (3, 4), replace=False)
+
+
+def test_multivariate_normal():
+    mean = [0, 0]
+    cov = [[1, 0], [0, 100]]
+
+    t = multivariate_normal(mean, cov, 5000, chunk_size=500)
+    assert t.shape == (5000, 2)
+    assert t.op.size == (5000,)
+
+
+def test_randint():
+    arr = randint(1, 2, size=(10, 9), dtype="f8", density=0.01, chunk_size=2)
+    assert arr.shape == (10, 9)
+
+
+def test_unexpected_key():
+    with pytest.raises(ValueError):
+        rand(10, 10, chunks=5)
+
+    with pytest.raises(ValueError):
+        randn(10, 10, chunks=5)
+
+
+def test_permutation():
+    x = permutation(10)
+
+    assert x.shape == (10,)
+    assert isinstance(x.op, TensorPermutation)
+
+    arr = from_ndarray([1, 4, 9, 12, 15], chunk_size=2)
+    x = permutation(arr)
+
+    assert x.shape == (5,)
+    assert isinstance(x.op, TensorPermutation)
+
+    arr = rand(3, 3, chunk_size=2)
+    x = permutation(arr)
+
+    assert x.shape == (3, 3)
+    assert isinstance(x.op, TensorPermutation)
+
+    with pytest.raises(np.AxisError):
+        pytest.raises(permutation("abc"))
+
+
+def test_shuffle():
+    with pytest.raises(TypeError):
+        shuffle("abc")
+
+    x = rand(10, 10, chunk_size=2)
+    shuffle(x)
+    assert isinstance(x.op, TensorPermutation)
+
+    x = rand(10, 10, chunk_size=2)
+    shuffle(x, axis=1)
+    assert isinstance(x.op, TensorPermutation)
+    assert x.op.axis == 1