def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.tanh(i_coeff)
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
elif pi_coeff.is_Rational:
cst_table = {
#2 : S.ComplexInfinity,
3 : sqrt(3),
4 : S.One,
6 : 1 / sqrt(3),
}
try:
result = cst_table[pi_coeff.q]
if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
pass
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
if (m*2/S.Pi) % 2 == 0:
return tan(x)
else:
return -cot(x)
if arg.func is atan:
return arg.args[0]
if arg.func is asin:
x = arg.args[0]
return x / sqrt(1 - x**2)
if arg.func is acos:
x = arg.args[0]
return sqrt(1 - x**2) / x
if arg.func is acot:
x = arg.args[0]
return 1 / x
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.tanh(i_coeff)
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
elif pi_coeff.is_Rational:
cst_table = {
2: S.ComplexInfinity,
3: sqrt(3),
4: S.One,
6: 1 / sqrt(3),
}
try:
result = cst_table[pi_coeff.q]
if (2 * pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
pass
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
if (m * 2 / S.Pi) % 2 == 0:
return tan(x)
else:
return -cot(x)
if arg.func is atan:
return arg.args[0]
if arg.func is asin:
x = arg.args[0]
return x / sqrt(1 - x**2)
if arg.func is acos:
x = arg.args[0]
return sqrt(1 - x**2) / x
if arg.func is acot:
x = arg.args[0]
return 1 / x
def canonize(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
#elif arg is S.Zero:
# return S.ComplexInfinity
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.coth(i_coeff)
else:
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
#if pi_coeff.is_integer:
# return S.ComplexInfinity
if pi_coeff.is_Rational:
cst_table = {
2 : S.Zero,
3 : 1 / sqrt(3),
4 : S.One,
6 : sqrt(3)
}
try:
result = cst_table[pi_coeff.q]
if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
pass
coeff, terms = arg.as_coeff_terms()
if coeff.is_negative:
return -cls(-arg)
if isinstance(arg, acot):
return arg.args[0]
if isinstance(arg, atan):
x = arg.args[0]
return 1 / x
if isinstance(arg, asin):
x = arg.args[0]
return sqrt(1 - x**2) / x
if isinstance(arg, acos):
x = arg.args[0]
return x / sqrt(1 - x**2)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
#elif arg is S.Zero:
# return S.ComplexInfinity
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.coth(i_coeff)
else:
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
#if pi_coeff.is_integer:
# return S.ComplexInfinity
if pi_coeff.is_Rational:
cst_table = {
2: S.Zero,
3: 1 / sqrt(3),
4: S.One,
6: sqrt(3)
}
try:
result = cst_table[pi_coeff.q]
if (2 * pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
pass
coeff, terms = arg.as_coeff_terms()
if coeff.is_negative:
return -cls(-arg)
if isinstance(arg, acot):
return arg.args[0]
if isinstance(arg, atan):
x = arg.args[0]
return 1 / x
if isinstance(arg, asin):
x = arg.args[0]
return sqrt(1 - x**2) / x
if isinstance(arg, acos):
x = arg.args[0]
return x / sqrt(1 - x**2)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.coth(i_coeff)
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_Rational:
cst_table = {
2 : S.Zero,
3 : 1 / sqrt(3),
4 : S.One,
6 : sqrt(3)
}
try:
result = cst_table[pi_coeff.q]
if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
pass
if arg.func is acot:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return 1 / x
if arg.func is asin:
x = arg.args[0]
return sqrt(1 - x**2) / x
if arg.func is acos:
x = arg.args[0]
return x / sqrt(1 - x**2)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Zero
elif arg is S.NegativeInfinity:
return S.Zero
elif arg is S.Zero:
return S.Pi / 2
elif arg is S.One:
return S.Pi / 4
elif arg is S.NegativeOne:
return -S.Pi / 4
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
sqrt(3) / 3: 3,
-sqrt(3) / 3: -3,
1 / sqrt(3): 3,
-1 / sqrt(3): -3,
sqrt(3): 6,
-sqrt(3): -6,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.acoth(i_coeff)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Pi / 2
elif arg is S.One:
return S.Zero
elif arg is S.NegativeOne:
return S.Pi
if arg.is_number:
cst_table = {
S.Half: S.Pi / 3,
-S.Half: 2 * S.Pi / 3,
sqrt(2) / 2: S.Pi / 4,
-sqrt(2) / 2: 3 * S.Pi / 4,
1 / sqrt(2): S.Pi / 4,
-1 / sqrt(2): 3 * S.Pi / 4,
sqrt(3) / 2: S.Pi / 6,
-sqrt(3) / 2: 5 * S.Pi / 6,
}
if arg in cst_table:
return cst_table[arg]
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Pi / 2
elif arg is S.One:
return S.Zero
elif arg is S.NegativeOne:
return S.Pi
if arg.is_number:
cst_table = {
S.Half : S.Pi/3,
-S.Half : 2*S.Pi/3,
sqrt(2)/2 : S.Pi/4,
-sqrt(2)/2 : 3*S.Pi/4,
1/sqrt(2) : S.Pi/4,
-1/sqrt(2) : 3*S.Pi/4,
sqrt(3)/2 : S.Pi/6,
-sqrt(3)/2 : 5*S.Pi/6,
}
if arg in cst_table:
return cst_table[arg]
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Pi / 2
elif arg is S.NegativeInfinity:
return -S.Pi / 2
elif arg is S.Zero:
return S.Zero
elif arg is S.One:
return S.Pi / 4
elif arg is S.NegativeOne:
return -S.Pi / 4
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
sqrt(3)/3 : 6,
-sqrt(3)/3 : -6,
1/sqrt(3) : 6,
-1/sqrt(3) : -6,
sqrt(3) : 3,
-sqrt(3) : -3,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.atanh(i_coeff)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.coth(i_coeff)
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_Rational:
cst_table = {2: S.Zero, 3: 1 / sqrt(3), 4: S.One, 6: sqrt(3)}
try:
result = cst_table[pi_coeff.q]
if (2 * pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
pass
if arg.func is acot:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return 1 / x
if arg.func is asin:
x = arg.args[0]
return sqrt(1 - x**2) / x
if arg.func is acos:
x = arg.args[0]
return x / sqrt(1 - x**2)
def canonize(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Zero
elif arg is S.One:
return S.Pi / 2
elif arg is S.NegativeOne:
return -S.Pi / 2
if arg.is_number:
cst_table = {
S.Half : 6,
-S.Half : -6,
sqrt(2)/2 : 4,
-sqrt(2)/2 : -4,
1/sqrt(2) : 4,
-1/sqrt(2) : -4,
sqrt(3)/2 : 3,
-sqrt(3)/2 : -3,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.asinh(i_coeff)
else:
coeff, terms = arg.as_coeff_terms()
if coeff.is_negative:
return -cls(-arg)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Zero
elif arg is S.One:
return S.Pi / 2
elif arg is S.NegativeOne:
return -S.Pi / 2
if arg.is_number:
cst_table = {
S.Half: 6,
-S.Half: -6,
sqrt(2) / 2: 4,
-sqrt(2) / 2: -4,
1 / sqrt(2): 4,
-1 / sqrt(2): -4,
sqrt(3) / 2: 3,
-sqrt(3) / 2: -3,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.asinh(i_coeff)
else:
coeff, terms = arg.as_coeff_terms()
if coeff.is_negative:
return -cls(-arg)
def canonize(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Zero
elif arg is S.NegativeInfinity:
return S.Zero
elif arg is S.Zero:
return S.Pi/ 2
elif arg is S.One:
return S.Pi / 4
elif arg is S.NegativeOne:
return -S.Pi / 4
if arg.is_number:
cst_table = {
sqrt(3)/3 : 3,
-sqrt(3)/3 : -3,
1/sqrt(3) : 3,
-1/sqrt(3) : -3,
sqrt(3) : 6,
-sqrt(3) : -6,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.acoth(i_coeff)
else:
coeff, terms = arg.as_coeff_terms()
if coeff.is_negative:
return -cls(-arg)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Zero
elif arg is S.NegativeInfinity:
return S.Zero
elif arg is S.Zero:
return S.Pi / 2
elif arg is S.One:
return S.Pi / 4
elif arg is S.NegativeOne:
return -S.Pi / 4
if arg.is_number:
cst_table = {
sqrt(3) / 3: 3,
-sqrt(3) / 3: -3,
1 / sqrt(3): 3,
-1 / sqrt(3): -3,
sqrt(3): 6,
-sqrt(3): -6,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.acoth(i_coeff)
else:
coeff, terms = arg.as_coeff_terms()
if coeff.is_negative:
return -cls(-arg)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Zero
elif arg is S.One:
return S.Pi / 2
elif arg is S.NegativeOne:
return -S.Pi / 2
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
S.Half: 6,
-S.Half: -6,
sqrt(2) / 2: 4,
-sqrt(2) / 2: -4,
1 / sqrt(2): 4,
-1 / sqrt(2): -4,
sqrt(3) / 2: 3,
-sqrt(3) / 2: -3,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.asinh(i_coeff)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.sinh(i_coeff)
else:
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
elif pi_coeff.is_Rational:
cst_table_some = {
2: S.One,
3: S.Half * sqrt(3),
4: S.Half * sqrt(2),
6: S.Half,
}
cst_table_more = {
(1, 5): sqrt((5 - sqrt(5)) / 8),
(2, 5): sqrt((5 + sqrt(5)) / 8)
}
p = pi_coeff.p
q = pi_coeff.q
Q, P = p // q, p % q
try:
result = cst_table_some[q]
except KeyError:
if abs(P) > q // 2:
P = q - P
try:
result = cst_table_more[(P, q)]
except KeyError:
if P != p:
result = cls(C.Rational(P, q) * S.Pi)
else:
return None
if Q % 2 == 1:
return -result
else:
return result
if arg.is_Mul and arg.args[0].is_negative:
return -cls(-arg)
if arg.is_Add:
x, m = arg.as_independent(S.Pi)
if m in [S.Pi / 2, S.Pi]:
return sin(m) * cos(x) + cos(m) * sin(x)
# normalize sin(-x-y) to -sin(x+y)
if arg.args[0].is_Mul:
if arg.args[0].args[0].is_negative:
# e.g. arg = -x - y
if (-arg).args[0].is_Mul:
if (-arg).args[0].args[0].is_negative:
# This is to prevent infinite recursion in
# the case sin(-x+y), for which
# -arg = -y + x. See also #838 for the
# root of the problem here.
return
# convert sin(-x-y) to -sin(x+y)
return -cls(-arg)
if arg.args[0].is_negative:
if (-arg).args[0].is_negative:
# This is to avoid infinite recursion in the case
# sin(-x-1)
return
return -cls(-arg)
if isinstance(arg, asin):
return arg.args[0]
if isinstance(arg, atan):
x = arg.args[0]
return x / sqrt(1 + x**2)
if isinstance(arg, acos):
x = arg.args[0]
return sqrt(1 - x**2)
if isinstance(arg, acot):
x = arg.args[0]
return 1 / (sqrt(1 + 1 / x**2) * x)
def fdiff(self, argindex=1):
if argindex == 1:
return 1/sqrt(1 - self.args[0]**2)
else:
raise ArgumentIndexError(self, argindex)
def _eval_rewrite_as_atan(self, x):
return 2*atan(x/(1 + sqrt(1 - x**2)))
def canonize(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.sinh(i_coeff)
else:
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
elif pi_coeff.is_Rational:
cst_table = {
2: S.One,
3: S.Half * sqrt(3),
4: S.Half * sqrt(2),
6: S.Half,
}
try:
result = cst_table[pi_coeff.q]
if (pi_coeff.p // pi_coeff.q) % 2 == 1:
return -result
else:
return result
except KeyError:
pass
if arg.is_Mul and arg.args[0].is_negative:
return -cls(-arg)
if arg.is_Add:
x, m = arg.as_independent(S.Pi)
if m in [S.Pi / 2, S.Pi]:
return sin(m) * cos(x) + cos(m) * sin(x)
# normalize sin(-x-y) to -sin(x+y)
if arg.args[0].is_Mul:
if arg.args[0].args[0].is_negative:
# e.g. arg = -x - y
if (-arg).args[0].is_Mul:
if (-arg).args[0].args[0].is_negative:
# This is to prevent infinite recursion in
# the case sin(-x+y), for which
# -arg = -y + x. See also #838 for the
# root of the problem here.
return
# convert sin(-x-y) to -sin(x+y)
return -cls(-arg)
if arg.args[0].is_negative:
if (-arg).args[0].is_negative:
# This is to avoid infinite recursion in the case
# sin(-x-1)
return
return -cls(-arg)
if isinstance(arg, asin):
return arg.args[0]
if isinstance(arg, atan):
x = arg.args[0]
return x / sqrt(1 + x**2)
if isinstance(arg, acos):
x = arg.args[0]
return sqrt(1 - x**2)
if isinstance(arg, acot):
x = arg.args[0]
return 1 / (sqrt(1 + 1 / x**2) * x)
def canonize(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.sinh(i_coeff)
else:
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
elif pi_coeff.is_Rational:
cst_table = {
2 : S.One,
3 : S.Half*sqrt(3),
4 : S.Half*sqrt(2),
6 : S.Half,
}
try:
result = cst_table[pi_coeff.q]
if (pi_coeff.p // pi_coeff.q) % 2 == 1:
return -result
else:
return result
except KeyError:
pass
if arg.is_Mul and arg.args[0].is_negative:
return -cls(-arg)
if arg.is_Add:
x, m = arg.as_independent(S.Pi)
if m in [S.Pi/2, S.Pi]:
return sin(m)*cos(x)+cos(m)*sin(x)
# normalize sin(-x-y) to -sin(x+y)
if arg.args[0].is_Mul:
if arg.args[0].args[0].is_negative:
# e.g. arg = -x - y
if (-arg).args[0].is_Mul:
if (-arg).args[0].args[0].is_negative:
# This is to prevent infinite recursion in
# the case sin(-x+y), for which
# -arg = -y + x. See also #838 for the
# root of the problem here.
return
# convert sin(-x-y) to -sin(x+y)
return -cls(-arg)
if arg.args[0].is_negative:
if (-arg).args[0].is_negative:
# This is to avoid infinite recursion in the case
# sin(-x-1)
return
return -cls(-arg)
if isinstance(arg, asin):
return arg.args[0]
if isinstance(arg, atan):
x = arg.args[0]
return x / sqrt(1 + x**2)
if isinstance(arg, acos):
x = arg.args[0]
return sqrt(1 - x**2)
if isinstance(arg, acot):
x = arg.args[0];
return 1 / (sqrt(1 + 1 / x**2) * x)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
elif arg.is_negative:
return -cls(-arg)
else:
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.sinh(i_coeff)
else:
pi_coeff = arg.as_coefficient(S.Pi)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
elif pi_coeff.is_Rational:
cst_table_some = {
2 : S.One,
3 : S.Half*sqrt(3),
4 : S.Half*sqrt(2),
6 : S.Half,
}
cst_table_more = {
(1, 5) : sqrt((5 - sqrt(5)) / 8),
(2, 5) : sqrt((5 + sqrt(5)) / 8)
}
p = pi_coeff.p
q = pi_coeff.q
Q, P = p // q, p % q
try:
result = cst_table_some[q]
except KeyError:
if abs(P) > q // 2:
P = q - P
try:
result = cst_table_more[(P, q)]
except KeyError:
if P != p:
result = cls(C.Rational(P, q)*S.Pi)
else:
return None
if Q % 2 == 1:
return -result
else:
return result
if arg.is_Mul and arg.args[0].is_negative:
return -cls(-arg)
if arg.is_Add:
x, m = arg.as_independent(S.Pi)
if m in [S.Pi/2, S.Pi]:
return sin(m)*cos(x)+cos(m)*sin(x)
# normalize sin(-x-y) to -sin(x+y)
if arg.args[0].is_Mul:
if arg.args[0].args[0].is_negative:
# e.g. arg = -x - y
if (-arg).args[0].is_Mul:
if (-arg).args[0].args[0].is_negative:
# This is to prevent infinite recursion in
# the case sin(-x+y), for which
# -arg = -y + x. See also #838 for the
# root of the problem here.
return
# convert sin(-x-y) to -sin(x+y)
return -cls(-arg)
if arg.args[0].is_negative:
if (-arg).args[0].is_negative:
# This is to avoid infinite recursion in the case
# sin(-x-1)
return
return -cls(-arg)
if isinstance(arg, asin):
return arg.args[0]
if isinstance(arg, atan):
x = arg.args[0]
return x / sqrt(1 + x**2)
if isinstance(arg, acos):
x = arg.args[0]
return sqrt(1 - x**2)
if isinstance(arg, acot):
x = arg.args[0];
return 1 / (sqrt(1 + 1 / x**2) * x)
def _eval_rewrite_as_atan(self, x):
return 2 * atan(x / (1 + sqrt(1 - x**2)))
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
if arg is S.Zero:
return S.ComplexInfinity
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.coth(i_coeff)
pi_coeff = _pi_coeff(arg, 2)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.ComplexInfinity
if not pi_coeff.is_Rational:
narg = pi_coeff * S.Pi
if narg != arg:
return cls(narg)
return None
cst_table = {2: S.Zero, 3: 1 / sqrt(3), 4: S.One, 6: sqrt(3)}
try:
result = cst_table[pi_coeff.q]
if (2 * pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
if pi_coeff.p > pi_coeff.q:
p, q = pi_coeff.p % pi_coeff.q, pi_coeff.q
if 2 * p > q:
return -cls(Rational(q - p, q) * S.Pi)
return cls(Rational(p, q) * S.Pi)
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
if (m * 2 / S.Pi) % 2 == 0:
return cot(x)
else:
return -tan(x)
if arg.func is acot:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return 1 / x
if arg.func is asin:
x = arg.args[0]
return sqrt(1 - x**2) / x
if arg.func is acos:
x = arg.args[0]
return x / sqrt(1 - x**2)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Zero
elif arg is S.One:
return S.Pi / 2
elif arg is S.NegativeOne:
return -S.Pi / 2
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
sqrt(3) / 2: 3,
-sqrt(3) / 2: -3,
sqrt(2) / 2: 4,
-sqrt(2) / 2: -4,
1 / sqrt(2): 4,
-1 / sqrt(2): -4,
sqrt((5 - sqrt(5)) / 8): 5,
-sqrt((5 - sqrt(5)) / 8): -5,
S.Half: 6,
-S.Half: -6,
sqrt(2 - sqrt(2)) / 2: 8,
-sqrt(2 - sqrt(2)) / 2: -8,
(sqrt(5) - 1) / 4: 10,
(1 - sqrt(5)) / 4: -10,
(sqrt(3) - 1) / sqrt(2**3): 12,
(1 - sqrt(3)) / sqrt(2**3): -12,
(sqrt(5) + 1) / 4: S(10) / 3,
-(sqrt(5) + 1) / 4: -S(10) / 3
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.asinh(i_coeff)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.One
elif arg is S.Infinity:
return
if arg.could_extract_minus_sign():
return cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return C.cosh(i_coeff)
pi_coeff = _pi_coeff(arg)
if pi_coeff is not None:
if not pi_coeff.is_Rational:
if pi_coeff.is_integer:
even = pi_coeff.is_even
if even:
return S.One
elif even is False:
return S.NegativeOne
narg = pi_coeff * S.Pi
if narg != arg:
return cls(narg)
return None
cst_table_some = {
1: S.One,
2: S.Zero,
3: S.Half,
4: S.Half * sqrt(2),
6: S.Half * sqrt(3),
}
cst_table_more = {
(1, 5): (sqrt(5) + 1) / 4,
(2, 5): (sqrt(5) - 1) / 4
}
p = pi_coeff.p
q = pi_coeff.q
Q, P = 2 * p // q, p % q
try:
result = cst_table_some[q]
except KeyError:
if abs(P) > q // 2:
P = q - P
try:
result = cst_table_more[(P, q)]
except KeyError:
if P != p:
result = cls(C.Rational(P, q) * S.Pi)
else:
return None
if Q % 4 in (1, 2):
return -result
else:
return result
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
return cos(m) * cos(x) - sin(m) * sin(x)
if arg.func is acos:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return 1 / sqrt(1 + x**2)
if arg.func is asin:
x = arg.args[0]
return sqrt(1 - x**2)
if arg.func is acot:
x = arg.args[0]
return 1 / sqrt(1 + 1 / x**2)
def _eval_rewrite_as_log(self, x):
return S.Pi/2 + S.ImaginaryUnit * C.log(S.ImaginaryUnit * x + sqrt(1 - x**2))
def fdiff(self, argindex=1):
if argindex == 1:
return 1/sqrt(1 - self.args[0]**2)
else:
raise ArgumentIndexError(self, argindex)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.One
elif arg is S.Infinity:
return
if arg.could_extract_minus_sign():
return cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return C.cosh(i_coeff)
pi_coeff = _pi_coeff(arg)
if pi_coeff is not None:
if not pi_coeff.is_Rational:
if pi_coeff.is_integer:
return (S.NegativeOne)**pi_coeff
narg = pi_coeff*S.Pi
if narg != arg:
return cls(narg)
return None
cst_table_some = {
1 : S.One,
2 : S.Zero,
3 : S.Half,
4 : S.Half*sqrt(2),
6 : S.Half*sqrt(3),
}
cst_table_more = {
(1, 5) : (sqrt(5) + 1)/4,
(2, 5) : (sqrt(5) - 1)/4
}
p = pi_coeff.p
q = pi_coeff.q
Q, P = 2*p // q, p % q
try:
result = cst_table_some[q]
except KeyError:
if abs(P) > q // 2:
P = q - P
try:
result = cst_table_more[(P, q)]
except KeyError:
if P != p:
result = cls(C.Rational(P, q)*S.Pi)
else:
return None
if Q % 4 in (1, 2):
return -result
else:
return result
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
return cos(m)*cos(x)-sin(m)*sin(x)
if arg.func is acos:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return 1 / sqrt(1 + x**2)
if arg.func is asin:
x = arg.args[0]
return sqrt(1 - x ** 2)
if arg.func is acot:
x = arg.args[0]
return 1 / sqrt(1 + 1 / x**2)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Zero
elif arg is S.NegativeInfinity:
return S.Zero
elif arg is S.Zero:
return S.Pi/ 2
elif arg is S.One:
return S.Pi / 4
elif arg is S.NegativeOne:
return -S.Pi / 4
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
sqrt(3)/3 : 3,
-sqrt(3)/3 : -3,
1/sqrt(3) : 3,
-1/sqrt(3) : -3,
sqrt(3) : 6,
-sqrt(3) : -6,
(1+sqrt(2)) : 8,
-(1+sqrt(2)) : -8,
(1-sqrt(2)) : -S(8)/3,
(sqrt(2)-1) : S(8)/3,
sqrt(5+2*sqrt(5)) : 10,
-sqrt(5+2*sqrt(5)) : -10,
(2+sqrt(3)) : 12,
-(2+sqrt(3)) : -12,
(2-sqrt(3)) : S(12)/5,
-(2-sqrt(3)) : -S(12)/5,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.acoth(i_coeff)
def _eval_rewrite_as_atan(self, x):
if x > -1 and x <= 1:
return 2 * atan(sqrt(1 - x**2)/(1 + x))
else:
raise ValueError("The argument must be bounded in the interval (-1,1]")
def _eval_rewrite_as_log(self, x):
return S.Pi / 2 + S.ImaginaryUnit * C.log(S.ImaginaryUnit * x +
sqrt(1 - x**2))
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
elif arg is S.Infinity:
return
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.sinh(i_coeff)
pi_coeff = _pi_coeff(arg)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
if not pi_coeff.is_Rational:
narg = pi_coeff*S.Pi
if narg != arg:
return cls(narg)
return None
cst_table_some = {
2 : S.One,
3 : S.Half*sqrt(3),
4 : S.Half*sqrt(2),
6 : S.Half,
}
cst_table_more = {
(1, 5) : sqrt((5 - sqrt(5)) / 8),
(2, 5) : sqrt((5 + sqrt(5)) / 8)
}
p = pi_coeff.p
q = pi_coeff.q
Q, P = p // q, p % q
try:
result = cst_table_some[q]
except KeyError:
if abs(P) > q // 2:
P = q - P
try:
result = cst_table_more[(P, q)]
except KeyError:
if P != p:
result = cls(C.Rational(P, q)*S.Pi)
else:
return None
if Q % 2 == 1:
return -result
else:
return result
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
return sin(m)*cos(x)+cos(m)*sin(x)
if arg.func is asin:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return x / sqrt(1 + x**2)
if arg.func is acos:
x = arg.args[0]
return sqrt(1 - x**2)
if arg.func is acot:
x = arg.args[0];
return 1 / (sqrt(1 + 1 / x**2) * x)
def _eval_rewrite_as_atan(self, x):
if x > -1 and x <= 1:
return 2 * atan(sqrt(1 - x**2) / (1 + x))
else:
raise ValueError(
"The argument must be bounded in the interval (-1,1]")
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
if arg is S.Zero:
return S.ComplexInfinity
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.coth(i_coeff)
pi_coeff = _pi_coeff(arg, 2)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.ComplexInfinity
if not pi_coeff.is_Rational:
narg = pi_coeff*S.Pi
if narg != arg:
return cls(narg)
return None
cst_table = {
2 : S.Zero,
3 : 1 / sqrt(3),
4 : S.One,
6 : sqrt(3)
}
try:
result = cst_table[pi_coeff.q]
if (2*pi_coeff.p // pi_coeff.q) % 4 in (1, 3):
return -result
else:
return result
except KeyError:
if pi_coeff.p > pi_coeff.q:
p, q = pi_coeff.p % pi_coeff.q, pi_coeff.q
if 2 * p > q:
return -cls(Rational(q - p, q)*S.Pi)
return cls(Rational(p, q)*S.Pi)
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
if (m*2/S.Pi) % 2 == 0:
return cot(x)
else:
return -tan(x)
if arg.func is acot:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return 1 / x
if arg.func is asin:
x = arg.args[0]
return sqrt(1 - x**2) / x
if arg.func is acos:
x = arg.args[0]
return x / sqrt(1 - x**2)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.Zero
elif arg is S.NegativeInfinity:
return S.Zero
elif arg is S.Zero:
return S.Pi / 2
elif arg is S.One:
return S.Pi / 4
elif arg is S.NegativeOne:
return -S.Pi / 4
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
sqrt(3) / 3: 3,
-sqrt(3) / 3: -3,
1 / sqrt(3): 3,
-1 / sqrt(3): -3,
sqrt(3): 6,
-sqrt(3): -6,
(1 + sqrt(2)): 8,
-(1 + sqrt(2)): -8,
(1 - sqrt(2)): -S(8) / 3,
(sqrt(2) - 1): S(8) / 3,
sqrt(5 + 2 * sqrt(5)): 10,
-sqrt(5 + 2 * sqrt(5)): -10,
(2 + sqrt(3)): 12,
-(2 + sqrt(3)): -12,
(2 - sqrt(3)): S(12) / 5,
-(2 - sqrt(3)): -S(12) / 5,
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return -S.ImaginaryUnit * C.acoth(i_coeff)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Infinity:
return S.NegativeInfinity * S.ImaginaryUnit
elif arg is S.NegativeInfinity:
return S.Infinity * S.ImaginaryUnit
elif arg is S.Zero:
return S.Zero
elif arg is S.One:
return S.Pi / 2
elif arg is S.NegativeOne:
return -S.Pi / 2
if arg.could_extract_minus_sign():
return -cls(-arg)
if arg.is_number:
cst_table = {
sqrt(3)/2 : 3,
-sqrt(3)/2 : -3,
sqrt(2)/2 : 4,
-sqrt(2)/2 : -4,
1/sqrt(2) : 4,
-1/sqrt(2) : -4,
sqrt((5-sqrt(5))/8) : 5,
-sqrt((5-sqrt(5))/8) : -5,
S.Half : 6,
-S.Half : -6,
sqrt(2-sqrt(2))/2 : 8,
-sqrt(2-sqrt(2))/2 : -8,
(sqrt(5)-1)/4 : 10,
(1-sqrt(5))/4 : -10,
(sqrt(3)-1)/sqrt(2**3) : 12,
(1-sqrt(3))/sqrt(2**3) : -12,
(sqrt(5)+1)/4 : S(10)/3,
-(sqrt(5)+1)/4 : -S(10)/3
}
if arg in cst_table:
return S.Pi / cst_table[arg]
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.asinh(i_coeff)
def eval(cls, arg):
if arg.is_Number:
if arg is S.NaN:
return S.NaN
elif arg is S.Zero:
return S.Zero
elif arg is S.Infinity:
return
if arg.could_extract_minus_sign():
return -cls(-arg)
i_coeff = arg.as_coefficient(S.ImaginaryUnit)
if i_coeff is not None:
return S.ImaginaryUnit * C.sinh(i_coeff)
pi_coeff = _pi_coeff(arg)
if pi_coeff is not None:
if pi_coeff.is_integer:
return S.Zero
if not pi_coeff.is_Rational:
narg = pi_coeff * S.Pi
if narg != arg:
return cls(narg)
return None
cst_table_some = {
2: S.One,
3: S.Half * sqrt(3),
4: S.Half * sqrt(2),
6: S.Half,
}
cst_table_more = {
(1, 5): sqrt((5 - sqrt(5)) / 8),
(2, 5): sqrt((5 + sqrt(5)) / 8)
}
p = pi_coeff.p
q = pi_coeff.q
Q, P = p // q, p % q
try:
result = cst_table_some[q]
except KeyError:
if abs(P) > q // 2:
P = q - P
try:
result = cst_table_more[(P, q)]
except KeyError:
if P != p:
result = cls(C.Rational(P, q) * S.Pi)
else:
return None
if Q % 2 == 1:
return -result
else:
return result
if arg.is_Add:
x, m = _peeloff_pi(arg)
if m:
return sin(m) * cos(x) + cos(m) * sin(x)
if arg.func is asin:
return arg.args[0]
if arg.func is atan:
x = arg.args[0]
return x / sqrt(1 + x**2)
if arg.func is acos:
x = arg.args[0]
return sqrt(1 - x**2)
if arg.func is acot:
x = arg.args[0]
return 1 / (sqrt(1 + 1 / x**2) * x)
