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

maxframe/tensor/special/ellip_harm.py

@@ -0,0 +1,55 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..utils import implement_scipy, infer_scipy_dtype
+from .core import TensorSpecialMultiOp, _register_special_op
+
+
+@_register_special_op
+class TensorEllipHarm(TensorSpecialMultiOp):
+    _ARG_COUNT = 5
+    _func_name = "ellip_harm"
+
+
+@implement_scipy("scipy.special.ellip_harm")
+@infer_scipy_dtype("scipy.special.ellip_harm")
+def ellip_harm(h2, k2, n, p, s, signm=1, signn=1, **kwargs):
+    op = TensorEllipHarm(**kwargs)
+    return op(h2, k2, n, p, s, signm, signn)
+
+
+@_register_special_op
+class TensorEllipHarm2(TensorSpecialMultiOp):
+    _ARG_COUNT = 5
+    _func_name = "ellip_harm_2"
+
+
+@implement_scipy("scipy.special.ellip_harm_2")
+@infer_scipy_dtype("scipy.special.ellip_harm_2")
+def ellip_harm_2(h2, k2, n, p, s, **kwargs):
+    op = TensorEllipHarm2(**kwargs)
+    return op(h2, k2, n, p, s)
+
+
+@_register_special_op
+class TensorEllipNormal(TensorSpecialMultiOp):
+    _ARG_COUNT = 4
+    _func_name = "ellip_normal"
+
+
+@implement_scipy("scipy.special.ellip_normal")
+@infer_scipy_dtype("scipy.special.ellip_normal")
+def ellip_normal(h2, k2, n, p, **kwargs):
+    op = TensorEllipNormal(**kwargs)
+    return op(h2, k2, n, p)

maxframe/tensor/special/err_fresnel.py

