Source code for mars.tensor.special.bessel

# Copyright 1999-2021 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_operand
from ..utils import infer_dtype, implement_scipy
from .core import spspecial, TensorSpecialBinOp, _register_special_op


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorJV(TensorSpecialBinOp):
    _func_name = 'jv'


@implement_scipy(spspecial.jv)
@infer_dtype(spspecial.jv)
def jv(v, z, **kwargs):
    op = TensorJV(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorJVE(TensorSpecialBinOp):
    _func_name = 'jve'


@implement_scipy(spspecial.jve)
@infer_dtype(spspecial.jve)
def jve(v, z, **kwargs):
    op = TensorJVE(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorYN(TensorSpecialBinOp):
    _func_name = 'yn'


@implement_scipy(spspecial.yn)
@infer_dtype(spspecial.yn)
def yn(n, x, **kwargs):
    op = TensorYN(**kwargs)
    return op(n, x)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorYV(TensorSpecialBinOp):
    _func_name = 'yv'


@implement_scipy(spspecial.yv)
@infer_dtype(spspecial.yv)
def yv(v, z, **kwargs):
    op = TensorYV(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorYVE(TensorSpecialBinOp):
    _func_name = 'yve'


@implement_scipy(spspecial.yve)
@infer_dtype(spspecial.yve)
def yve(v, z, **kwargs):
    op = TensorYVE(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorKN(TensorSpecialBinOp):
    _func_name = 'kn'


@implement_scipy(spspecial.kn)
@infer_dtype(spspecial.kn)
def kn(n, x, **kwargs):
    op = TensorKN(**kwargs)
    return op(n, x)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorKV(TensorSpecialBinOp):
    _func_name = 'kv'


@implement_scipy(spspecial.kv)
@infer_dtype(spspecial.kv)
def kv(v, z, **kwargs):
    op = TensorKV(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorKVE(TensorSpecialBinOp):
    _func_name = 'kve'


@implement_scipy(spspecial.kve)
@infer_dtype(spspecial.kve)
def kve(v, z, **kwargs):
    op = TensorKVE(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorIV(TensorSpecialBinOp):
    _func_name = 'iv'


@implement_scipy(spspecial.iv)
@infer_dtype(spspecial.iv)
def iv(v, z, **kwargs):
    op = TensorIV(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorIVE(TensorSpecialBinOp):
    _func_name = 'ive'


@implement_scipy(spspecial.ive)
@infer_dtype(spspecial.ive)
def ive(v, z, **kwargs):
    op = TensorIVE(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorHankel1(TensorSpecialBinOp):
    _func_name = 'hankel1'


@implement_scipy(spspecial.hankel1)
@infer_dtype(spspecial.hankel1)
def hankel1(v, z, **kwargs):
    op = TensorHankel1(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorHankel1e(TensorSpecialBinOp):
    _func_name = 'hankel1e'


@implement_scipy(spspecial.hankel1e)
@infer_dtype(spspecial.hankel1e)
def hankel1e(v, z, **kwargs):
    op = TensorHankel1e(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorHankel2(TensorSpecialBinOp):
    _func_name = 'hankel2'


@implement_scipy(spspecial.hankel2)
@infer_dtype(spspecial.hankel2)
def hankel2(v, z, **kwargs):
    op = TensorHankel2(**kwargs)
    return op(v, z)


@_register_special_op
@arithmetic_operand(sparse_mode='binary_and')
class TensorHankel2e(TensorSpecialBinOp):
    _func_name = 'hankel2e'


@implement_scipy(spspecial.hankel2e)
@infer_dtype(spspecial.hankel2e)
def hankel2e(v, z, **kwargs):
    op = TensorHankel2e(**kwargs)
    return op(v, z)