maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/tensor/operators.py

@@ -0,0 +1,123 @@
+# 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.
+
+from ..core import OutputType
+from ..core.operator import (
+    Fuse,
+    HasInput,
+    MapReduceOperator,
+    Operator,
+    ShuffleProxy,
+    TileableOperatorMixin,
+)
+from ..serialization.serializables import DataTypeField
+from ..utils import calc_nsplits
+
+
+class TensorOperatorMixin(TileableOperatorMixin):
+    __slots__ = ()
+    _op_module_ = "tensor"
+    _output_type_ = OutputType.tensor
+
+    def new_tensors(
+        self,
+        inputs,
+        shape=None,
+        dtype=None,
+        order=None,
+        chunks=None,
+        nsplits=None,
+        output_limit=None,
+        kws=None,
+        **kw
+    ):
+        return self.new_tileables(
+            inputs,
+            shape=shape,
+            chunks=chunks,
+            nsplits=nsplits,
+            output_limit=output_limit,
+            kws=kws,
+            dtype=dtype,
+            order=order,
+            **kw
+        )
+
+    def new_tensor(self, inputs, shape, dtype=None, order=None, **kw):
+        if getattr(self, "output_limit") != 1:
+            raise TypeError("cannot new tensor with more than 1 outputs")
+        return self.new_tensors(inputs, shape=shape, dtype=dtype, order=order, **kw)[0]
+
+    @classmethod
+    def concat_tileable_chunks(cls, tileable):
+        from .merge.concatenate import TensorConcatenate
+
+        tensor = tileable
+        assert not tensor.is_coarse()
+
+        op = TensorConcatenate(dtype=tensor.dtype)
+        chunk = TensorConcatenate(dtype=tensor.dtype).new_chunk(
+            tensor.chunks, shape=tensor.shape, index=(0,) * tileable.ndim
+        )
+        return op.new_tensor(
+            [tensor],
+            tensor.shape,
+            chunks=[chunk],
+            nsplits=tuple((s,) for s in tensor.shape),
+        )
+
+    @classmethod
+    def create_tileable_from_chunks(cls, chunks, inputs=None, **kw):
+        chunk_idx_to_shape = {c.index: c.shape for c in chunks}
+        nsplits = calc_nsplits(chunk_idx_to_shape)
+        shape = tuple(sum(ns) for ns in nsplits)
+        op = chunks[0].op.copy().reset_key()
+        return op.new_tensor(
+            inputs,
+            shape=shape,
+            chunks=chunks,
+            nsplits=nsplits,
+            dtype=chunks[0].dtype,
+            **kw
+        )
+
+
+class TensorOperator(Operator):
+    _output_type_ = OutputType.tensor
+
+    dtype = DataTypeField("dtype", default=None)
+
+
+class TensorHasInput(HasInput):
+    _output_type_ = OutputType.tensor
+
+    dtype = DataTypeField("dtype", default=None)
+
+
+class TensorShuffleProxy(ShuffleProxy, TensorOperatorMixin):
+    _output_type_ = OutputType.tensor
+
+    dtype = DataTypeField("dtype", default=None)
+
+
+class TensorMapReduceOperator(MapReduceOperator):
+    _output_type_ = OutputType.tensor
+
+    dtype = DataTypeField("dtype", default=None)
+
+
+class TensorFuse(Fuse):
+    _output_type_ = OutputType.tensor
+
+    dtype = DataTypeField("dtype", default=None)

maxframe/tensor/random/__init__.py

