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

maxframe/tensor/special/__init__.py

@@ -12,26 +12,164 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .misc import softmax, softplus
-from .statistical import (
-    TensorExpit,
-    TensorLogExpit,
-    TensorLogit,
-    expit,
-    log_expit,
-    logit,
-)
+try:
+    import scipy
 
+    from .airy import TensorAiry, TensorAirye, TensorItairy, airy, airye, itairy
+    from .bessel import (
+        TensorHankel1,
+        TensorHankel1e,
+        TensorHankel2,
+        TensorHankel2e,
+        TensorIV,
+        TensorIVE,
+        TensorJV,
+        TensorJVE,
+        TensorKN,
+        TensorKV,
+        TensorKVE,
+        TensorYN,
+        TensorYV,
+        TensorYVE,
+        hankel1,
+        hankel1e,
+        hankel2,
+        hankel2e,
+        iv,
+        ive,
+        jv,
+        jve,
+        kn,
+        kv,
+        kve,
+        yn,
+        yv,
+        yve,
+    )
+    from .ellip_func_integrals import (
+        TensorEllipe,
+        TensorEllipeinc,
+        TensorEllipk,
+        TensorEllipkinc,
+        TensorEllipkm1,
+        TensorElliprc,
+        TensorElliprd,
+        TensorElliprf,
+        TensorElliprg,
+        TensorElliprj,
+        ellipe,
+        ellipeinc,
+        ellipk,
+        ellipkinc,
+        ellipkm1,
+        elliprc,
+        elliprd,
+        elliprf,
+        elliprg,
+        elliprj,
+    )
+    from .ellip_harm import (
+        TensorEllipHarm,
+        TensorEllipHarm2,
+        TensorEllipNormal,
+        ellip_harm,
+        ellip_harm_2,
+        ellip_normal,
+    )
+    from .err_fresnel import (
+        TensorDawsn,
+        TensorErf,
+        TensorErfc,
+        TensorErfcinv,
+        TensorErfcx,
+        TensorErfi,
+        TensorErfinv,
+        TensorFresnel,
+        TensorModFresnelM,
+        TensorModFresnelP,
+        TensorVoigtProfile,
+        TensorWofz,
+        dawsn,
+        erf,
+        erfc,
+        erfcinv,
+        erfcx,
+        erfi,
+        erfinv,
+        fresnel,
+        modfresnelm,
+        modfresnelp,
+        voigt_profile,
+        wofz,
+    )
+    from .gamma_funcs import (
+        TensorBeta,
+        TensorBetaInc,
+        TensorBetaIncInv,
+        TensorBetaLn,
+        TensorDiGamma,
+        TensorGamma,
+        TensorGammaInc,
+        TensorGammaIncc,
+        TensorGammaInccInv,
+        TensorGammaIncInv,
+        TensorGammaln,
+        TensorGammaSgn,
+        TensorLogGamma,
+        TensorMultiGammaLn,
+        TensorPoch,
+        TensorPolyGamma,
+        TensorPsi,
+        TensorRGamma,
+        beta,
+        betainc,
+        betaincinv,
+        betaln,
+        digamma,
+        gamma,
+        gammainc,
+        gammaincc,
+        gammainccinv,
+        gammaincinv,
+        gammaln,
+        gammasgn,
+        loggamma,
+        multigammaln,
+        poch,
+        polygamma,
+        psi,
+        rgamma,
+    )
+    from .hypergeometric_funcs import (
+        TensorHYP0F1,
+        TensorHYP1F1,
+        TensorHYP2F1,
+        TensorHYPERU,
+        hyp0f1,
+        hyp1f1,
+        hyp2f1,
+        hyperu,
+    )
+    from .info_theory import (
+        TensorEntr,
+        TensorKlDiv,
+        TensorRelEntr,
+        entr,
+        kl_div,
+        rel_entr,
+    )
+    from .misc import TensorXLogY, softmax, softplus, xlogy
+    from .statistical import (
+        TensorExpit,
+        TensorLogExpit,
+        TensorLogit,
+        expit,
+        log_expit,
+        logit,
+    )
+except ImportError:  # pragma: no cover
+    pass
 
