def test_atanh():
R, x, y = ring("x, y", QQ)
assert rs_atanh(x, x, 9) / x**5 == Rational(1, 7) * x**2 + Rational(
1, 5) + Rational(1, 3) * x**(-2) + x**(-4)
assert (rs_atanh(x * y + x**2 * y**3, x, 9) == 2 * x**8 * y**11 +
x**8 * y**9 + 2 * x**7 * y**9 + x**7 * y**7 / 7 + x**6 * y**9 / 3 +
x**6 * y**7 + x**5 * y**7 + x**5 * y**5 / 5 + x**4 * y**5 +
x**3 * y**3 / 3 + x**2 * y**3 + x * y)
# Constant term in series
a = symbols("a")
R, x, y = ring("x, y", EX)
assert rs_atanh(x + a, x, 5) == EX(
(a**3 + a) / (a**8 - 4 * a**6 + 6 * a**4 - 4 * a**2 + 1)) * x**4 - EX(
(3 * a**2 + 1) / (3 * a**6 - 9 * a**4 + 9 * a**2 - 3)) * x**3 + EX(
a / (a**4 - 2 * a**2 + 1)) * x**2 - EX(1 /
(a**2 - 1)) * x + EX(
atanh(a))
assert rs_atanh(
x + x**2 * y + a, x,
4) == EX(2 * a / (a**4 - 2 * a**2 + 1)) * x**3 * y - EX(
(3 * a**2 + 1) / (3 * a**6 - 9 * a**4 + 9 * a**2 - 3)) * x**3 - EX(
1 /
(a**2 - 1)) * x**2 * y + EX(a /
(a**4 - 2 * a**2 + 1)) * x**2 - EX(
1 /
(a**2 - 1)) * x + EX(atanh(a))
p = x + x**2 + 5
assert rs_atanh(p, x, 10).compose(
x, 10) == EX(Rational(-733442653682135, 5079158784) + atanh(5))
def rs_atanh(p, x, prec):
"""
Hyperbolic arctangent of a series
Returns the series expansion of the atanh of p, about 0.
Examples
========
>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_atanh
>>> R, x, y = ring('x, y', QQ)
>>> rs_atanh(x + x*y, x, 4)
1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x
See Also
========
atanh
"""
if rs_is_puiseux(p, x):
return rs_puiseux(rs_atanh, p, x, prec)
R = p.ring
const = 0
if _has_constant_term(p, x):
zm = R.zero_monom
c = p[zm]
if R.domain is EX:
c_expr = c.as_expr()
const = atanh(c_expr)
elif isinstance(c, PolyElement):
try:
c_expr = c.as_expr()
const = R(atanh(c_expr))
except ValueError:
raise DomainError("The given series can't be expanded in "
"this domain.")
else:
try:
const = R(atanh(c))
except ValueError:
raise DomainError("The given series can't be expanded in "
"this domain.")
# Instead of using a closed form formula, we differentiate atanh(p) to get
# `1/(1-p**2) * dp`, whose series expansion is much easier to calculate.
# Finally we integrate to get back atanh
dp = rs_diff(p, x)
p1 = -rs_square(p, x, prec) + 1
p1 = rs_series_inversion(p1, x, prec - 1)
p1 = rs_mul(dp, p1, x, prec - 1)
return rs_integrate(p1, x) + const
def rs_atanh(p, x, prec):
"""
Hyperbolic arctangent of a series
Returns the series expansion of the atanh of p, about 0.
Examples
========
>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_atanh
>>> R, x, y = ring('x, y', QQ)
>>> rs_atanh(x + x*y, x, 4)
1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x
See Also
========
atanh
"""
if rs_is_puiseux(p, x):
return rs_puiseux(rs_atanh, p, x, prec)
R = p.ring
const = 0
if _has_constant_term(p, x):
zm = R.zero_monom
c = p[zm]
if R.domain is EX:
c_expr = c.as_expr()
const = atanh(c_expr)
elif isinstance(c, PolyElement):
try:
c_expr = c.as_expr()
const = R(atanh(c_expr))
except ValueError:
raise DomainError("The given series can't be expanded in "
"this domain.")
else:
try:
const = R(atanh(c))
except ValueError:
raise DomainError("The given series can't be expanded in "
"this domain.")
# Instead of using a closed form formula, we differentiate atanh(p) to get
# `1/(1-p**2) * dp`, whose series expansion is much easier to calculate.
# Finally we integrate to get back atanh
dp = rs_diff(p, x)
p1 = - rs_square(p, x, prec) + 1
p1 = rs_series_inversion(p1, x, prec - 1)
p1 = rs_mul(dp, p1, x, prec - 1)
return rs_integrate(p1, x) + const
def test_C99CodePrinter__precision():
n = symbols('n', integer=True)
f32_printer = C99CodePrinter(dict(type_aliases={real: float32}))
f64_printer = C99CodePrinter(dict(type_aliases={real: float64}))
f80_printer = C99CodePrinter(dict(type_aliases={real: float80}))
assert f32_printer.doprint(sin(x+2.1)) == 'sinf(x + 2.1F)'
assert f64_printer.doprint(sin(x+2.1)) == 'sin(x + 2.1000000000000001)'
assert f80_printer.doprint(sin(x+Float('2.0'))) == 'sinl(x + 2.0L)'
for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ['f', '', 'l']):
def check(expr, ref):
assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
check(Abs(n), 'abs(n)')
check(Abs(x + 2.0), 'fabs{s}(x + 2.0{S})')
check(sin(x + 4.0)**cos(x - 2.0), 'pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))')
check(exp(x*8.0), 'exp{s}(8.0{S}*x)')
check(exp2(x), 'exp2{s}(x)')
check(expm1(x*4.0), 'expm1{s}(4.0{S}*x)')
check(Mod(n, 2), '((n) % (2))')
check(Mod(2*n + 3, 3*n + 5), '((2*n + 3) % (3*n + 5))')
check(Mod(x + 2.0, 3.0), 'fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})')
check(Mod(x, 2.0*x + 3.0), 'fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})')
check(log(x/2), 'log{s}((1.0{S}/2.0{S})*x)')
check(log10(3*x/2), 'log10{s}((3.0{S}/2.0{S})*x)')
check(log2(x*8.0), 'log2{s}(8.0{S}*x)')
check(log1p(x), 'log1p{s}(x)')
check(2**x, 'pow{s}(2, x)')
check(2.0**x, 'pow{s}(2.0{S}, x)')
check(x**3, 'pow{s}(x, 3)')
check(x**4.0, 'pow{s}(x, 4.0{S})')
check(sqrt(3+x), 'sqrt{s}(x + 3)')
check(Cbrt(x-2.0), 'cbrt{s}(x - 2.0{S})')
check(hypot(x, y), 'hypot{s}(x, y)')
check(sin(3.*x + 2.), 'sin{s}(3.0{S}*x + 2.0{S})')
check(cos(3.*x - 1.), 'cos{s}(3.0{S}*x - 1.0{S})')
check(tan(4.*y + 2.), 'tan{s}(4.0{S}*y + 2.0{S})')
check(asin(3.*x + 2.), 'asin{s}(3.0{S}*x + 2.0{S})')
check(acos(3.*x + 2.), 'acos{s}(3.0{S}*x + 2.0{S})')
check(atan(3.*x + 2.), 'atan{s}(3.0{S}*x + 2.0{S})')
check(atan2(3.*x, 2.*y), 'atan2{s}(3.0{S}*x, 2.0{S}*y)')
check(sinh(3.*x + 2.), 'sinh{s}(3.0{S}*x + 2.0{S})')
check(cosh(3.*x - 1.), 'cosh{s}(3.0{S}*x - 1.0{S})')
check(tanh(4.0*y + 2.), 'tanh{s}(4.0{S}*y + 2.0{S})')
check(asinh(3.*x + 2.), 'asinh{s}(3.0{S}*x + 2.0{S})')
check(acosh(3.*x + 2.), 'acosh{s}(3.0{S}*x + 2.0{S})')
check(atanh(3.*x + 2.), 'atanh{s}(3.0{S}*x + 2.0{S})')
check(erf(42.*x), 'erf{s}(42.0{S}*x)')
check(erfc(42.*x), 'erfc{s}(42.0{S}*x)')
check(gamma(x), 'tgamma{s}(x)')
check(loggamma(x), 'lgamma{s}(x)')
check(ceiling(x + 2.), "ceil{s}(x + 2.0{S})")
check(floor(x + 2.), "floor{s}(x + 2.0{S})")
check(fma(x, y, -z), 'fma{s}(x, y, -z)')
check(Max(x, 8.0, x**4.0), 'fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))')
check(Min(x, 2.0), 'fmin{s}(2.0{S}, x)')
def test_C99CodePrinter__precision():
n = symbols('n', integer=True)
f32_printer = C99CodePrinter(dict(type_aliases={real: float32}))
f64_printer = C99CodePrinter(dict(type_aliases={real: float64}))
f80_printer = C99CodePrinter(dict(type_aliases={real: float80}))
assert f32_printer.doprint(sin(x+2.1)) == 'sinf(x + 2.1F)'
assert f64_printer.doprint(sin(x+2.1)) == 'sin(x + 2.1000000000000001)'
assert f80_printer.doprint(sin(x+Float('2.0'))) == 'sinl(x + 2.0L)'
for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ['f', '', 'l']):
def check(expr, ref):
assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
check(Abs(n), 'abs(n)')
check(Abs(x + 2.0), 'fabs{s}(x + 2.0{S})')
check(sin(x + 4.0)**cos(x - 2.0), 'pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))')
check(exp(x*8.0), 'exp{s}(8.0{S}*x)')
check(exp2(x), 'exp2{s}(x)')
check(expm1(x*4.0), 'expm1{s}(4.0{S}*x)')
check(Mod(n, 2), '((n) % (2))')
check(Mod(2*n + 3, 3*n + 5), '((2*n + 3) % (3*n + 5))')
check(Mod(x + 2.0, 3.0), 'fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})')
check(Mod(x, 2.0*x + 3.0), 'fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})')
check(log(x/2), 'log{s}((1.0{S}/2.0{S})*x)')
check(log10(3*x/2), 'log10{s}((3.0{S}/2.0{S})*x)')
check(log2(x*8.0), 'log2{s}(8.0{S}*x)')
check(log1p(x), 'log1p{s}(x)')
check(2**x, 'pow{s}(2, x)')
check(2.0**x, 'pow{s}(2.0{S}, x)')
check(x**3, 'pow{s}(x, 3)')
check(x**4.0, 'pow{s}(x, 4.0{S})')
check(sqrt(3+x), 'sqrt{s}(x + 3)')
check(Cbrt(x-2.0), 'cbrt{s}(x - 2.0{S})')
check(hypot(x, y), 'hypot{s}(x, y)')
check(sin(3.*x + 2.), 'sin{s}(3.0{S}*x + 2.0{S})')
check(cos(3.*x - 1.), 'cos{s}(3.0{S}*x - 1.0{S})')
check(tan(4.*y + 2.), 'tan{s}(4.0{S}*y + 2.0{S})')
check(asin(3.*x + 2.), 'asin{s}(3.0{S}*x + 2.0{S})')
check(acos(3.*x + 2.), 'acos{s}(3.0{S}*x + 2.0{S})')
check(atan(3.*x + 2.), 'atan{s}(3.0{S}*x + 2.0{S})')
check(atan2(3.*x, 2.*y), 'atan2{s}(3.0{S}*x, 2.0{S}*y)')
check(sinh(3.*x + 2.), 'sinh{s}(3.0{S}*x + 2.0{S})')
check(cosh(3.*x - 1.), 'cosh{s}(3.0{S}*x - 1.0{S})')
check(tanh(4.0*y + 2.), 'tanh{s}(4.0{S}*y + 2.0{S})')
check(asinh(3.*x + 2.), 'asinh{s}(3.0{S}*x + 2.0{S})')
check(acosh(3.*x + 2.), 'acosh{s}(3.0{S}*x + 2.0{S})')
check(atanh(3.*x + 2.), 'atanh{s}(3.0{S}*x + 2.0{S})')
check(erf(42.*x), 'erf{s}(42.0{S}*x)')
check(erfc(42.*x), 'erfc{s}(42.0{S}*x)')
check(gamma(x), 'tgamma{s}(x)')
check(loggamma(x), 'lgamma{s}(x)')
check(ceiling(x + 2.), "ceil{s}(x + 2.0{S})")
check(floor(x + 2.), "floor{s}(x + 2.0{S})")
check(fma(x, y, -z), 'fma{s}(x, y, -z)')
check(Max(x, 8.0, x**4.0), 'fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))')
check(Min(x, 2.0), 'fmin{s}(2.0{S}, x)')
def test_atanh():
R, x, y = ring('x, y', QQ)
assert rs_atanh(x, x, 9)/x**5 == S(1)/7*x**2 + S(1)/5 + S(1)/3*x**(-2) + x**(-4)
assert rs_atanh(x*y + x**2*y**3, x, 9) == 2*x**8*y**11 + x**8*y**9 + \
2*x**7*y**9 + x**7*y**7/7 + x**6*y**9/3 + x**6*y**7 + x**5*y**7 + \
x**5*y**5/5 + x**4*y**5 + x**3*y**3/3 + x**2*y**3 + x*y
# Constant term in series
a = symbols('a')
R, x, y = ring('x, y', EX)
assert rs_atanh(x + a, x, 5) == EX((a**3 + a)/(a**8 - 4*a**6 + 6*a**4 - \
4*a**2 + 1))*x**4 - EX((3*a**2 + 1)/(3*a**6 - 9*a**4 + \
9*a**2 - 3))*x**3 + EX(a/(a**4 - 2*a**2 + 1))*x**2 - EX(1/(a**2 - \
1))*x + EX(atanh(a))
assert rs_atanh(x + x**2*y + a, x, 4) == EX(2*a/(a**4 - 2*a**2 + \
1))*x**3*y - EX((3*a**2 + 1)/(3*a**6 - 9*a**4 + 9*a**2 - 3))*x**3 - \
EX(1/(a**2 - 1))*x**2*y + EX(a/(a**4 - 2*a**2 + 1))*x**2 - \
EX(1/(a**2 - 1))*x + EX(atanh(a))
p = x + x**2 + 5
assert rs_atanh(p, x, 10).compose(x, 10) == EX(-S(733442653682135)/5079158784 \
+ atanh(5))
def test_atanh():
R, x, y = ring('x, y', QQ)
assert rs_atanh(x, x, 9) == x**7 / 7 + x**5 / 5 + x**3 / 3 + x
assert rs_atanh(x*y + x**2*y**3, x, 9) == 2*x**8*y**11 + x**8*y**9 + \
2*x**7*y**9 + x**7*y**7/7 + x**6*y**9/3 + x**6*y**7 + x**5*y**7 + \
x**5*y**5/5 + x**4*y**5 + x**3*y**3/3 + x**2*y**3 + x*y
# Constant term in series
a = symbols('a')
R, x, y = ring('x, y', EX)
assert rs_atanh(x + a, x, 5) == EX((a**3 + a)/(a**8 - 4*a**6 + 6*a**4 - \
4*a**2 + 1))*x**4 - EX((3*a**2 + 1)/(3*a**6 - 9*a**4 + \
9*a**2 - 3))*x**3 + EX(a/(a**4 - 2*a**2 + 1))*x**2 - EX(1/(a**2 - \
1))*x + EX(atanh(a))
assert rs_atanh(x + x**2*y + a, x, 4) == EX(2*a/(a**4 - 2*a**2 + \
1))*x**3*y - EX((3*a**2 + 1)/(3*a**6 - 9*a**4 + 9*a**2 - 3))*x**3 - \
EX(1/(a**2 - 1))*x**2*y + EX(a/(a**4 - 2*a**2 + 1))*x**2 - \
EX(1/(a**2 - 1))*x + EX(atanh(a))
p = x + x**2 + 5
assert rs_atanh(p, x, 10).compose(x, 10) == EX(-733442653682135/5079158784 \
+ atanh(5))
def _expr_small(cls, x):
return atanh(sqrt(x)) / sqrt(x)
def _expr_small(cls, x):
return atanh(sqrt(x))/sqrt(x)
def test_tensorflow_math():
if not tf:
skip("TensorFlow not installed")
expr = Abs(x)
assert tensorflow_code(expr) == "tensorflow.math.abs(x)"
_compare_tensorflow_scalar((x, ), expr)
expr = sign(x)
assert tensorflow_code(expr) == "tensorflow.math.sign(x)"
_compare_tensorflow_scalar((x, ), expr)
expr = ceiling(x)
assert tensorflow_code(expr) == "tensorflow.math.ceil(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = floor(x)
assert tensorflow_code(expr) == "tensorflow.math.floor(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = exp(x)
assert tensorflow_code(expr) == "tensorflow.math.exp(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = sqrt(x)
assert tensorflow_code(expr) == "tensorflow.math.sqrt(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = x**4
assert tensorflow_code(expr) == "tensorflow.math.pow(x, 4)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = cos(x)
assert tensorflow_code(expr) == "tensorflow.math.cos(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = acos(x)
assert tensorflow_code(expr) == "tensorflow.math.acos(x)"
_compare_tensorflow_scalar((x, ),
expr,
rng=lambda: random.uniform(0, 0.95))
expr = sin(x)
assert tensorflow_code(expr) == "tensorflow.math.sin(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = asin(x)
assert tensorflow_code(expr) == "tensorflow.math.asin(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = tan(x)
assert tensorflow_code(expr) == "tensorflow.math.tan(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = atan(x)
assert tensorflow_code(expr) == "tensorflow.math.atan(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = atan2(y, x)
assert tensorflow_code(expr) == "tensorflow.math.atan2(y, x)"
_compare_tensorflow_scalar((y, x), expr, rng=lambda: random.random())
expr = cosh(x)
assert tensorflow_code(expr) == "tensorflow.math.cosh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = acosh(x)
assert tensorflow_code(expr) == "tensorflow.math.acosh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = sinh(x)
assert tensorflow_code(expr) == "tensorflow.math.sinh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = asinh(x)
assert tensorflow_code(expr) == "tensorflow.math.asinh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = tanh(x)
assert tensorflow_code(expr) == "tensorflow.math.tanh(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = atanh(x)
assert tensorflow_code(expr) == "tensorflow.math.atanh(x)"
_compare_tensorflow_scalar((x, ),
expr,
rng=lambda: random.uniform(-.5, .5))
expr = erf(x)
assert tensorflow_code(expr) == "tensorflow.math.erf(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
expr = loggamma(x)
assert tensorflow_code(expr) == "tensorflow.math.lgamma(x)"
_compare_tensorflow_scalar((x, ), expr, rng=lambda: random.random())
def test_C99CodePrinter__precision():
n = symbols("n", integer=True)
f32_printer = C99CodePrinter(dict(type_aliases={real: float32}))
f64_printer = C99CodePrinter(dict(type_aliases={real: float64}))
f80_printer = C99CodePrinter(dict(type_aliases={real: float80}))
assert f32_printer.doprint(sin(x + 2.1)) == "sinf(x + 2.1F)"
assert f64_printer.doprint(sin(x + 2.1)) == "sin(x + 2.1000000000000001)"
assert f80_printer.doprint(sin(x + Float("2.0"))) == "sinl(x + 2.0L)"
for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ["f", "", "l"]):
def check(expr, ref):
assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
check(Abs(n), "abs(n)")
check(Abs(x + 2.0), "fabs{s}(x + 2.0{S})")
check(
sin(x + 4.0) ** cos(x - 2.0),
"pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))",
)
check(exp(x * 8.0), "exp{s}(8.0{S}*x)")
check(exp2(x), "exp2{s}(x)")
check(expm1(x * 4.0), "expm1{s}(4.0{S}*x)")
check(Mod(n, 2), "((n) % (2))")
check(Mod(2 * n + 3, 3 * n + 5), "((2*n + 3) % (3*n + 5))")
check(Mod(x + 2.0, 3.0), "fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})")
check(Mod(x, 2.0 * x + 3.0), "fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})")
check(log(x / 2), "log{s}((1.0{S}/2.0{S})*x)")
check(log10(3 * x / 2), "log10{s}((3.0{S}/2.0{S})*x)")
check(log2(x * 8.0), "log2{s}(8.0{S}*x)")
check(log1p(x), "log1p{s}(x)")
check(2 ** x, "pow{s}(2, x)")
check(2.0 ** x, "pow{s}(2.0{S}, x)")
check(x ** 3, "pow{s}(x, 3)")
check(x ** 4.0, "pow{s}(x, 4.0{S})")
check(sqrt(3 + x), "sqrt{s}(x + 3)")
check(Cbrt(x - 2.0), "cbrt{s}(x - 2.0{S})")
check(hypot(x, y), "hypot{s}(x, y)")
check(sin(3.0 * x + 2.0), "sin{s}(3.0{S}*x + 2.0{S})")
check(cos(3.0 * x - 1.0), "cos{s}(3.0{S}*x - 1.0{S})")
check(tan(4.0 * y + 2.0), "tan{s}(4.0{S}*y + 2.0{S})")
check(asin(3.0 * x + 2.0), "asin{s}(3.0{S}*x + 2.0{S})")
check(acos(3.0 * x + 2.0), "acos{s}(3.0{S}*x + 2.0{S})")
check(atan(3.0 * x + 2.0), "atan{s}(3.0{S}*x + 2.0{S})")
check(atan2(3.0 * x, 2.0 * y), "atan2{s}(3.0{S}*x, 2.0{S}*y)")
check(sinh(3.0 * x + 2.0), "sinh{s}(3.0{S}*x + 2.0{S})")
check(cosh(3.0 * x - 1.0), "cosh{s}(3.0{S}*x - 1.0{S})")
check(tanh(4.0 * y + 2.0), "tanh{s}(4.0{S}*y + 2.0{S})")
check(asinh(3.0 * x + 2.0), "asinh{s}(3.0{S}*x + 2.0{S})")
check(acosh(3.0 * x + 2.0), "acosh{s}(3.0{S}*x + 2.0{S})")
check(atanh(3.0 * x + 2.0), "atanh{s}(3.0{S}*x + 2.0{S})")
check(erf(42.0 * x), "erf{s}(42.0{S}*x)")
check(erfc(42.0 * x), "erfc{s}(42.0{S}*x)")
check(gamma(x), "tgamma{s}(x)")
check(loggamma(x), "lgamma{s}(x)")
check(ceiling(x + 2.0), "ceil{s}(x + 2.0{S})")
check(floor(x + 2.0), "floor{s}(x + 2.0{S})")
check(fma(x, y, -z), "fma{s}(x, y, -z)")
check(Max(x, 8.0, x ** 4.0), "fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))")
check(Min(x, 2.0), "fmin{s}(2.0{S}, x)")
def test_torch_math():
if not torch:
skip("Torch not installed")
ma = torch.tensor([[1, 2, -3, -4]])
expr = Abs(x)
assert torch_code(expr) == "torch.abs(x)"
f = lambdify(x, expr, 'torch')
y = f(ma)
c = torch.abs(ma)
assert (y == c).all()
expr = sign(x)
assert torch_code(expr) == "torch.sign(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.randint(0, 10))
expr = ceiling(x)
assert torch_code(expr) == "torch.ceil(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = floor(x)
assert torch_code(expr) == "torch.floor(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = exp(x)
assert torch_code(expr) == "torch.exp(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
# expr = sqrt(x)
# assert torch_code(expr) == "torch.sqrt(x)"
# _compare_torch_scalar((x,), expr, rng=lambda: random.random())
# expr = x ** 4
# assert torch_code(expr) == "torch.pow(x, 4)"
# _compare_torch_scalar((x,), expr, rng=lambda: random.random())
expr = cos(x)
assert torch_code(expr) == "torch.cos(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = acos(x)
assert torch_code(expr) == "torch.acos(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(0, 0.95))
expr = sin(x)
assert torch_code(expr) == "torch.sin(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = asin(x)
assert torch_code(expr) == "torch.asin(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = tan(x)
assert torch_code(expr) == "torch.tan(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = atan(x)
assert torch_code(expr) == "torch.atan(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
# expr = atan2(y, x)
# assert torch_code(expr) == "torch.atan2(y, x)"
# _compare_torch_scalar((y, x), expr, rng=lambda: random.random())
expr = cosh(x)
assert torch_code(expr) == "torch.cosh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = acosh(x)
assert torch_code(expr) == "torch.acosh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = sinh(x)
assert torch_code(expr) == "torch.sinh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = asinh(x)
assert torch_code(expr) == "torch.asinh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = tanh(x)
assert torch_code(expr) == "torch.tanh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(1, 2))
expr = atanh(x)
assert torch_code(expr) == "torch.atanh(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.uniform(-.5, .5))
expr = erf(x)
assert torch_code(expr) == "torch.erf(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
expr = loggamma(x)
assert torch_code(expr) == "torch.lgamma(x)"
_compare_torch_scalar((x, ), expr, rng=lambda: random.random())