@@ -0,0 +1,168 @@
+#!/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.
+
+from .beta import TensorRandBeta, beta
+from .binomial import TensorBinomial, binomial
+from .bytes import bytes
+from .chisquare import TensorChisquareDist, chisquare
+from .choice import TensorChoice, choice
+from .core import RandomState, RandomStateField, _random_state
+from .dirichlet import TensorDirichlet, dirichlet
+from .exponential import TensorExponential, exponential
+from .f import TensorF, f
+from .gamma import TensorRandGamma, gamma
+from .geometric import TensorGeometric, geometric
+from .gumbel import TensorGumbel, gumbel
+from .hypergeometric import TensorHypergeometric, hypergeometric
+from .laplace import TensorLaplace, laplace
+from .logistic import TensorLogistic, logistic
+from .lognormal import TensorLognormal, lognormal
+from .logseries import TensorLogseries, logseries
+from .multinomial import TensorMultinomial, multinomial
+from .multivariate_normal import TensorMultivariateNormal, multivariate_normal
+from .negative_binomial import TensorNegativeBinomial, negative_binomial
+from .noncentral_chisquare import TensorNoncentralChisquare, noncentral_chisquare
+from .noncentral_f import TensorNoncentralF, noncentral_f
+from .normal import TensorNormal, normal
+from .pareto import TensorPareto, pareto
+from .permutation import TensorPermutation, permutation
+from .poisson import TensorPoisson, poisson
+from .power import TensorRandomPower, power
+from .rand import TensorRand, rand
+from .randint import TensorRandint, randint
+from .randn import TensorRandn, randn
+from .random_integers import TensorRandomIntegers, random_integers
+from .random_sample import TensorRandomSample, random_sample
+from .rayleigh import TensorRayleigh, rayleigh
+from .shuffle import shuffle
+from .standard_cauchy import TensorStandardCauchy, standard_cauchy
+from .standard_exponential import TensorStandardExponential, standard_exponential
+from .standard_gamma import TensorStandardGamma, standard_gamma
+from .standard_normal import TensorStandardNormal, standard_normal
+from .standard_t import TensorStandardT, standard_t
+from .triangular import TensorTriangular, triangular
+from .uniform import TensorUniform, uniform
+from .vonmises import TensorVonmises, vonmises
+from .wald import TensorWald, wald
+from .weibull import TensorWeibull, weibull
+from .zipf import TensorZipf, zipf
+
+
+def _install():
+    setattr(RandomState, "rand", rand)
+    setattr(RandomState, "randn", randn)
+    setattr(RandomState, "randint", randint)
+    setattr(RandomState, "random_integers", random_integers)
+    setattr(RandomState, "random_sample", random_sample)
+    setattr(RandomState, "ranf", random_sample)
+    setattr(RandomState, "random", random_sample)
+    setattr(RandomState, "sample", random_sample)
+    setattr(RandomState, "choice", choice)
+    setattr(RandomState, "bytes", bytes)
+    setattr(RandomState, "beta", beta)
+    setattr(RandomState, "binomial", binomial)
+    setattr(RandomState, "chisquare", chisquare)
+    setattr(RandomState, "dirichlet", dirichlet)
+    setattr(RandomState, "exponential", exponential)
+    setattr(RandomState, "f", f)
+    setattr(RandomState, "gamma", gamma)
+    setattr(RandomState, "geometric", geometric)
+    setattr(RandomState, "gumbel", gumbel)
+    setattr(RandomState, "hypergeometric", hypergeometric)
+    setattr(RandomState, "laplace", laplace)
+    setattr(RandomState, "logistic", logistic)
+    setattr(RandomState, "lognormal", lognormal)
+    setattr(RandomState, "logseries", logseries)
+    setattr(RandomState, "multinomial", multinomial)
+    setattr(RandomState, "multivariate_normal", multivariate_normal)
+    setattr(RandomState, "negative_binomial", negative_binomial)
+    setattr(RandomState, "noncentral_chisquare", noncentral_chisquare)
+    setattr(RandomState, "noncentral_f", noncentral_f)
+    setattr(RandomState, "normal", normal)
+    setattr(RandomState, "pareto", pareto)
+    setattr(RandomState, "poisson", poisson)
+    setattr(RandomState, "power", power)
+    setattr(RandomState, "rayleigh", rayleigh)
+    setattr(RandomState, "standard_cauchy", standard_cauchy)
+    setattr(RandomState, "standard_exponential", standard_exponential)
+    setattr(RandomState, "standard_gamma", standard_gamma)
+    setattr(RandomState, "standard_normal", standard_normal)
+    setattr(RandomState, "standard_t", standard_t)
+    setattr(RandomState, "triangular", triangular)
+    setattr(RandomState, "uniform", uniform)
+    setattr(RandomState, "vonmises", vonmises)
+    setattr(RandomState, "wald", wald)
+    setattr(RandomState, "weibull", weibull)
+    setattr(RandomState, "zipf", zipf)
+    setattr(RandomState, "permutation", permutation)
+    setattr(RandomState, "shuffle", shuffle)
+
+
+_install()
+del _install
+
+
+seed = _random_state.seed
+
+rand = _random_state.rand
+randn = _random_state.randn
+randint = _random_state.randint
+random_integers = _random_state.random_integers
+random_sample = _random_state.random_sample
+random = _random_state.random
+ranf = _random_state.ranf
+sample = _random_state.sample
+choice = _random_state.choice
+bytes = _random_state.bytes
+
+permutation = _random_state.permutation
+shuffle = _random_state.shuffle
+
+beta = _random_state.beta
+binomial = _random_state.binomial
+chisquare = _random_state.chisquare
+dirichlet = _random_state.dirichlet
+exponential = _random_state.exponential
+f = _random_state.f
+gamma = _random_state.gamma
+geometric = _random_state.geometric
+gumbel = _random_state.gumbel
+hypergeometric = _random_state.hypergeometric
+laplace = _random_state.laplace
+logistic = _random_state.logistic
+lognormal = _random_state.lognormal
+logseries = _random_state.logseries
+multinomial = _random_state.multinomial
+multivariate_normal = _random_state.multivariate_normal
+negative_binomial = _random_state.negative_binomial
+noncentral_chisquare = _random_state.noncentral_chisquare
+noncentral_f = _random_state.noncentral_f
+normal = _random_state.normal
+pareto = _random_state.pareto
+poisson = _random_state.poisson
+power = _random_state.power
+rayleigh = _random_state.rayleigh
+standard_cauchy = _random_state.standard_cauchy
+standard_exponential = _random_state.standard_exponential
+standard_gamma = _random_state.standard_gamma
+standard_normal = _random_state.standard_normal
+standard_t = _random_state.standard_t
+triangular = _random_state.triangular
+uniform = _random_state.uniform
+vonmises = _random_state.vonmises
+wald = _random_state.wald
+weibull = _random_state.weibull
+zipf = _random_state.zipf