@@ -0,0 +1,223 @@
+# 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 ..arithmetic.utils import arithmetic_operator
+from ..utils import implement_scipy, infer_scipy_dtype
+from .core import (
+    TensorSpecialMultiOp,
+    TensorSpecialUnaryOp,
+    TensorSpecialUnaryTupleOp,
+    _register_special_op,
+)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorErf(TensorSpecialUnaryOp):
+    _func_name = "erf"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorErfc(TensorSpecialUnaryOp):
+    _func_name = "erfc"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorErfcx(TensorSpecialUnaryOp):
+    _func_name = "erfcx"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorErfi(TensorSpecialUnaryOp):
+    _func_name = "erfi"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorErfinv(TensorSpecialUnaryOp):
+    _func_name = "erfinv"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorErfcinv(TensorSpecialUnaryOp):
+    _func_name = "erfcinv"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorWofz(TensorSpecialUnaryOp):
+    _func_name = "wofz"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorDawsn(TensorSpecialUnaryOp):
+    _func_name = "dawsn"
+
+
+@_register_special_op
+class TensorFresnel(TensorSpecialUnaryTupleOp):
+    _func_name = "fresnel"
+    _n_outputs = 2
+
+
+@_register_special_op
+class TensorModFresnelP(TensorSpecialUnaryTupleOp):
+    _func_name = "modfresnelp"
+    _n_outputs = 2
+
+
+@_register_special_op
+class TensorModFresnelM(TensorSpecialUnaryTupleOp):
+    _func_name = "modfresnelm"
+    _n_outputs = 2
+
+
+@_register_special_op
+class TensorVoigtProfile(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "voigt_profile"
+
+
+@implement_scipy("scipy.special.erf")
+@infer_scipy_dtype("scipy.special.erf")
+def erf(x, out=None, where=None, **kwargs):
+    """
+    Returns the error function of complex argument.
+
+    It is defined as ``2/sqrt(pi)*integral(exp(-t**2), t=0..z)``.
+
+    Parameters
+    ----------
+    x : Tensor
+        Input tensor.
+
+    Returns
+    -------
+    res : Tensor
+        The values of the error function at the given points `x`.
+
+    See Also
+    --------
+    erfc, erfinv, erfcinv, wofz, erfcx, erfi
+
+    Notes
+    -----
+    The cumulative of the unit normal distribution is given by
+    ``Phi(z) = 1/2[1 + erf(z/sqrt(2))]``.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover,
+        1972. http://www.math.sfu.ca/~cbm/aands/page_297.htm
+    .. [3] Steven G. Johnson, Faddeeva W function implementation.
+       http://ab-initio.mit.edu/Faddeeva
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> from maxframe.tensor import special
+    >>> import matplotlib.pyplot as plt
+    >>> x = mt.linspace(-3, 3)
+    >>> plt.plot(x, special.erf(x))
+    >>> plt.xlabel('$x$')
+    >>> plt.ylabel('$erf(x)$')
+    >>> plt.show()
+    """
+    op = TensorErf(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.erfc")
+@infer_scipy_dtype("scipy.special.erfc")
+def erfc(x, out=None, where=None, **kwargs):
+    op = TensorErfc(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.erfcx")
+@infer_scipy_dtype("scipy.special.erfcx")
+def erfcx(x, out=None, where=None, **kwargs):
+    op = TensorErfcx(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.erfi")
+@infer_scipy_dtype("scipy.special.erfi")
+def erfi(x, out=None, where=None, **kwargs):
+    op = TensorErfi(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.erfinv")
+@infer_scipy_dtype("scipy.special.erfinv")
+def erfinv(x, out=None, where=None, **kwargs):
+    op = TensorErfinv(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.erfcinv")
+@infer_scipy_dtype("scipy.special.erfcinv")
+def erfcinv(x, out=None, where=None, **kwargs):
+    op = TensorErfcinv(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.wofz")
+@infer_scipy_dtype("scipy.special.wofz")
+def wofz(x, out=None, where=None, **kwargs):
+    op = TensorWofz(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.dawsn")
+@infer_scipy_dtype("scipy.special.dawsn")
+def dawsn(x, out=None, where=None, **kwargs):
+    op = TensorDawsn(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@implement_scipy("scipy.special.fresnel")
+@infer_scipy_dtype("scipy.special.fresnel", multi_outputs=True)
+def fresnel(x, out=None, **kwargs):
+    op = TensorFresnel(**kwargs)
+    return op(x, out=out)
+
+
+@implement_scipy("scipy.special.modfresnelp")
+@infer_scipy_dtype("scipy.special.modfresnelp", multi_outputs=True)
+def modfresnelp(x, out=None, **kwargs):
+    op = TensorModFresnelP(**kwargs)
+    return op(x, out=out)
+
+
+@implement_scipy("scipy.special.modfresnelm")
+@infer_scipy_dtype("scipy.special.modfresnelm", multi_outputs=True)
+def modfresnelm(x, out=None, **kwargs):
+    op = TensorModFresnelM(**kwargs)
+    return op(x, out=out)
+
+
+@implement_scipy("scipy.special.voigt_profile")
+@infer_scipy_dtype("scipy.special.voigt_profile")
+def voigt_profile(x, sigma, gamma, **kwargs):
+    op = TensorVoigtProfile(**kwargs)
+    return op(x, sigma, gamma)

maxframe/tensor/special/gamma_funcs.py

@@ -0,0 +1,303 @@
+# 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 ..arithmetic.utils import arithmetic_operator
+from ..utils import implement_scipy, infer_scipy_dtype
+from .core import (
+    TensorSpecialBinOp,
+    TensorSpecialMultiOp,
+    TensorSpecialUnaryOp,
+    _register_special_op,
+)
+
+
+class NoOrderSpecialMixin:
+    @classmethod
+    def _get_func(cls, xp):
+        func = super()._get_func(xp)
+
+        def _wrapped(*args, **kw):
+            kw.pop("order", None)
+            return func(*args, **kw)
+
+        return _wrapped
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorGamma(TensorSpecialUnaryOp):
+    _func_name = "gamma"
+
+
+@implement_scipy("scipy.special.gamma")
+@infer_scipy_dtype("scipy.special.gamma")
+def gamma(x, **kwargs):
+    op = TensorGamma(**kwargs)
+    return op(x)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorGammaln(TensorSpecialUnaryOp):
+    _func_name = "gammaln"
+
+
+@implement_scipy("scipy.special.gammaln")
+@infer_scipy_dtype("scipy.special.gammaln")
+def gammaln(x, out=None, where=None, **kwargs):
+    """
+    Logarithm of the absolute value of the Gamma function.
+
+    Parameters
+    ----------
+    x : array-like
+        Values on the real line at which to compute ``gammaln``
+    out : Tensor, None, or tuple of Tensor and None, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the inputs broadcast to. If not provided or `None`,
+        a freshly-allocated tensor is returned. A tuple (possible only as a
+        keyword argument) must have length equal to the number of outputs.
+    where : array_like, optional
+        Values of True indicate to calculate the ufunc at that position, values
+        of False indicate to leave the value in the output alone.
+    **kwargs
+
+    Returns
+    -------
+    gammaln : Tensor
+        Values of ``gammaln`` at x.
+
+    See Also
+    --------
+    gammasgn : sign of the gamma function
+    loggamma : principal branch of the logarithm of the gamma function
+
+    Notes
+    -----
+    When used in conjunction with `gammasgn`, this function is useful
+    for working in logspace on the real axis without having to deal with
+    complex numbers, via the relation ``exp(gammaln(x)) = gammasgn(x)*gamma(x)``.
+
+    For complex-valued log-gamma, use `loggamma` instead of `gammaln`.
+    """
+    op = TensorGammaln(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorLogGamma(TensorSpecialUnaryOp):
+    _func_name = "loggamma"
+
+
+@implement_scipy("scipy.special.loggamma")
+@infer_scipy_dtype("scipy.special.loggamma")
+def loggamma(x, **kwargs):
+    op = TensorLogGamma(**kwargs)
+    return op(x)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorGammaSgn(TensorSpecialUnaryOp):
+    _func_name = "gammasgn"
+
+
+@implement_scipy("scipy.special.gammasgn")
+@infer_scipy_dtype("scipy.special.gammasgn")
+def gammasgn(x, **kwargs):
+    op = TensorGammaSgn(**kwargs)
+    return op(x)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorGammaInc(TensorSpecialBinOp):
+    _func_name = "gammainc"
+
+
+@implement_scipy("scipy.special.gammainc")
+@infer_scipy_dtype("scipy.special.gammainc")
+def gammainc(a, b, **kwargs):
+    op = TensorGammaInc(**kwargs)
+    return op(a, b)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorGammaIncInv(TensorSpecialBinOp):
+    _func_name = "gammaincinv"
+
+
+@implement_scipy("scipy.special.gammaincinv")
+@infer_scipy_dtype("scipy.special.gammaincinv")
+def gammaincinv(a, b, **kwargs):
+    op = TensorGammaIncInv(**kwargs)
+    return op(a, b)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorGammaIncc(TensorSpecialBinOp):
+    _func_name = "gammaincc"
+
+
+@implement_scipy("scipy.special.gammainc")
+@infer_scipy_dtype("scipy.special.gammainc")
+def gammaincc(a, b, **kwargs):
+    op = TensorGammaIncc(**kwargs)
+    return op(a, b)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorGammaInccInv(TensorSpecialBinOp):
+    _func_name = "gammainccinv"
+
+
+@implement_scipy("scipy.special.gammainccinv")
+@infer_scipy_dtype("scipy.special.gammainccinv")
+def gammainccinv(a, b, **kwargs):
+    op = TensorGammaInccInv(**kwargs)
+    return op(a, b)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorBeta(TensorSpecialBinOp):
+    _func_name = "beta"
+
+
+@implement_scipy("scipy.special.beta")
+@infer_scipy_dtype("scipy.special.beta")
+def beta(a, b, out=None, **kwargs):
+    op = TensorBeta(**kwargs)
+    return op(a, b, out=out)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorBetaLn(TensorSpecialBinOp):
+    _func_name = "betaln"
+
+
+@implement_scipy("scipy.special.betaln")
+@infer_scipy_dtype("scipy.special.betaln")
+def betaln(a, b, out=None, **kwargs):
+    op = TensorBetaLn(**kwargs)
+    return op(a, b, out=out)
+
+
+@_register_special_op
+class TensorBetaInc(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "betainc"
+
+
+@implement_scipy("scipy.special.betainc")
+@infer_scipy_dtype("scipy.special.betainc")
+def betainc(a, b, x, out=None, **kwargs):
+    op = TensorBetaInc(**kwargs)
+    return op(a, b, x, out=out)
+
+
+@_register_special_op
+class TensorBetaIncInv(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "betaincinv"
+
+
+@implement_scipy("scipy.special.betaincinv")
+@infer_scipy_dtype("scipy.special.betaincinv")
+def betaincinv(a, b, y, out=None, **kwargs):
+    op = TensorBetaIncInv(**kwargs)
+    return op(a, b, y, out=out)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorPsi(TensorSpecialUnaryOp):
+    _func_name = "psi"
+
+
+@implement_scipy("scipy.special.psi")
+@infer_scipy_dtype("scipy.special.psi")
+def psi(x, out=None, **kwargs):
+    op = TensorPsi(**kwargs)
+    return op(x, out=out)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorRGamma(TensorSpecialUnaryOp):
+    _func_name = "rgamma"
+
+
+@implement_scipy("scipy.special.rgamma")
+@infer_scipy_dtype("scipy.special.rgamma")
+def rgamma(x, out=None, **kwargs):
+    op = TensorRGamma(**kwargs)
+    return op(x, out=out)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorPolyGamma(NoOrderSpecialMixin, TensorSpecialBinOp):
+    _func_name = "polygamma"
+
+
+@implement_scipy("scipy.special.polygamma")
+@infer_scipy_dtype("scipy.special.polygamma")
+def polygamma(a, b, **kwargs):
+    op = TensorPolyGamma(**kwargs)
+    return op(a, b)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorMultiGammaLn(NoOrderSpecialMixin, TensorSpecialBinOp):
+    _func_name = "multigammaln"
+
+
+@implement_scipy("scipy.special.multigammaln")
+@infer_scipy_dtype("scipy.special.multigammaln")
+def multigammaln(a, b, **kwargs):
+    op = TensorMultiGammaLn(**kwargs)
+    return op(a, b)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorDiGamma(TensorSpecialUnaryOp):
+    _func_name = "digamma"
+
+
+@implement_scipy("scipy.special.digamma")
+@infer_scipy_dtype("scipy.special.digamma")
+def digamma(x, out=None, **kwargs):
+    op = TensorDiGamma(**kwargs)
+    return op(x, out=out)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorPoch(TensorSpecialBinOp):
+    _func_name = "poch"
+
+
+@implement_scipy("scipy.special.poch")
+@infer_scipy_dtype("scipy.special.poch")
+def poch(a, b, **kwargs):
+    op = TensorPoch(**kwargs)
+    return op(a, b)

maxframe/tensor/special/hypergeometric_funcs.py

@@ -0,0 +1,69 @@
+# 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 ..arithmetic.utils import arithmetic_operator
+from ..utils import implement_scipy, infer_scipy_dtype
+from .core import TensorSpecialBinOp, TensorSpecialMultiOp, _register_special_op
+
+
+@_register_special_op
+class TensorHYP2F1(TensorSpecialMultiOp):
+    _ARG_COUNT = 4
+    _func_name = "hyp2f1"
+
+
+@implement_scipy("scipy.special.hyp2f1")
+@infer_scipy_dtype("scipy.special.hyp2f1")
+def hyp2f1(a, b, c, z, **kwargs):
+    op = TensorHYP2F1(**kwargs)
+    return op(a, b, c, z)
+
+
+@_register_special_op
+class TensorHYP1F1(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "hyp1f1"
+
+
+@implement_scipy("scipy.special.hyp1f1")
+@infer_scipy_dtype("scipy.special.hyp1f1")
+def hyp1f1(a, b, x, out=None, **kwargs):
+    op = TensorHYP1F1(**kwargs)
+    return op(a, b, x, out=out)
+
+
+@_register_special_op
+class TensorHYPERU(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "hyperu"
+
+
+@implement_scipy("scipy.special.hyperu")
+@infer_scipy_dtype("scipy.special.hyperu")
+def hyperu(a, b, x, out=None, **kwargs):
+    op = TensorHYPERU(**kwargs)
+    return op(a, b, x, out=out)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorHYP0F1(TensorSpecialBinOp):
+    _func_name = "hyp0f1"
+
+
+@implement_scipy("scipy.special.hyp0f1")
+@infer_scipy_dtype("scipy.special.hyp0f1")
+def hyp0f1(v, z, out=None, **kwargs):
+    op = TensorHYP0F1(**kwargs)
+    return op(v, z, out=out)