-def _clear_nones():
-    """Remove unsupported functions"""
-    erase_key = []
-    for member, val in globals().items():
-        if val is None:
-            erase_key.append(member)
-    for key in erase_key:
-        globals().pop(key, None)
-
-
-_clear_nones()
-del _clear_nones
+_names_to_del = [_name for _name, _val in globals().items() if _val is None]
+[globals().pop(_name) for _name in _names_to_del]
+del _names_to_del

maxframe/tensor/special/airy.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 TensorSpecialUnaryTupleOp, _register_special_op
+
+
+@_register_special_op
+class TensorAiry(TensorSpecialUnaryTupleOp):
+    _func_name = "airy"
+    _n_outputs = 4
+
+
+@implement_scipy("scipy.special.airy")
+@infer_scipy_dtype("scipy.special.airy", multi_outputs=True)
+def airy(z, out=None, **kwargs):
+    op = TensorAiry(**kwargs)
+    return op(z, out=out)
+
+
+@_register_special_op
+class TensorAirye(TensorSpecialUnaryTupleOp):
+    _func_name = "airye"
+    _n_outputs = 4
+
+
+@implement_scipy("scipy.special.airye")
+@infer_scipy_dtype("scipy.special.airye", multi_outputs=True)
+def airye(z, out=None, **kwargs):
+    op = TensorAirye(**kwargs)
+    return op(z, out=out)
+
+
+@_register_special_op
+class TensorItairy(TensorSpecialUnaryTupleOp):
+    _func_name = "itairy"
+    _n_outputs = 4
+
+
+@implement_scipy("scipy.special.itairy")
+@infer_scipy_dtype("scipy.special.itairy", multi_outputs=True)
+def itairy(x, out=None, **kwargs):
+    op = TensorItairy(**kwargs)
+    return op(x, out=out)

maxframe/tensor/special/bessel.py

