maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/random/triangular.py

@@ -0,0 +1,117 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorTriangular(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["left", "mode", "right"]
+    _op_type_ = opcodes.RAND_TRIANGULAR
+
+    _fields_ = "left", "mode", "right", "size"
+    left = AnyField("left")
+    mode = AnyField("mode")
+    right = AnyField("right")
+    _func_name = "triangular"
+
+    def __call__(self, left, mode, right, chunk_size=None):
+        return self.new_tensor([left, mode, right], None, raw_chunk_size=chunk_size)
+
+
+def triangular(
+    random_state, left, mode, right, size=None, chunk_size=None, gpu=None, dtype=None
+):
+    r"""
+    Draw samples from the triangular distribution over the
+    interval ``[left, right]``.
+
+    The triangular distribution is a continuous probability
+    distribution with lower limit left, peak at mode, and upper
+    limit right. Unlike the other distributions, these parameters
+    directly define the shape of the pdf.
+
+    Parameters
+    ----------
+    left : float or array_like of floats
+        Lower limit.
+    mode : float or array_like of floats
+        The value where the peak of the distribution occurs.
+        The value should fulfill the condition ``left <= mode <= right``.
+    right : float or array_like of floats
+        Upper limit, should be larger than `left`.
+    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 ``left``, ``mode``, and ``right``
+        are all scalars.  Otherwise, ``mt.broadcast(left, mode, right).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 triangular distribution.
+
+    Notes
+    -----
+    The probability density function for the triangular distribution is
+
+    .. math:: P(x;l, m, r) = \begin{cases}
+              \frac{2(x-l)}{(r-l)(m-l)}& \text{for $l \leq x \leq m$},\\
+              \frac{2(r-x)}{(r-l)(r-m)}& \text{for $m \leq x \leq r$},\\
+              0& \text{otherwise}.
+              \end{cases}
+
+    The triangular distribution is often used in ill-defined
+    problems where the underlying distribution is not known, but
+    some knowledge of the limits and mode exists. Often it is used
+    in simulations.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Triangular distribution"
+           http://en.wikipedia.org/wiki/Triangular_distribution
+
+    Examples
+    --------
+    Draw values from the distribution and plot the histogram:
+
+    >>> import matplotlib.pyplot as plt
+    >>> import maxframe.tensor as mt
+    >>> h = plt.hist(mt.random.triangular(-3, 0, 8, 100000).execute(), bins=200,
+    ...              normed=True)
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .triangular(
+                handle_array(left), handle_array(mode), handle_array(right), size=(0,)
+            )
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorTriangular(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(left, mode, right, chunk_size=chunk_size)

maxframe/tensor/random/uniform.py

@@ -0,0 +1,129 @@
+# 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 TensorUniform(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["low", "high"]
+    _op_type_ = opcodes.RAND_UNIFORM
+
+    _fields_ = "low", "high", "size"
+    low = AnyField("low")
+    high = AnyField("high")
+    _func_name = "uniform"
+
+    def __call__(self, low, high, chunk_size=None):
+        return self.new_tensor([low, high], None, raw_chunk_size=chunk_size)
+
+
+def uniform(
+    random_state, low=0.0, high=1.0, size=None, chunk_size=None, gpu=None, dtype=None
+):
+    r"""
+    Draw samples from a uniform distribution.
+
+    Samples are uniformly distributed over the half-open interval
+    ``[low, high)`` (includes low, but excludes high).  In other words,
+    any value within the given interval is equally likely to be drawn
+    by `uniform`.
+
+    Parameters
+    ----------
+    low : float or array_like of floats, optional
+        Lower boundary of the output interval.  All values generated will be
+        greater than or equal to low.  The default value is 0.
+    high : float or array_like of floats
+        Upper boundary of the output interval.  All values generated will be
+        less than high.  The default value is 1.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 ``low`` and ``high`` are both scalars.
+        Otherwise, ``mt.broadcast(low, high).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 uniform distribution.
+
+    See Also
+    --------
+    randint : Discrete uniform distribution, yielding integers.
+    random_integers : Discrete uniform distribution over the closed
+                      interval ``[low, high]``.
+    random_sample : Floats uniformly distributed over ``[0, 1)``.
+    random : Alias for `random_sample`.
+    rand : Convenience function that accepts dimensions as input, e.g.,
+           ``rand(2,2)`` would generate a 2-by-2 array of floats,
+           uniformly distributed over ``[0, 1)``.
+
+    Notes
+    -----
+    The probability density function of the uniform distribution is
+
+    .. math:: p(x) = \frac{1}{b - a}
+
+    anywhere within the interval ``[a, b)``, and zero elsewhere.
+
+    When ``high`` == ``low``, values of ``low`` will be returned.
+    If ``high`` < ``low``, the results are officially undefined
+    and may eventually raise an error, i.e. do not rely on this
+    function to behave when passed arguments satisfying that
+    inequality condition.
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> s = mt.random.uniform(-1,0,1000)
+
+    All values are within the given interval:
+
+    >>> mt.all(s >= -1).execute()
+    True
+    >>> mt.all(s < 0).execute()
+    True
+
+    Display the histogram of the samples, along with the
+    probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> count, bins, ignored = plt.hist(s.execute(), 15, normed=True)
+    >>> plt.plot(bins, mt.ones_like(bins).execute(), linewidth=2, color='r')
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .uniform(handle_array(low), handle_array(high), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorUniform(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(low, high, chunk_size=chunk_size)

maxframe/tensor/random/vonmises.py

@@ -0,0 +1,129 @@
+# 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 TensorVonmises(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["mu", "kappa"]
+    _op_type_ = opcodes.RAND_VONMISES
+
+    _fields_ = "mu", "kappa", "size"
+    mu = AnyField("mu")
+    kappa = AnyField("kappa")
+    _func_name = "vonmises"
+
+    def __call__(self, mu, kappa, chunk_size=None):
+        return self.new_tensor([mu, kappa], None, raw_chunk_size=chunk_size)
+
+
+def vonmises(random_state, mu, kappa, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a von Mises distribution.
+
+    Samples are drawn from a von Mises distribution with specified mode
+    (mu) and dispersion (kappa), on the interval [-pi, pi].
+
+    The von Mises distribution (also known as the circular normal
+    distribution) is a continuous probability distribution on the unit
+    circle.  It may be thought of as the circular analogue of the normal
+    distribution.
+
+    Parameters
+    ----------
+    mu : float or array_like of floats
+        Mode ("center") of the distribution.
+    kappa : float or array_like of floats
+        Dispersion of the distribution, has to 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 ``mu`` and ``kappa`` are both scalars.
+        Otherwise, ``np.broadcast(mu, kappa).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 von Mises distribution.
+
+    See Also
+    --------
+    scipy.stats.vonmises : probability density function, distribution, or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the von Mises distribution is
+
+    .. math:: p(x) = \frac{e^{\kappa cos(x-\mu)}}{2\pi I_0(\kappa)},
+
+    where :math:`\mu` is the mode and :math:`\kappa` the dispersion,
+    and :math:`I_0(\kappa)` is the modified Bessel function of order 0.
+
+    The von Mises is named for Richard Edler von Mises, who was born in
+    Austria-Hungary, in what is now the Ukraine.  He fled to the United
+    States in 1939 and became a professor at Harvard.  He worked in
+    probability theory, aerodynamics, fluid mechanics, and philosophy of
+    science.
+
+    References
+    ----------
+    .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). "Handbook of
+           Mathematical Functions with Formulas, Graphs, and Mathematical
+           Tables, 9th printing," New York: Dover, 1972.
+    .. [2] von Mises, R., "Mathematical Theory of Probability
+           and Statistics", New York: Academic Press, 1964.
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mu, kappa = 0.0, 4.0 # mean and dispersion
+    >>> s = mt.random.vonmises(mu, kappa, 1000)
+
+    Display the histogram of the samples, along with
+    the probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.special import i0
+    >>> plt.hist(s.execute(), 50, normed=True)
+    >>> x = mt.linspace(-mt.pi, mt.pi, num=51)
+    >>> y = mt.exp(kappa*mt.cos(x-mu))/(2*mt.pi*i0(kappa))
+    >>> plt.plot(x.execute(), y.execute(), linewidth=2, color='r')
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .vonmises(handle_array(mu), handle_array(kappa), size=(0,))
+            .dtype
+        )
+
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorVonmises(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(mu, kappa, chunk_size=chunk_size)

maxframe/tensor/random/wald.py

@@ -0,0 +1,112 @@
+# 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 TensorWald(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["mean", "scale"]
+    _op_type_ = opcodes.RAND_WALD
+
+    _fields_ = "mean", "scale", "size"
+    mean = AnyField("mean")
+    scale = AnyField("scale")
+    _func_name = "wald"
+
+    def __call__(self, mean, scale, chunk_size=None):
+        return self.new_tensor([mean, scale], None, raw_chunk_size=chunk_size)
+
+
+def wald(random_state, mean, scale, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Wald, or inverse Gaussian, distribution.
+
+    As the scale approaches infinity, the distribution becomes more like a
+    Gaussian. Some references claim that the Wald is an inverse Gaussian
+    with mean equal to 1, but this is by no means universal.
+
+    The inverse Gaussian distribution was first studied in relationship to
+    Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian
+    because there is an inverse relationship between the time to cover a
+    unit distance and distance covered in unit time.
+
+    Parameters
+    ----------
+    mean : float or array_like of floats
+        Distribution mean, should be > 0.
+    scale : float or array_like of floats
+        Scale 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 ``mean`` and ``scale`` are both scalars.
+        Otherwise, ``np.broadcast(mean, 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 Wald distribution.
+
+    Notes
+    -----
+    The probability density function for the Wald distribution is
+
+    .. math:: P(x;mean,scale) = \sqrt{\frac{scale}{2\pi x^3}}e^
+                                \frac{-scale(x-mean)^2}{2\cdotp mean^2x}
+
+    As noted above the inverse Gaussian distribution first arise
+    from attempts to model Brownian motion. It is also a
+    competitor to the Weibull for use in reliability modeling and
+    modeling stock returns and interest rate processes.
+
+    References
+    ----------
+    .. [1] Brighton Webs Ltd., Wald Distribution,
+           http://www.brighton-webs.co.uk/distributions/wald.asp
+    .. [2] Chhikara, Raj S., and Folks, J. Leroy, "The Inverse Gaussian
+           Distribution: Theory : Methodology, and Applications", CRC Press,
+           1988.
+    .. [3] Wikipedia, "Wald distribution"
+           http://en.wikipedia.org/wiki/Wald_distribution
+
+    Examples
+    --------
+    Draw values from the distribution and plot the histogram:
+
+    >>> import matplotlib.pyplot as plt
+    >>> import maxframe.tensor as mt
+    >>> h = plt.hist(mt.random.wald(3, 2, 100000).execute(), bins=200, normed=True)
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .wald(handle_array(mean), handle_array(scale), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorWald(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(mean, scale, chunk_size=chunk_size)

maxframe/tensor/random/weibull.py

@@ -0,0 +1,138 @@
+# 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 TensorWeibull(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["a"]
+    _op_type_ = opcodes.RAND_WEIBULL
+
+    _fields_ = "a", "size"
+    a = AnyField("a")
+    _func_name = "weibull"
+
+    def __call__(self, a, chunk_size=None):
+        return self.new_tensor([a], None, raw_chunk_size=chunk_size)
+
+
+def weibull(random_state, a, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Weibull distribution.
+
+    Draw samples from a 1-parameter Weibull distribution with the given
+    shape parameter `a`.
+
+    .. math:: X = (-ln(U))^{1/a}
+
+    Here, U is drawn from the uniform distribution over (0,1].
+
+    The more common 2-parameter Weibull, including a scale parameter
+    :math:`\lambda` is just :math:`X = \lambda(-ln(U))^{1/a}`.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Should be greater than zero.
+    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`` is a scalar.  Otherwise,
+        ``mt.array(a).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 Weibull distribution.
+
+    See Also
+    --------
+    scipy.stats.weibull_max
+    scipy.stats.weibull_min
+    scipy.stats.genextreme
+    gumbel
+
+    Notes
+    -----
+    The Weibull (or Type III asymptotic extreme value distribution
+    for smallest values, SEV Type III, or Rosin-Rammler
+    distribution) is one of a class of Generalized Extreme Value
+    (GEV) distributions used in modeling extreme value problems.
+    This class includes the Gumbel and Frechet distributions.
+
+    The probability density for the Weibull distribution is
+
+    .. math:: p(x) = \frac{a}
+                     {\lambda}(\frac{x}{\lambda})^{a-1}e^{-(x/\lambda)^a},
+
+    where :math:`a` is the shape and :math:`\lambda` the scale.
+
+    The function has its peak (the mode) at
+    :math:`\lambda(\frac{a-1}{a})^{1/a}`.
+
+    When ``a = 1``, the Weibull distribution reduces to the exponential
+    distribution.
+
+    References
+    ----------
+    .. [1] Waloddi Weibull, Royal Technical University, Stockholm,
+           1939 "A Statistical Theory Of The Strength Of Materials",
+           Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,
+           Generalstabens Litografiska Anstalts Forlag, Stockholm.
+    .. [2] Waloddi Weibull, "A Statistical Distribution Function of
+           Wide Applicability", Journal Of Applied Mechanics ASME Paper
+           1951.
+    .. [3] Wikipedia, "Weibull distribution",
+           http://en.wikipedia.org/wiki/Weibull_distribution
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> a = 5. # shape
+    >>> s = mt.random.weibull(a, 1000)
+
+    Display the histogram of the samples, along with
+    the probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = mt.arange(1,100.)/50.
+    >>> def weib(x,n,a):
+    ...     return (a / n) * (x / n)**(a - 1) * mt.exp(-(x / n)**a)
+
+    >>> count, bins, ignored = plt.hist(mt.random.weibull(5.,1000).execute())
+    >>> x = mt.arange(1,100.)/50.
+    >>> scale = count.max()/weib(x, 1., 5.).max()
+    >>> plt.plot(x.execute(), (weib(x, 1., 5.)*scale).execute())
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().weibull(handle_array(a), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorWeibull(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(a, chunk_size=chunk_size)