def test_var_div_var(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(x / y)
self.assertLessEqual(
np.abs(f.eval_d().real /
(-.44755270475041560619657805305047592426404601827) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-.13600253041648890000441351713180233327939034617) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-.44755270475041560619657805305047592426404601827") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-.13600253041648890000441351713180233327939034617") - 1),
tol_mp)
def test_arith_mpfr(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
self.assertLessEqual(mp.abs((x + y) - mp.Float("0.37")), tol)
self.assertLessEqual(mp.abs((z - y) - mp.Float("5.0095")), tol)
self.assertLessEqual(mp.abs((z * y) - mp.Float("-4.437070")), tol)
self.assertLessEqual(
mp.abs((y / x) -
mp.Float("-.91252955082742316784869976359338061")), tol)
self.assertLessEqual(
mp.abs((x**y) -
mp.Float("0.0038223124228935822000384505727705508")), tol)
self.assertLessEqual(mp.abs((-z) - mp.Float("-1.1495")), tol)
#
result = mp.Float(x)
result += y
self.assertLessEqual(mp.abs(result - mp.Float("0.37")), tol)
result = mp.Float(z)
result -= y
self.assertLessEqual(mp.abs(result - mp.Float("5.0095")), tol)
result = mp.Float(z)
result *= y
self.assertLessEqual(mp.abs(result - mp.Float("-4.437070")), tol)
result = mp.Float(y)
result /= x
self.assertLessEqual(
mp.abs(result - mp.Float("-.91252955082742316784869976359338061")),
tol)
def compute_values(tol, pred, tr, td):
tr.tracking_tolerance(tol)
tr.predictor(pred)
start_time = pybertini.multiprec.Complex("1")
eg_boundary = pybertini.multiprec.Complex("0.1")
midpath_points = [None]*td.num_start_points()
overall_code = pybertini.tracking.SuccessCode.Success
speed_start = time.time()
target_tol_multiplier = 10
same_point_tol = target_tol_multiplier * tol
for ii in range(td.num_start_points()):
#print("Tracking path {}...".format(ii))
midpath_points[ii] = pybertini.multiprec.Vector()
code = tr.track_path(result=midpath_points[ii], start_time=start_time, end_time=eg_boundary, start_point=td.start_point_mp(ii))
if code != pybertini.tracking.SuccessCode.Success:
overall_code = pybertini.tracking.SuccessCode.Failure
from pybertini.multiprec import abs
for ii in range(td.num_start_points()):
for jj in range(ii + 1, td.num_start_points()):
if abs((midpath_points[ii] - midpath_points[jj]).norm()) < same_point_tol:
overall_code = pybertini.tracking.SuccessCode.Failure
#print("encountered a path crossing")
return time.time() - speed_start, overall_code
def test_plus(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(x + y + a)
self.assertLessEqual(np.abs(f.eval_d().real / (5.53) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.118) - 1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("5.53") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-1.118") - 1), tol_mp)
#
f = Function(x + Float("3.87"))
self.assertLessEqual(np.abs(f.eval_d().real / (1.44) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (0.21) - 1), tol_d)
#
f = Function(x + mpfr_complex("3.87", "-2.1"))
self.assertLessEqual(np.abs(f.eval_d().real / (1.44) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.89) - 1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("1.44") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-1.89") - 1), tol_mp)
#
f = Function(x + (-5))
self.assertLessEqual(np.abs(f.eval_d().real / (-7.43) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (0.21) - 1), tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("-7.43") - 1), tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("0.21") - 1),
tol_mp)
#
f = Function(x)
f += y
f += a
self.assertLessEqual(np.abs(f.eval_d().real / (5.53) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.118) - 1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("5.53") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-1.118") - 1), tol_mp)
#
f = Function(x)
f += Float("3.87")
self.assertLessEqual(np.abs(f.eval_d().real / (1.44) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (0.21) - 1), tol_d)
def test_var_times_var(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(x * y * z)
self.assertLessEqual(np.abs(f.eval_d().real / (77.7616926) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-28.8346602) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("77.7616926") - 1), tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-28.8346602") - 1), tol_mp)
def test_power_rule(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = x**2 + y**3;
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real / (-4.86)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(x).imag / (0.42)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real / mpfr_float("-4.86")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag / mpfr_float("0.42")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real / (58.9860)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag / (-56.3376)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real / mpfr_float("58.9860")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag / mpfr_float("-56.3376")-1), tol_mp)
def test_I_construct(self):
x_d = self.x_d
y_d = self.y_d
z_d = self.z_d
p_d = self.p_d
tol_d = self.tol_d
x_mp = self.x_mp
y_mp = self.y_mp
z_mp = self.z_mp
p_mp = self.p_mp
tol_mp = self.tol_mp
y = make_i()
#
self.assertLessEqual(np.abs(y.eval_d().real - (0)), tol_d)
self.assertLessEqual(np.abs(y.eval_d().imag / (1.0) - 1), tol_d)
#
self.assertLessEqual(mp.abs(y.eval_mp().real - mpfr_float("0")),
tol_mp)
self.assertLessEqual(mp.abs(y.eval_mp().imag / mpfr_float("1.0") - 1),
tol_mp)
def test_change_prec(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
mp.default_precision(45)
tol = mp.Float("1e-37")
t = mp.Complex("-2.43", ".21")
t = t**(-2)
self.assertLessEqual(
mp.abs(
t.real -
mp.Float("0.16560329111110602501494676510297183141930819429")),
tol)
self.assertLessEqual(
mp.abs(t.imag - mp.Float(
"0.028838165251841866149715852522538399390278791818")), tol)
mp.default_precision(30)
tol = mp.Float("1e-27")
def test_sum_rule(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = x+y+a;
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real/(1.0)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(x).imag-0), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real/mpfr_float("1.0")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag-mpfr_float("0")), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real/(1.0)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag-0), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real/mpfr_float("1.0")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag-mpfr_float("0")), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(z).real-0), tol_d)
self.assertLessEqual(np.abs(df.eval_d(z).imag-0), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(z).real-mpfr_float("0.0")), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(z).imag-mpfr_float("0")), tol_mp)
def test_trancendental(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = sin(x*y) + exp(z*y) - log(x*x);
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real / (-17.648420086229721902138620795382021306411662490)-1), 9e-13)
self.assertLessEqual(np.abs(df.eval_d(x).imag / (-803.11883403426275105632833868183320319093878729)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real / mpfr_float("-17.648420086229721902138620795382021306411662490")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag / mpfr_float("-803.11883403426275105632833868183320319093878729")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real / (-100.97157179433748763552280062599971478593963953)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag / (361.98093991820979266721712882115615553425318528)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real / mpfr_float("-100.97157179433748763552280062599971478593963953")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag / mpfr_float("361.98093991820979266721712882115615553425318528")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(z).real / (-2.1642907643013779167501866500194314960002972412e-14)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(z).imag / (2.1105887207247540399884720817624768568595288922e-14)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(z).real / mpfr_float("-2.1642907643013779167501866500194314960002972412e-14")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(z).imag / mpfr_float("2.1105887207247540399884720817624768568595288922e-14")-1), tol_mp)
def test_prod_rule(self):
x = self.x; y = self.y; z = self.z; p = self.p; a = self.a; b = self.b;
tol_d = self.tol_d; tol_mp = self.tol_mp;
#
f = x**2*y**4 - a*x*y*z**2;
df = f.differentiate();
#
self.assertLessEqual(np.abs(df.eval_d(x).real / (-559.28968169592)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(x).imag / (3577.05276993648)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(x).real / mpfr_float("-559.28968169592")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(x).imag / mpfr_float("3577.05276993648")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(y).real / (1161.85042980828)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(y).imag / (-3157.24325320476)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(y).real / mpfr_float("1161.85042980828")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(y).imag / mpfr_float("-3157.24325320476")-1), tol_mp)
#
df.reset()
self.assertLessEqual(np.abs(df.eval_d(z).real / (-520.5265859088)-1), tol_d)
self.assertLessEqual(np.abs(df.eval_d(z).imag / (84.7479679056)-1), tol_d)
#
self.assertLessEqual(mp.abs(df.eval_mp(z).real / mpfr_float("-520.5265859088")-1), tol_mp)
self.assertLessEqual(mp.abs(df.eval_mp(z).imag / mpfr_float("84.7479679056")-1), tol_mp)
def test_Pi_construct(self):
x_d = self.x_d
y_d = self.y_d
z_d = self.z_d
p_d = self.p_d
tol_d = self.tol_d
x_mp = self.x_mp
y_mp = self.y_mp
z_mp = self.z_mp
p_mp = self.p_mp
tol_mp = self.tol_mp
x = Pi()
y = make_pi()
#
self.assertLessEqual(
np.abs(x.eval_d().real /
(3.1415926535897932384626433832795028841971693994) - 1),
tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(
mp.abs(x.eval_mp().real / mpfr_float(
"3.1415926535897932384626433832795028841971693994") - 1),
tol_mp)
self.assertLessEqual(mp.abs(x.eval_mp().imag - mpfr_float("0")),
tol_mp)
#
self.assertLessEqual(
np.abs(y.eval_d().real /
(3.1415926535897932384626433832795028841971693994) - 1),
tol_d)
self.assertLessEqual(np.abs(y.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(
mp.abs(y.eval_mp().real / mpfr_float(
"3.1415926535897932384626433832795028841971693994") - 1),
tol_mp)
self.assertLessEqual(mp.abs(y.eval_mp().imag - mpfr_float("0")),
tol_mp)
def test_Float_eval(self):
x_d = self.x_d
y_d = self.y_d
z_d = self.z_d
p_d = self.p_d
tol_d = self.tol_d
x_mp = self.x_mp
y_mp = self.y_mp
z_mp = self.z_mp
p_mp = self.p_mp
tol_mp = self.tol_mp
x = Float(x_mp)
y = Float(y_mp)
z = Float(z_mp)
#
self.assertLessEqual(np.abs(x.eval_d().real / (-2.43) - 1), tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag / (.21) - 1), tol_d)
#
self.assertLessEqual(mp.abs(y.eval_mp().real / mpfr_float("4.84") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(y.eval_mp().imag / mpfr_float("-1.94") - 1), tol_mp)
def test_num_times_var(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(a * x * b * y)
#
self.assertLessEqual(np.abs(f.eval_d().real / (3.4011196056) - 1),
tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-110.9953448712) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("3.4011196056") - 1), tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-110.9953448712") - 1),
tol_mp)
def test_E_construct(self):
x_d = self.x_d
y_d = self.y_d
z_d = self.z_d
p_d = self.p_d
tol_d = self.tol_d
x_mp = self.x_mp
y_mp = self.y_mp
z_mp = self.z_mp
p_mp = self.p_mp
tol_mp = self.tol_mp
x = E()
y = make_e()
#
self.assertLessEqual(
np.abs(x.eval_d().real /
(2.7182818284590452353602874713526624977572470937) - 1),
tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(
mp.abs(x.eval_mp().real - mpfr_float(
"2.7182818284590452353602874713526624977572470937")), tol_mp)
self.assertLessEqual(mp.abs(x.eval_mp().imag - mpfr_float("0")),
tol_mp)
#
self.assertLessEqual(
np.abs(y.eval_d().real /
(2.7182818284590452353602874713526624977572470937) - 1),
tol_d)
self.assertLessEqual(np.abs(y.eval_d().imag - (0)), tol_d)
#
self.assertLessEqual(
mp.abs(y.eval_mp().real / mpfr_float(
"2.7182818284590452353602874713526624977572470937") - 1),
tol_mp)
self.assertLessEqual(mp.abs(y.eval_mp().imag - mpfr_float("0")),
tol_mp)
def test_Variable_eval(self):
x_d = self.x_d
y_d = self.y_d
z_d = self.z_d
p_d = self.p_d
tol_d = self.tol_d
x_mp = self.x_mp
y_mp = self.y_mp
z_mp = self.z_mp
p_mp = self.p_mp
tol_mp = self.tol_mp
x = Variable("x")
y = Variable("y")
x.set_current_value(x_d)
x.set_current_value(x_mp)
#
self.assertLessEqual(np.abs(x.eval_d().real / (-2.43) - 1), tol_d)
self.assertLessEqual(np.abs(x.eval_d().imag / (.21) - 1), tol_d)
#
self.assertLessEqual(
mp.abs(x.eval_mp().real / mpfr_float("-2.43") - 1), tol_mp)
self.assertLessEqual(mp.abs(x.eval_mp().imag / mpfr_float(".21") - 1),
tol_mp)
def test_change_prec(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
mp.default_precision(40)
tol = mp.Float("1e-37")
t = mp.Float("4.23")
self.assertLessEqual(
mp.abs(t**(-2) - mp.Float(
"0.055888089689206333238323580861682566828183245868")), tol)
mp.default_precision(30)
tol = mp.Float("1e-27")
def test_Float_funcs(self):
x_d = self.x_d
y_d = self.y_d
z_d = self.z_d
p_d = self.p_d
tol_d = self.tol_d
x_mp = self.x_mp
y_mp = self.y_mp
z_mp = self.z_mp
p_mp = self.p_mp
tol_mp = self.tol_mp
x = Float(x_mp)
y = Float(y_mp)
z = Float(z_mp)
#
self.assertEqual(x.degree(), 0)
d = y.differentiate()
self.assertLessEqual(mp.abs(d.eval_mp().real - mpfr_float("0")),
tol_mp)
self.assertLessEqual(mp.abs(d.eval_mp().imag - mpfr_float("0")),
tol_mp)
self.assertTrue(y.is_homogeneous())
self.assertTrue(y.is_polynomial())
def test_sub(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(x - y - a)
self.assertLessEqual(np.abs(f.eval_d().real / (-10.39) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (1.538) - 1), tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("-10.39") - 1), tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("1.538") - 1), tol_mp)
#
f = Function(y - Float("3.87"))
self.assertLessEqual(np.abs(f.eval_d().real / (0.97) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94) - 1), tol_d)
#
f = Function(y - Float("3.87", "0"))
self.assertLessEqual(np.abs(f.eval_d().real / (0.97) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94) - 1), tol_d)
#
#
f = Function(y - mpfr_complex("3.87", "-2.1"))
self.assertLessEqual(np.abs(f.eval_d().real / (0.97) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (0.16) - 1), tol_d)
#
self.assertLessEqual(mp.abs(f.eval_mp().real / mpfr_float("0.97") - 1),
tol_mp)
self.assertLessEqual(mp.abs(f.eval_mp().imag / mpfr_float("0.16") - 1),
tol_mp)
#
f = Function(y - (-5))
self.assertLessEqual(np.abs(f.eval_d().real / (9.84) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94) - 1), tol_d)
#
f = Function(x)
f -= y
f -= a
self.assertLessEqual(np.abs(f.eval_d().real / (-10.39) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (1.538) - 1), tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("-10.39") - 1), tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("1.538") - 1), tol_mp)
#
f = Function(y)
f -= Float("3.87")
self.assertLessEqual(np.abs(f.eval_d().real / (0.97) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-1.94) - 1), tol_d)
def test_misc_funcs(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
#
res = mp.norm(x)
self.assertLessEqual(mp.abs(res - mp.Float("5.949")), tol)
res = mp.abs2(x)
self.assertLessEqual(mp.abs(res - mp.Float("5.949")), tol)
res = mp.conj(x)
self.assertLessEqual(mp.abs(res.real - x.real), tol)
self.assertLessEqual(mp.abs(res.imag - (-x.imag)), tol)
res = mp.polar(mp.Float("3.21"), mp.Float("-5.62"))
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("2.5295931897050156212406076422629449344206513531")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("1.9761726378527774897831544771425943545375239972")),
tol)
res = mp.arg(y)
self.assertLessEqual(
mp.abs(
res -
mp.Float("-.38121862770417378405072154507774424569831993182")),
tol)
res = mp.inverse(z)
self.assertLessEqual(
mp.abs(res.real - mp.Float(
"-0.15238180880075963272315628064317633672297417498")), tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"0.017189984912554828938368401412062021935878722517")), tol)
def test_trancendentals(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
self.assertLessEqual(
mp.abs((mp.exp(x)) -
mp.Float("68.717232173846461408252914213396109")), tol)
self.assertLessEqual(
mp.abs((mp.log(z)) -
mp.Float("0.13932706522109918666170810230684295")), tol)
self.assertLessEqual(
mp.abs((mp.sqrt(z)) -
mp.Float("1.0721473779289860297522254519889560")), tol)
#
self.assertLessEqual(
mp.abs((mp.sin(x)) -
mp.Float("-.88588921129660245121088859729926237")), tol)
self.assertLessEqual(
mp.abs((mp.cos(y)) -
mp.Float("-.75285494656729525719980460936483635")), tol)
self.assertLessEqual(
mp.abs((mp.tan(z)) -
mp.Float("2.2315038042849919118711153687209483")), tol)
#
self.assertLessEqual(
mp.abs((mp.asin(p)) -
mp.Float("0.34691689752716170922069696210451452")), tol)
self.assertLessEqual(
mp.abs((mp.acos(p)) -
mp.Float("1.2238794292677349100106247295352369")), tol)
self.assertLessEqual(
mp.abs((mp.atan(z)) -
mp.Float("0.85483739856328448882289109284144652")), tol)
#
self.assertLessEqual(
mp.abs((mp.sinh(x)) -
mp.Float("34.351339891649022639414777866662100")), tol)
self.assertLessEqual(
mp.abs((mp.cosh(y)) -
mp.Float("23.743209684188284295743755381842167")), tol)
self.assertLessEqual(
mp.abs((mp.tanh(z)) -
mp.Float("0.81758837109637920976170104688035086")), tol)
def test_arith_mp_float(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
a = mp.Float("3.12")
b = mp.Float("-5.92")
res = mp.Complex(x + a)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.69")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.21")), tol)
res = mp.Complex(y - b)
self.assertLessEqual(mp.abs(res.real - mp.Float("10.76")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.94")), tol)
res = mp.Complex(a + x)
self.assertLessEqual(mp.abs(res.real - mp.Float("0.69")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.21")), tol)
res = mp.Complex(b - y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-10.76")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.94")), tol)
res = mp.Complex(z * a)
self.assertLessEqual(mp.abs(res.real - mp.Float("-20.2176")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.28072")), tol)
res = mp.Complex(a * z)
self.assertLessEqual(mp.abs(res.real - mp.Float("-20.2176")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.28072")), tol)
res = mp.Complex(y / b)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-.81756756756756756756756756756756756756756756757")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float(".3277027027027027027027027027027027027027027027")),
tol)
res = mp.Complex(b / y)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-1.0538301972842157915642975887484736586585850264")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("-.42240301296102864372618539714298324334662292381")),
tol)
res = mp.Complex(x**a)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-16.054376621961088182387920766649714821973863952")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("-1.7411284591111236754359685247799914985638458821")),
tol)
#
#
#
res = mp.Complex(x)
res += a
self.assertLessEqual(mp.abs(res.real - mp.Float("0.69")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.21")), tol)
res = mp.Complex(y)
res -= b
self.assertLessEqual(mp.abs(res.real - mp.Float("10.76")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.94")), tol)
res = mp.Complex(z)
res *= a
self.assertLessEqual(mp.abs(res.real - mp.Float("-20.2176")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-2.28072")), tol)
res = mp.Complex(y)
res /= b
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-.81756756756756756756756756756756756756756756757")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float(".3277027027027027027027027027027027027027027027")),
tol)
#
res = mp.Complex(x**4)
self.assertLessEqual(mp.abs(res.real - mp.Float("33.30735228")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-11.96306496")), tol)
#
res = mp.Complex(-z)
self.assertLessEqual(mp.abs(res.real - mp.Float("6.48")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".731")), tol)
def test_power(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(y**3)
self.assertLessEqual(np.abs(f.eval_d().real / (58.732432) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-129.035608) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("58.732432") - 1), tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-129.035608") - 1), tol_mp)
#
f = Function(pow(y, 3))
self.assertLessEqual(np.abs(f.eval_d().real / (58.732432) - 1), tol_d)
self.assertLessEqual(np.abs(f.eval_d().imag / (-129.035608) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float("58.732432") - 1), tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float("-129.035608") - 1), tol_mp)
#
f = Function(x**p)
self.assertLessEqual(
np.abs(f.eval_d().real /
(-.35190932545709434788093164550270669097948909024) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-6.7687858345625791466707575744042177964518271087) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-.35190932545709434788093164550270669097948909024") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-6.7687858345625791466707575744042177964518271087") - 1),
tol_mp)
#
f = Function(pow(x, p))
self.assertLessEqual(
np.abs(f.eval_d().real /
(-.35190932545709434788093164550270669097948909024) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-6.7687858345625791466707575744042177964518271087) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-.35190932545709434788093164550270669097948909024") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-6.7687858345625791466707575744042177964518271087") - 1),
tol_mp)
def test_trans_funcs(self):
x = self.x
y = self.y
z = self.z
p = self.p
a = self.a
b = self.b
tol_d = self.tol_d
tol_mp = self.tol_mp
#
f = Function(sin(x))
self.assertLessEqual(
np.abs(f.eval_d().real /
(-.66749329633668695550441899166308616328986315948) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-.16020928942503633132090203927960650380076680938) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-.66749329633668695550441899166308616328986315948") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-.16020928942503633132090203927960650380076680938") - 1),
tol_mp)
#
f = Function(cos(y))
self.assertLessEqual(
np.abs(f.eval_d().real /
(0.45194679593300564730917329070452033759984813611) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-3.3798161097977088705360399142708324234265626016) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"0.45194679593300564730917329070452033759984813611") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-3.3798161097977088705360399142708324234265626016") - 1),
tol_mp)
#
f = Function(tan(z))
self.assertLessEqual(
np.abs(f.eval_d().real /
(-.11998086808607765336591715593714295443402911227) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-.63859741450762243500349270264429166927927928889) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-.11998086808607765336591715593714295443402911227") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-.63859741450762243500349270264429166927927928889") - 1),
tol_mp)
#
f = Function(asin(x))
self.assertLessEqual(
np.abs(f.eval_d().real /
(-1.4763431474004472804452143435221887167393328861) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(1.5406263884278099750127157814537559611048741005) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-1.4763431474004472804452143435221887167393328861") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"1.5406263884278099750127157814537559611048741005") - 1),
tol_mp)
#
f = Function(acos(y))
self.assertLessEqual(
np.abs(f.eval_d().real /
(0.38769800860408664087229892623614567735197135529) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(2.3379037587834289977359318611458042347281923566) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"0.38769800860408664087229892623614567735197135529") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"2.3379037587834289977359318611458042347281923566") - 1),
tol_mp)
#
f = Function(atan(z))
self.assertLessEqual(
np.abs(f.eval_d().real /
(-1.4195347801361539102032503530226060969949192059) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-0.16801358511827150554928904776095870747673962940e-1) -
1), tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-1.4195347801361539102032503530226060969949192059") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-0.16801358511827150554928904776095870747673962940e-1") - 1),
tol_mp)
#
f = Function(exp(y))
self.assertLessEqual(
np.abs(f.eval_d().real /
(-45.639359208255772966298371983389382308765171859) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-117.94721623715960520658000231550940351946595854) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"-45.639359208255772966298371983389382308765171859") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-117.94721623715960520658000231550940351946595854") - 1),
tol_mp)
#
f = Function(log(z))
self.assertLessEqual(
np.abs(f.eval_d().real /
(1.8750432590213669716781046977781508038070552297) - 1),
tol_d)
self.assertLessEqual(
np.abs(f.eval_d().imag /
(-3.0292589170775161726973168096174940982043177322) - 1),
tol_d)
#
self.assertLessEqual(
mp.abs(f.eval_mp().real / mpfr_float(
"1.8750432590213669716781046977781508038070552297") - 1),
tol_mp)
self.assertLessEqual(
mp.abs(f.eval_mp().imag / mpfr_float(
"-3.0292589170775161726973168096174940982043177322") - 1),
tol_mp)
def test_arith_mp_complex(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
#
res = mp.Complex(x + y)
self.assertLessEqual(mp.abs(res.real - mp.Float("2.41")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.73")), tol)
res = mp.Complex(y - z)
self.assertLessEqual(mp.abs(res.real - mp.Float("11.32")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.209")), tol)
res = mp.Complex(y + x)
self.assertLessEqual(mp.abs(res.real - mp.Float("2.41")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.73")), tol)
res = mp.Complex(z - y)
self.assertLessEqual(mp.abs(res.real - mp.Float("-11.32")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("1.209")), tol)
res = mp.Complex(z * x)
self.assertLessEqual(mp.abs(res.real - mp.Float("15.89991")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("0.41553")), tol)
res = mp.Complex(x * z)
self.assertLessEqual(mp.abs(res.real - mp.Float("15.89991")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".41553")), tol)
res = mp.Complex(y / x)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-2.0454866364094805849722642460917801311144730207")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("0.62158345940494200706001008572869389813414019163")),
tol)
res = mp.Complex(x / y)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-.44755270475041560619657805305047592426404601827")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("-.13600253041648890000441351713180233327939034617")),
tol)
res = mp.Complex(y**z)
self.assertLessEqual(
mp.abs(res.real - mp.Float(
"0.0000051612634484879218649489640888954160904291899461")),
tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"0.16242051733741136410199105656393042124100116889e-4")), tol)
#
#
#
res = mp.Complex(x)
res += y
self.assertLessEqual(mp.abs(res.real - mp.Float("2.41")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.73")), tol)
res = mp.Complex(y)
res -= z
self.assertLessEqual(mp.abs(res.real - mp.Float("11.32")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-1.209")), tol)
res = mp.Complex(z)
res *= x
self.assertLessEqual(mp.abs(res.real - mp.Float("15.89991")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float(".41553")), tol)
res = mp.Complex(y)
res /= x
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-2.0454866364094805849722642460917801311144730207")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("0.62158345940494200706001008572869389813414019163")),
tol)
def test_trancendentals(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
#
res = mp.exp(x)
self.assertLessEqual(
mp.abs(res.real - mp.Float(
"0.086102743899954532232498058731947255067424332219")), tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"0.018352149302889219131202317785160051395400089327")), tol)
res = mp.log(y)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("1.6514099178148475691128039277241118340531698491")),
tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"-0.38121862770417378405072154507774424569831993182")), tol)
res = mp.sqrt(z)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("0.14335482322754515813189359093523204816185445814")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("-2.5496177371015053245565185485769652617478797292")),
tol)
res = mp.sin(x)
self.assertLessEqual(
mp.abs(res.real - mp.Float(
"-0.66749329633668695550441899166308616328986315948")), tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"-0.16020928942503633132090203927960650380076680938")), tol)
res = mp.cos(y)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("0.45194679593300564730917329070452033759984813611")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("-3.3798161097977088705360399142708324234265626016")),
tol)
res = mp.tan(z)
self.assertLessEqual(
mp.abs(res.real - mp.Float(
"-0.11998086808607765336591715593714295443402911227")), tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"-0.63859741450762243500349270264429166927927928889")), tol)
res = mp.asin(x)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-1.4763431474004472804452143435221887167393328861")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("1.5406263884278099750127157814537559611048741005")),
tol)
res = mp.acos(y)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("0.38769800860408664087229892623614567735197135529")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("2.3379037587834289977359318611458042347281923566")),
tol)
res = mp.atan(z)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-1.4195347801361539102032503530226060969949192059")),
tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"-0.016801358511827150554928904776095870747673962940")), tol)
res = mp.sinh(x)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-5.5116175435238027338707341903303682792175349461")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("1.1931117850318239903301857156967336540973461581")),
tol)
res = mp.cosh(y)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-22.821106324812396153305984541517740047129741299")),
tol)
self.assertLessEqual(
mp.abs(
res.imag -
mp.Float("-58.969920999917202046449299163531439999586349377")),
tol)
res = mp.tanh(z)
self.assertLessEqual(
mp.abs(
res.real -
mp.Float("-.99999948909538256503828034023523935671055767287")),
tol)
self.assertLessEqual(
mp.abs(res.imag - mp.Float(
"-0.0000046773288796255165542679839050497228616710086412")),
tol)
res = mp.square(z)
self.assertLessEqual(mp.abs(res.real - mp.Float("41.456039")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("9.47376")), tol)
res = mp.cube(z)
self.assertLessEqual(mp.abs(res.real - mp.Float("-261.70981416")), tol)
self.assertLessEqual(mp.abs(res.imag - mp.Float("-91.694329309")), tol)
def test_arith_int(self):
x = self.x
y = self.y
z = self.z
p = self.p
tol = self.tol
self.assertLessEqual(mp.abs((x + 8) - mp.Float("12.23")), tol)
self.assertLessEqual(mp.abs((y - 2) - mp.Float("-5.86")), tol)
self.assertLessEqual(mp.abs((8 + x) - mp.Float("12.23")), tol)
self.assertLessEqual(mp.abs((2 - y) - mp.Float("5.86")), tol)
self.assertLessEqual(mp.abs((z * 6) - mp.Float("6.897")), tol)
self.assertLessEqual(mp.abs((6 * z) - mp.Float("6.897")), tol)
self.assertLessEqual(
mp.abs((y / 3) -
mp.Float("-1.2866666666666666666666666666666667")), tol)
self.assertLessEqual(
mp.abs((3 / y) -
mp.Float("-.77720207253886010362694300518134714")), tol)
self.assertLessEqual(mp.abs((x**3) - mp.Float("75.686967")), tol)
#
result = mp.Float(x)
result += 8
self.assertLessEqual(mp.abs(result - mp.Float("12.23")), tol)
result = mp.Float(y)
result -= 2
self.assertLessEqual(mp.abs(result - mp.Float("-5.86")), tol)
result = mp.Float(z)
result *= 6
self.assertLessEqual(mp.abs(result - mp.Float("6.897")), tol)
result = mp.Float(y)
result /= 3
self.assertLessEqual(
mp.abs(result - mp.Float("-1.2866666666666666666666666666666667")),
tol)
#
self.assertLessEqual(mp.abs((-z) - mp.Float("-1.1495")), tol)