maxframe/tensor/random/beta.py

@@ -0,0 +1,87 @@
+# 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 TensorRandBeta(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["a", "b"]
+    _op_type_ = opcodes.RAND_BETA
+
+    _fields_ = "a", "b", "size"
+    a = AnyField("a")
+    b = AnyField("b")
+    _func_name = "beta"
+
+    def __call__(self, a, b, chunk_size=None):
+        return self.new_tensor([a, b], None, raw_chunk_size=chunk_size)
+
+
+def beta(random_state, a, b, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Beta distribution.
+
+    The Beta distribution is a special case of the Dirichlet distribution,
+    and is related to the Gamma distribution.  It has the probability
+    distribution function
+
+    .. math:: f(x; a,b) = \frac{1}{B(\alpha, \beta)} x^{\alpha - 1}
+                                                     (1 - x)^{\beta - 1},
+
+    where the normalisation, B, is the beta function,
+
+    .. math:: B(\alpha, \beta) = \int_0^1 t^{\alpha - 1}
+                                 (1 - t)^{\beta - 1} dt.
+
+    It is often seen in Bayesian inference and order statistics.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Alpha, non-negative.
+    b : float or array_like of floats
+        Beta, non-negative.
+    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 ``a`` and ``b`` are both scalars.
+        Otherwise, ``mt.broadcast(a, b).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 beta distribution.
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .beta(handle_array(a), handle_array(b), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandBeta(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(a, b, chunk_size=chunk_size)

maxframe/tensor/random/binomial.py

@@ -0,0 +1,137 @@
+#!/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 TensorBinomial(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["n", "p"]
+    _op_type_ = opcodes.RAND_BINOMIAL
+
+    _fields_ = "n", "p", "size"
+    n = AnyField("n")
+    p = AnyField("p")
+    _func_name = "binomial"
+
+    def __call__(self, n, p, chunk_size=None):
+        return self.new_tensor([n, p], None, raw_chunk_size=chunk_size)
+
+
+def binomial(random_state, n, p, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a binomial distribution.
+
+    Samples are drawn from a binomial distribution with specified
+    parameters, n trials and p probability of success where
+    n an integer >= 0 and p is in the interval [0,1]. (n may be
+    input as a float, but it is truncated to an integer in use)
+
+    Parameters
+    ----------
+    n : int or array_like of ints
+        Parameter of the distribution, >= 0. Floats are also accepted,
+        but they will be truncated to integers.
+    p : float or array_like of floats
+        Parameter of the distribution, >= 0 and <=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 ``n`` and ``p`` are both scalars.
+        Otherwise, ``mt.broadcast(n, p).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 binomial distribution, where
+        each sample is equal to the number of successes over the n trials.
+
+    See Also
+    --------
+    scipy.stats.binom : probability density function, distribution or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the binomial distribution is
+
+    .. math:: P(N) = \binom{n}{N}p^N(1-p)^{n-N},
+
+    where :math:`n` is the number of trials, :math:`p` is the probability
+    of success, and :math:`N` is the number of successes.
+
+    When estimating the standard error of a proportion in a population by
+    using a random sample, the normal distribution works well unless the
+    product p*n <=5, where p = population proportion estimate, and n =
+    number of samples, in which case the binomial distribution is used
+    instead. For example, a sample of 15 people shows 4 who are left
+    handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,
+    so the binomial distribution should be used in this case.
+
+    References
+    ----------
+    .. [1] Dalgaard, Peter, "Introductory Statistics with R",
+           Springer-Verlag, 2002.
+    .. [2] Glantz, Stanton A. "Primer of Biostatistics.", McGraw-Hill,
+           Fifth Edition, 2002.
+    .. [3] Lentner, Marvin, "Elementary Applied Statistics", Bogden
+           and Quigley, 1972.
+    .. [4] Weisstein, Eric W. "Binomial Distribution." From MathWorld--A
+           Wolfram Web Resource.
+           http://mathworld.wolfram.com/BinomialDistribution.html
+    .. [5] Wikipedia, "Binomial distribution",
+           http://en.wikipedia.org/wiki/Binomial_distribution
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> n, p = 10, .5  # number of trials, probability of each trial
+    >>> s = mt.random.binomial(n, p, 1000).execute()
+    # result of flipping a coin 10 times, tested 1000 times.
+
+    A real world example. A company drills 9 wild-cat oil exploration
+    wells, each with an estimated probability of success of 0.1. All nine
+    wells fail. What is the probability of that happening?
+
+    Let's do 20,000 trials of the model, and count the number that
+    generate zero positive results.
+
+    >>> (mt.sum(mt.random.binomial(9, 0.1, 20000) == 0)/20000.).execute()
+    # answer = 0.38885, or 38%.
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .binomial(handle_array(n), handle_array(p), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorBinomial(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(n, p, chunk_size=chunk_size)

maxframe/tensor/random/bytes.py

@@ -0,0 +1,39 @@
+#!/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.
+
+
+def bytes(random_state, length):
+    """
+    Return random bytes.
+
+    Parameters
+    ----------
+    length : int
+        Number of random bytes.
+
+    Returns
+    -------
+    out : str
+        String of length `length`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.bytes(10)
+    ' eh\x85\x022SZ\xbf\xa4' #random
+    """
+    return random_state._random_state.bytes(length)

maxframe/tensor/random/chisquare.py

@@ -0,0 +1,110 @@
+#!/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 TensorChisquareDist(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["df"]
+    _op_type_ = opcodes.RAND_CHISQUARE
+
+    _fields_ = "df", "size"
+    df = AnyField("df")
+    _func_name = "chisquare"
+
+    def __call__(self, df, chunk_size=None):
+        return self.new_tensor([df], self.size, raw_chunk_size=chunk_size)
+
+
+def chisquare(random_state, df, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a chi-square distribution.
+
+    When `df` independent random variables, each with standard normal
+    distributions (mean 0, variance 1), are squared and summed, the
+    resulting distribution is chi-square (see Notes).  This distribution
+    is often used in hypothesis testing.
+
+    Parameters
+    ----------
+    df : float or array_like of floats
+         Number of 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 chi-square distribution.
+
+    Raises
+    ------
+    ValueError
+        When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)
+        is given.
+
+    Notes
+    -----
+    The variable obtained by summing the squares of `df` independent,
+    standard normally distributed random variables:
+
+    .. math:: Q = \sum_{i=0}^{\mathtt{df}} X^2_i
+
+    is chi-square distributed, denoted
+
+    .. math:: Q \sim \chi^2_k.
+
+    The probability density function of the chi-squared distribution is
+
+    .. math:: p(x) = \frac{(1/2)^{k/2}}{\Gamma(k/2)}
+                     x^{k/2 - 1} e^{-x/2},
+
+    where :math:`\Gamma` is the gamma function,
+
+    .. math:: \Gamma(x) = \int_0^{-\infty} t^{x - 1} e^{-t} dt.
+
+    References
+    ----------
+    .. [1] NIST "Engineering Statistics Handbook"
+           http://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.chisquare(2,4).execute()
+    array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272])
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().chisquare(handle_array(df), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorChisquareDist(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(df, chunk_size=chunk_size)