@@ -0,0 +1,199 @@
+# 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, _register_special_op
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorJV(TensorSpecialBinOp):
+    _func_name = "jv"
+
+
+@implement_scipy("scipy.special.jv")
+@infer_scipy_dtype("scipy.special.jv")
+def jv(v, z, **kwargs):
+    op = TensorJV(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorJVE(TensorSpecialBinOp):
+    _func_name = "jve"
+
+
+@implement_scipy("scipy.special.jve")
+@infer_scipy_dtype("scipy.special.jve")
+def jve(v, z, **kwargs):
+    op = TensorJVE(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorYN(TensorSpecialBinOp):
+    _func_name = "yn"
+
+
+@implement_scipy("scipy.special.yn")
+@infer_scipy_dtype("scipy.special.yn")
+def yn(n, x, **kwargs):
+    op = TensorYN(**kwargs)
+    return op(n, x)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorYV(TensorSpecialBinOp):
+    _func_name = "yv"
+
+
+@implement_scipy("scipy.special.yv")
+@infer_scipy_dtype("scipy.special.yv")
+def yv(v, z, **kwargs):
+    op = TensorYV(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorYVE(TensorSpecialBinOp):
+    _func_name = "yve"
+
+
+@implement_scipy("scipy.special.yve")
+@infer_scipy_dtype("scipy.special.yve")
+def yve(v, z, **kwargs):
+    op = TensorYVE(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorKN(TensorSpecialBinOp):
+    _func_name = "kn"
+
+
+@implement_scipy("scipy.special.kn")
+@infer_scipy_dtype("scipy.special.kn")
+def kn(n, x, **kwargs):
+    op = TensorKN(**kwargs)
+    return op(n, x)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorKV(TensorSpecialBinOp):
+    _func_name = "kv"
+
+
+@implement_scipy("scipy.special.kv")
+@infer_scipy_dtype("scipy.special.kv")
+def kv(v, z, **kwargs):
+    op = TensorKV(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorKVE(TensorSpecialBinOp):
+    _func_name = "kve"
+
+
+@implement_scipy("scipy.special.kve")
+@infer_scipy_dtype("scipy.special.kve")
+def kve(v, z, **kwargs):
+    op = TensorKVE(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorIV(TensorSpecialBinOp):
+    _func_name = "iv"
+
+
+@implement_scipy("scipy.special.iv")
+@infer_scipy_dtype("scipy.special.iv")
+def iv(v, z, **kwargs):
+    op = TensorIV(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorIVE(TensorSpecialBinOp):
+    _func_name = "ive"
+
+
+@implement_scipy("scipy.special.ive")
+@infer_scipy_dtype("scipy.special.ive")
+def ive(v, z, **kwargs):
+    op = TensorIVE(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorHankel1(TensorSpecialBinOp):
+    _func_name = "hankel1"
+
+
+@implement_scipy("scipy.special.hankel1")
+@infer_scipy_dtype("scipy.special.hankel1")
+def hankel1(v, z, **kwargs):
+    op = TensorHankel1(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorHankel1e(TensorSpecialBinOp):
+    _func_name = "hankel1e"
+
+
+@implement_scipy("scipy.special.hankel1e")
+@infer_scipy_dtype("scipy.special.hankel1e")
+def hankel1e(v, z, **kwargs):
+    op = TensorHankel1e(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorHankel2(TensorSpecialBinOp):
+    _func_name = "hankel2"
+
+
+@implement_scipy("scipy.special.hankel2")
+@infer_scipy_dtype("scipy.special.hankel2")
+def hankel2(v, z, **kwargs):
+    op = TensorHankel2(**kwargs)
+    return op(v, z)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorHankel2e(TensorSpecialBinOp):
+    _func_name = "hankel2e"
+
+
+@implement_scipy("scipy.special.hankel2e")
+@infer_scipy_dtype("scipy.special.hankel2e")
+def hankel2e(v, z, **kwargs):
+    op = TensorHankel2e(**kwargs)
+    return op(v, z)

maxframe/tensor/special/core.py

@@ -12,8 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import numpy as np
+
+try:
+    import scipy.special as spspecial
+except ImportError:
+    spspecial = None
+
 from ... import opcodes
-from ..arithmetic.core import TensorUnaryOp
+from ...core import ExecutableTuple
+from ...serialization.serializables import StringField
+from ..arithmetic.core import TensorBinOp, TensorMultiOp, TensorUnaryOp
+from ..datasource import tensor as astensor
 
 _func_name_to_special_cls = {}
 
@@ -29,10 +39,61 @@ class TensorSpecialOperatorMixin:
     _func_name = None
 
     def __new__(cls, *args, **kwargs):
-        if cls._func_name is not None:
-            return object.__new__(_func_name_to_special_cls[cls._func_name])
+        func_name = kwargs.get("func_name", cls._func_name)
+        kwargs["func_name"] = func_name
+        if func_name is not None:
+            return object.__new__(_func_name_to_special_cls[func_name])
         return super().__new__(cls, *args, **kwargs)
 
 
 class TensorSpecialUnaryOp(TensorSpecialOperatorMixin, TensorUnaryOp):
-    pass
+    func_name = StringField("func_name")
+
+
+class TensorSpecialBinOp(TensorSpecialOperatorMixin, TensorBinOp):
+    func_name = StringField("func_name")
+
+
+class TensorSpecialMultiOp(TensorSpecialOperatorMixin, TensorMultiOp):
+    func_name = StringField("func_name")
+
+
+class TensorSpecialUnaryTupleOp(TensorSpecialUnaryOp):
+    @property
+    def output_limit(self):
+        return self._n_outputs
+
+    def __call__(self, x, out=None):
+        x = astensor(x)
+
+        if out is not None:
+            if not isinstance(out, ExecutableTuple):
+                raise TypeError(
+                    f"out should be ExecutableTuple object, got {type(out)} instead"
+                )
+            if len(out) != self._n_outputs:
+                raise TypeError(
+                    "out should be an ExecutableTuple object with "
+                    f"{self._n_outputs} elements, got {len(out)} instead"
+                )
+
+        func = getattr(spspecial, self._func_name)
+        res = func(np.ones(x.shape, dtype=x.dtype))
+        res_tensors = self.new_tensors(
+            [x],
+            kws=[
+                {
+                    "side": f"{self._func_name}[{i}]",
+                    "dtype": output.dtype,
+                    "shape": output.shape,
+                }
+                for i, output in enumerate(res)
+            ],
+        )
+
+        if out is None:
+            return ExecutableTuple(res_tensors)
+
+        for res_tensor, out_tensor in zip(res_tensors, out):
+            out_tensor.data = res_tensor.data
+        return out

maxframe/tensor/special/ellip_func_integrals.py

@@ -0,0 +1,155 @@
+# 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,
+)
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorEllipk(TensorSpecialUnaryOp):
+    _func_name = "ellipk"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorEllipkm1(TensorSpecialUnaryOp):
+    _func_name = "ellipkm1"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorEllipkinc(TensorSpecialBinOp):
+    _func_name = "ellipkinc"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorEllipe(TensorSpecialUnaryOp):
+    _func_name = "ellipe"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorEllipeinc(TensorSpecialBinOp):
+    _func_name = "ellipeinc"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="binary_and")
+class TensorElliprc(TensorSpecialBinOp):
+    _func_name = "elliprc"
+
+
+@_register_special_op
+class TensorElliprd(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "elliprd"
+
+
+@_register_special_op
+class TensorElliprf(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "elliprf"
+
+
+@_register_special_op
+class TensorElliprg(TensorSpecialMultiOp):
+    _ARG_COUNT = 3
+    _func_name = "elliprg"
+
+
+@_register_special_op
+class TensorElliprj(TensorSpecialMultiOp):
+    _ARG_COUNT = 4
+    _func_name = "elliprj"
+
+
+@implement_scipy("scipy.special.ellipk")
+@infer_scipy_dtype("scipy.special.ellipk")
+def ellipk(x, **kwargs):
+    op = TensorEllipk(**kwargs)
+    return op(x)
+
+
+@implement_scipy("scipy.special.ellipkm1")
+@infer_scipy_dtype("scipy.special.ellipkm1")
+def ellipkm1(x, **kwargs):
+    op = TensorEllipkm1(**kwargs)
+    return op(x)
+
+
+@implement_scipy("scipy.special.ellipkinc")
+@infer_scipy_dtype("scipy.special.ellipkinc")
+def ellipkinc(phi, m, **kwargs):
+    op = TensorEllipkinc(**kwargs)
+    return op(phi, m)
+
+
+@implement_scipy("scipy.special.ellipe")
+@infer_scipy_dtype("scipy.special.ellipe")
+def ellipe(x, **kwargs):
+    op = TensorEllipe(**kwargs)
+    return op(x)
+
+
+@implement_scipy("scipy.special.ellipeinc")
+@infer_scipy_dtype("scipy.special.ellipeinc")
+def ellipeinc(phi, m, **kwargs):
+    op = TensorEllipeinc(**kwargs)
+    return op(phi, m)
+
+
+try:
+
+    @implement_scipy("scipy.special.elliprc")
+    @infer_scipy_dtype("scipy.special.elliprc")
+    def elliprc(x, y, **kwargs):
+        op = TensorElliprc(**kwargs)
+        return op(x, y)
+
+    @implement_scipy("scipy.special.elliprd")
+    @infer_scipy_dtype("scipy.special.elliprd")
+    def elliprd(x, y, z, **kwargs):
+        op = TensorElliprd(**kwargs)
+        return op(x, y, z)
+
+    @implement_scipy("scipy.special.elliprf")
+    @infer_scipy_dtype("scipy.special.elliprf")
+    def elliprf(x, y, z, **kwargs):
+        op = TensorElliprf(**kwargs)
+        return op(x, y, z)
+
+    @implement_scipy("scipy.special.elliprg")
+    @infer_scipy_dtype("scipy.special.elliprg")
+    def elliprg(x, y, z, **kwargs):
+        op = TensorElliprg(**kwargs)
+        return op(x, y, z)
+
+    @implement_scipy("scipy.special.elliprj")
+    @infer_scipy_dtype("scipy.special.elliprj")
+    def elliprj(x, y, z, p, **kwargs):
+        op = TensorElliprj(**kwargs)
+        return op(x, y, z, p)
+
+except AttributeError:
+    # These functions are not implemented before scipy v1.8 so
+    # spsecial.func may cause AttributeError
+    elliprc = elliprd = elliprf = elliprg = elliprj = None