def test_inverse_functions(self): from pyaudi import gdual_double as gdual from pyaudi import sinh, cosh, tanh from pyaudi import asinh, acosh, atanh from pyaudi import sin, cos, tan from pyaudi import asin, acos, atan x = gdual(1.1, "x", 6) y = gdual(1.2, "y", 6) p1 = 1. / (x + y) self.assertTrue((cos(acos(p1)) - p1).is_zero(1e-12)) self.assertTrue((acos(cos(p1)) - p1).is_zero(1e-12)) self.assertTrue((sin(asin(p1)) - p1).is_zero(1e-12)) self.assertTrue((asin(sin(p1)) - p1).is_zero(1e-12)) self.assertTrue((tan(atan(p1)) - p1).is_zero(1e-12)) self.assertTrue((atan(tan(p1)) - p1).is_zero(1e-12)) self.assertTrue((cosh(acosh(p1)) - p1).is_zero(1e-12)) self.assertTrue((acosh(cosh(p1)) - p1).is_zero(1e-12)) self.assertTrue((sinh(asinh(p1)) - p1).is_zero(1e-12)) self.assertTrue((asinh(sinh(p1)) - p1).is_zero(1e-12)) self.assertTrue((tanh(atanh(p1)) - p1).is_zero(1e-12)) self.assertTrue((atanh(tanh(p1)) - p1).is_zero(1e-12))
def test_inverse_functions(self): from pyaudi import gdual_double as gdual from pyaudi import sinh, cosh, tanh from pyaudi import asinh, acosh, atanh from pyaudi import sin, cos, tan from pyaudi import asin, acos, atan x = gdual(1.1, "x",6); y = gdual(1.2, "y",6); p1 = 1. / (x + y); self.assertTrue((cos(acos(p1))-p1).is_zero(1e-12)) self.assertTrue((acos(cos(p1))-p1).is_zero(1e-12)) self.assertTrue((sin(asin(p1))-p1).is_zero(1e-12)) self.assertTrue((asin(sin(p1))-p1).is_zero(1e-12)) self.assertTrue((tan(atan(p1))-p1).is_zero(1e-12)) self.assertTrue((atan(tan(p1))-p1).is_zero(1e-12)) self.assertTrue((cosh(acosh(p1))-p1).is_zero(1e-12)) self.assertTrue((acosh(cosh(p1))-p1).is_zero(1e-12)) self.assertTrue((sinh(asinh(p1))-p1).is_zero(1e-12)) self.assertTrue((asinh(sinh(p1))-p1).is_zero(1e-12)) self.assertTrue((tanh(atanh(p1))-p1).is_zero(1e-12)) self.assertTrue((atanh(tanh(p1))-p1).is_zero(1e-12))
def test_serialization_gdual_double(self): import cloudpickle as cpk from dcgpy import kernel_set_gdual_double as kernel_set from dcgpy import kernel_gdual_double as kernel from pyaudi import gdual_double as gdual # cpp kernels cpp_kv = kernel_set([ "sum", "diff", "mul", "div", "tanh", "sig", "cos", "sin", "log", "exp", "gaussian", "sqrt", "ReLu", "ELU", "ISRU" ])() x1 = gdual(1.2, "x1", 2) x2 = gdual(-1.2, "x2", 2) x3 = gdual(3.2, "x3", 2) for cpp_k in cpp_kv: cpp_k2 = cpk.loads(cpk.dumps(cpp_k)) self.assertEqual(cpp_k([x1, x2, x3]), cpp_k2([x1, x2, x3])) self.assertEqual(cpp_k(["a", "b", "c"]), cpp_k2(["a", "b", "c"])) # pythonic kernels my_py_kernel = kernel(my_py_fun, my_py_fun_print, "my_py_fun") my_py_kernel2 = cpk.loads(cpk.dumps(my_py_kernel)) self.assertEqual(my_py_kernel([x1, x2, x3]), my_py_kernel2([x1, x2, x3])) self.assertEqual(my_py_kernel(["a", "b", "c"]), my_py_kernel2(["a", "b", "c"]))
def test_addition(self): from pyaudi import gdual_double as gdual p1 = gdual(1); p2 = gdual(0, "x", 4); self.assertEqual(p1 + p2, p2 + p1) self.assertEqual(1 + p2, p2 + 1) self.assertEqual(1. + p2, p2 + 1.)
def test_map_inversion(self): from pyaudi import gdual_double as gdual from pyaudi import sin, exp, invert_map, cos x = gdual(0., "x", 11) f = 1. / (1 + exp(sin(x) + 1. / (x + 1))) + x g = invert_map([f], False)[0] dx = g.evaluate({"dp0": 0.01}) newf = f.evaluate({"dx": dx}) self.assertAlmostEqual(newf, f.constant_cf + 0.01, delta=1e-10) x = gdual(0, "x", 4) y = gdual(0, "y", 4) f0 = 1. / (1 + exp(sin(x * y) + 1. / (x + 1))) + x - y f1 = 1. / (1 + exp(cos(x * y) + 1. / (y + 1))) + x + y g0, g1 = invert_map([f0, f1], False) dx = g0.evaluate({"dp0": 0.01, "dp1": -0.02}) dy = g1.evaluate({"dp0": 0.01, "dp1": -0.02}) newf0 = f0.evaluate({"dx": dx, "dy": dy}) newf1 = f1.evaluate({"dx": dx, "dy": dy}) self.assertAlmostEqual(newf0, f0.constant_cf + 0.01, delta=1e-6) self.assertAlmostEqual(newf1, f1.constant_cf - 0.02, delta=1e-6) # We test the API g0, g1 = invert_map(map=[f0, f1], verbose=False) g0, g1 = invert_map(map=[f0, f1]) g0, g1 = invert_map([f0, f1])
def test_addition(self): from pyaudi import gdual_double as gdual p1 = gdual(1) p2 = gdual(0, "x", 4) self.assertEqual(p1 + p2, p2 + p1) self.assertEqual(1 + p2, p2 + 1) self.assertEqual(1. + p2, p2 + 1.)
def test_gdual_vdouble(self): from dcgpy import expression_gdual_vdouble as expression from dcgpy import kernel_set_gdual_vdouble as kernel_set from pyaudi import gdual_vdouble as gdual ex = expression(1,1,1,6,6,2,kernel_set(["sum","mul", "div", "diff"])(), 32) self.assertEqual(ex([gdual([1, 2, -1, 2], "x", 2)]), [gdual([1, 1, 1, 1])])
def test_exp_log(self): from pyaudi import gdual_double as gdual from pyaudi import exp, log x = gdual(2.3, "x",5); y = gdual(1.5, "y",5); p1 = x*x*y - x*y*x*x*x + 3*y*y*y*y*x*y*x; self.assertTrue((exp(log(p1)) - p1).is_zero(1e-10))
def test_exp_log(self): from pyaudi import gdual_double as gdual from pyaudi import exp, log x = gdual(2.3, "x", 5) y = gdual(1.5, "y", 5) p1 = x * x * y - x * y * x * x * x + 3 * y * y * y * y * x * y * x self.assertTrue((exp(log(p1)) - p1).is_zero(1e-10))
def test_extract_terms(self): from pyaudi import gdual_vdouble as gdual from pyaudi import sin x = gdual([1e-4, -1e-4], "x", 3) sinx = sin(x) self.assertTrue(sinx == sinx.extract_terms(0) + sinx.extract_terms(1) + sinx.extract_terms(2) + sinx.extract_terms(3)) self.assertTrue(x.trim(1e-3) == gdual([0, 0], "x", 1))
def test_tanh(self): from pyaudi import gdual_double as gdual from pyaudi import sinh, cosh, tanh x = gdual(2.3, "x",10); y = gdual(1.5, "y",10); p1 = x + y; self.assertTrue((tanh(p1) - sinh(p1) / cosh(p1)).is_zero(1e-12))
def test_abs(self): from pyaudi import gdual_double as gdual from pyaudi import abs as gd_abs x = gdual(1.1, "x", 6) y = gdual(1.2, "y", 6) self.assertEqual(x + y, gd_abs(x + y)) self.assertEqual(-(x + y), -gd_abs(x + y))
def test_abs(self): from pyaudi import gdual_double as gdual from pyaudi import abs as gd_abs x = gdual(1.1, "x",6); y = gdual(1.2, "y",6); self.assertEqual(x+y, gd_abs(x+y)) self.assertEqual(-(x + y), - gd_abs(x+y))
def test_tanh(self): from pyaudi import gdual_double as gdual from pyaudi import sinh, cosh, tanh x = gdual(2.3, "x", 10) y = gdual(1.5, "y", 10) p1 = x + y self.assertTrue((tanh(p1) - sinh(p1) / cosh(p1)).is_zero(1e-12))
def test_gdual_vdouble(self): from dcgpy import expression_gdual_vdouble as expression from dcgpy import kernel_set_gdual_vdouble as kernel_set from pyaudi import gdual_vdouble as gdual ex = expression(1, 1, 1, 6, 6, 2, kernel_set(["sum", "mul", "div", "diff"])(), 32) self.assertEqual(ex([gdual([1, 2, -1, 2], "x", 2)]), [gdual([1, 1, 1, 1])])
def test_extract_terms(self): from pyaudi import gdual_double as gdual from pyaudi import sin x = gdual(1e-4, "x", 3) sinx = sin(x) self.assertEqual( sinx, sinx.extract_terms(0) + sinx.extract_terms(1) + sinx.extract_terms(2) + sinx.extract_terms(3)) self.assertEqual(x.trim(1e-3), gdual(0, "x", 1))
def test_cbrt(self): from pyaudi import gdual_double as gdual from pyaudi import cbrt x = gdual(2.3, "x",3); y = gdual(1.5, "y",3); p1 = x*x*y - x*y*x*x*x + 3*y*y*y*y*x*y*x; # positive p0 p2 = x*x*y - x*y*x*x*x - 3*y*y*y*y*x*y*x; # negative coefficient self.assertTrue((cbrt(p1)*cbrt(p1)*cbrt(p1) - p1).is_zero(1e-12)) self.assertTrue((cbrt(p2)*cbrt(p2)*cbrt(p2) - p2).is_zero(1e-12))
def test_multiplication(self): from pyaudi import gdual_double as gdual x = gdual(3, "x", 2) y = gdual(7, "y", 2) p1 = x + 3 * x * y + y * y self.assertEqual(p1.find_cf([0, 0]), 115) self.assertEqual(p1.find_cf([1, 0]), 22) self.assertEqual(p1.find_cf([0, 1]), 23) self.assertEqual(p1.find_cf([1, 1]), 3) self.assertEqual(p1.find_cf([2, 0]), 0) self.assertEqual(p1.find_cf([0, 2]), 1)
def test_multiplication(self): from pyaudi import gdual_double as gdual x = gdual(3, "x",2) y = gdual(7, "y",2) p1 = x + 3*x*y + y*y self.assertEqual(p1.find_cf([0,0]), 115) self.assertEqual(p1.find_cf([1,0]), 22) self.assertEqual(p1.find_cf([0,1]), 23) self.assertEqual(p1.find_cf([1,1]), 3) self.assertEqual(p1.find_cf([2,0]), 0) self.assertEqual(p1.find_cf([0,2]), 1)
def test_serialization(self): from pyaudi import gdual_double as gdual import pickle as pk x = gdual(1, "x", 4) y = gdual(1, "y", 4) z = gdual(1, "z", 4) f = (x*x*x + x*y*z + z*x*y)*(x*x*x + x*y*z + z*x*y)*(x*x*x + x*y*z + z*x*y)*(x*x*x + x*y*z + z*x*y) pk.dump(f, open("tmp.pk", "wb")) new_f = pk.load(open("tmp.pk", "rb")) self.assertEqual(f, new_f) self.assertEqual(f.order, new_f.order)
def test_division(self): from pyaudi import gdual_double as gdual x = gdual(0, "x",2) y = gdual(1, "y",2) p1 = 1 / (x + 2*x*y + y*y) self.assertEqual(p1.find_cf([0,0]), 1) self.assertEqual(p1.find_cf([1,0]), -3) self.assertEqual(p1.find_cf([0,1]), -2) self.assertEqual(p1.find_cf([1,1]), 10) self.assertEqual(p1.find_cf([2,0]), 9) self.assertEqual(p1.find_cf([0,2]), 3)
def test_division(self): from pyaudi import gdual_double as gdual x = gdual(0, "x", 2) y = gdual(1, "y", 2) p1 = 1 / (x + 2 * x * y + y * y) self.assertEqual(p1.find_cf([0, 0]), 1) self.assertEqual(p1.find_cf([1, 0]), -3) self.assertEqual(p1.find_cf([0, 1]), -2) self.assertEqual(p1.find_cf([1, 1]), 10) self.assertEqual(p1.find_cf([2, 0]), 9) self.assertEqual(p1.find_cf([0, 2]), 3)
def test_gdual_vdouble(self): from dcgpy import kernel_gdual_vdouble as kernel from pyaudi import gdual_vdouble as gdual my_kernel = kernel(self.my_sum, self.print_my_sum, "my_sum_kernel") self.assertEqual(my_kernel.__repr__(), "my_sum_kernel") x = gdual([1,-1], "x", 2) y = gdual([2,-2], "y", 2) z = gdual([-2,1], "z", 2) self.assertEqual(my_kernel([x, y, z]), x + y + z) self.assertEqual(my_kernel(["x", "y"]), "(x+y)")
def test_gdual_double(self): from dcgpy import kernel_gdual_double as kernel from pyaudi import gdual_double as gdual my_kernel = kernel(my_py_fun, my_py_fun_print, "my_sum_kernel") self.assertEqual(my_kernel.__repr__(), "my_sum_kernel") x = gdual(1, "x", 2) y = gdual(2, "y", 2) z = gdual(3, "z", 2) self.assertEqual(my_kernel([x, y, z]), x + y + z) self.assertEqual(my_kernel(["x", "y"]), "(x+y)")
def test_cbrt(self): from pyaudi import gdual_double as gdual from pyaudi import cbrt x = gdual(2.3, "x", 3) y = gdual(1.5, "y", 3) p1 = x * x * y - x * y * x * x * x + 3 * \ y * y * y * y * x * y * x # positive p0 p2 = x * x * y - x * y * x * x * x - 3 * y * \ y * y * y * x * y * x # negative coefficient self.assertTrue((cbrt(p1) * cbrt(p1) * cbrt(p1) - p1).is_zero(1e-12)) self.assertTrue((cbrt(p2) * cbrt(p2) * cbrt(p2) - p2).is_zero(1e-12))
def test_gdual_vdouble(self): from dcgpy import kernel_gdual_vdouble as kernel from pyaudi import gdual_vdouble as gdual my_kernel = kernel(self.my_sum, self.print_my_sum, "my_sum_kernel") self.assertEqual(my_kernel.__repr__(), "my_sum_kernel") x = gdual([1, -1], "x", 2) y = gdual([2, -2], "y", 2) z = gdual([-2, 1], "z", 2) self.assertEqual(my_kernel([x, y, z]), x + y + z) self.assertEqual(my_kernel(["x", "y"]), "(x+y)")
def test_identities(self): from pyaudi import gdual_double as gdual x = gdual(2, "x",3); y = gdual(3, "y",3); p1 = x*x+y-x*x*x*x*y-y*x*x p2 = y*y-x+y*y*y*y*x-2*x self.assertEqual((x + y)*(x + y), x*x + y*y + 2*x*y) self.assertEqual((p1 + p2)*(p1 + p2), p1*p1 + p2*p2 + 2*p1*p2) self.assertEqual(x*x*x*x-y*y*y*y, (x-y)*(x+y)*(x*x+y*y)) self.assertEqual(p1*p1*p1*p1-p2*p2*p2*p2, (p1-p2)*(p1+p2)*(p1*p1+p2*p2)) self.assertTrue(((p1/p2) * (p2/p1) - 1).is_zero(1e-12)) self.assertTrue(((p1/p2) * p2 - p1).is_zero(1e-12))
def test_serialization(self): from pyaudi import gdual_double as gdual import pickle as pk x = gdual(1, "x", 4) y = gdual(1, "y", 4) z = gdual(1, "z", 4) f = (x * x * x + x * y * z + z * x * y) * (x * x * x + x * y * z + z * x * y) * \ (x * x * x + x * y * z + z * x * y) * \ (x * x * x + x * y * z + z * x * y) pk.dump(f, open("tmp.pk", "wb")) new_f = pk.load(open("tmp.pk", "rb")) self.assertEqual(f, new_f) self.assertEqual(f.order, new_f.order)
def test_integrate_partial(self): from pyaudi import gdual_double as gdual x = gdual(1, "x", 4) y = gdual(1, "y", 4) z = gdual(1, "z", 4) f = x*x*x + x*y*z + z*x*y fx = 3*x*x + y*z + z*y fy = x*z + z*x fz = y*x + x*y self.assertEqual(f.partial("x"), fx) self.assertEqual(f.partial("y"), fy) self.assertEqual(f.partial("z"), fz)
def test_integrate_partial(self): from pyaudi import gdual_double as gdual x = gdual(1, "x", 4) y = gdual(1, "y", 4) z = gdual(1, "z", 4) f = x * x * x + x * y * z + z * x * y fx = 3 * x * x + y * z + z * y fy = x * z + z * x fz = y * x + x * y self.assertEqual(f.partial("x"), fx) self.assertEqual(f.partial("y"), fy) self.assertEqual(f.partial("z"), fz)
def test_subs(self): from pyaudi import gdual_double as gdual x = gdual(1, "x", 1) y = gdual(-1, "y", 1) f = x * y * x / (x - y) # -0.75*dx-0.5+0.25*dy res2 = f.subs("dx", 1) res3 = f.subs("dy", 1) self.assertEqual(res2.constant_cf, -1.25) self.assertEqual(res2.constant_cf, -1.25) self.assertEqual(res2.get_derivative({"dy": 1}), 0.25) self.assertEqual(res2.get_derivative({"dx": 1}), 0.) self.assertEqual(res3.constant_cf, -0.25) self.assertEqual(res3.constant_cf, -0.25) self.assertEqual(res3.get_derivative({"dx": 1}), -0.75) self.assertEqual(res3.get_derivative({"dy": 1}), 0.)
def test_subs(self): from pyaudi import gdual_double as gdual x = gdual(1, "x", 1) y = gdual(-1, "y", 1) f = x*y*x / (x-y) # -0.75*dx-0.5+0.25*dy res2 = f.subs("dx", 1) res3 = f.subs("dy", 1) self.assertEqual(res2.constant_cf, -1.25) self.assertEqual(res2.constant_cf, -1.25) self.assertEqual(res2.get_derivative({"dy":1}), 0.25) self.assertEqual(res2.get_derivative({"dx":1}), 0.) self.assertEqual(res3.constant_cf, -0.25) self.assertEqual(res3.constant_cf, -0.25) self.assertEqual(res3.get_derivative({"dx":1}), -0.75) self.assertEqual(res3.get_derivative({"dy":1}), 0.)
def test_identities(self): from pyaudi import gdual_double as gdual x = gdual(2, "x", 3) y = gdual(3, "y", 3) p1 = x * x + y - x * x * x * x * y - y * x * x p2 = y * y - x + y * y * y * y * x - 2 * x self.assertEqual((x + y) * (x + y), x * x + y * y + 2 * x * y) self.assertEqual((p1 + p2) * (p1 + p2), p1 * p1 + p2 * p2 + 2 * p1 * p2) self.assertEqual(x * x * x * x - y * y * y * y, (x - y) * (x + y) * (x * x + y * y)) self.assertEqual(p1 * p1 * p1 * p1 - p2 * p2 * p2 * p2, (p1 - p2) * (p1 + p2) * (p1 * p1 + p2 * p2)) self.assertTrue(((p1 / p2) * (p2 / p1) - 1).is_zero(1e-12)) self.assertTrue(((p1 / p2) * p2 - p1).is_zero(1e-12))
def test_gdual_vdouble(self): from dcgpy import kernel_set_gdual_vdouble as kernel_set from dcgpy import kernel_gdual_vdouble as kernel from pyaudi import gdual_vdouble as gdual a = kernel_set(["diff"]) a.push_back("mul") my_kernel = kernel(self.my_sum, self.print_my_sum, "my_sum_kernel") a.push_back(my_kernel) self.assertEqual(a.__repr__(), "[diff, mul, my_sum_kernel]") x = gdual([1, -1], "x", 2) y = gdual([2, -2], "y", 2) z = gdual([-2, 1], "z", 2) self.assertEqual(a[0]([x, y, z]), x - y - z) self.assertEqual(a[1]([x, y, z]), x * y * z) self.assertEqual(a[2]([x, y, z]), x + y + z)
def test_gdual_vdouble(self): from dcgpy import kernel_set_gdual_vdouble as kernel_set from dcgpy import kernel_gdual_vdouble as kernel from pyaudi import gdual_vdouble as gdual a = kernel_set(["diff"]) a.push_back("mul") my_kernel = kernel(self.my_sum, self.print_my_sum, "my_sum_kernel") a.push_back(my_kernel) self.assertEqual(a.__repr__(), "[diff, mul, my_sum_kernel]") x = gdual([1,-1], "x", 2) y = gdual([2,-2], "y", 2) z = gdual([-2,1], "z", 2) self.assertEqual(a[0]([x,y,z]), x-y-z) self.assertEqual(a[1]([x,y,z]), x*y*z) self.assertEqual(a[2]([x,y,z]), x+y+z)
def test_gdual_double(self): from dcgpy import kernel_set_gdual_double as kernel_set from dcgpy import kernel_gdual_double as kernel from pyaudi import gdual_double as gdual a = kernel_set(["diff"]) a.push_back("mul") my_kernel = kernel(my_py_fun, my_py_fun_print, "my_sum_kernel") a.push_back(my_kernel) self.assertEqual(a.__repr__(), "[diff, mul, my_sum_kernel]") x = gdual(1, "x", 2) y = gdual(2, "y", 2) z = gdual(3, "z", 2) self.assertEqual(a[0]([x, y, z]), x - y - z) self.assertEqual(a[1]([x, y, z]), x * y * z) self.assertEqual(a[2]([x, y, z]), x + y + z)
def test_sinh_and_cosh(self): from pyaudi import gdual_double as gdual from pyaudi import sinh, cosh, sinh_and_cosh x = gdual(2.3, "x",8); y = gdual(1.5, "y",8); p1 = x + y; self.assertTrue((sinh(2*p1) - 2 * sinh(p1) * cosh(p1)).is_zero(1e-12)) self.assertTrue((cosh(2*p1) - 1 - 2*sinh(p1)*sinh(p1)).is_zero(1e-12)) self.assertTrue((cosh(2*p1) + 1 - 2*cosh(p1)*cosh(p1)).is_zero(1e-12)) self.assertTrue((cosh(2*p1) - cosh(p1)*cosh(p1) - sinh(p1) * sinh(p1)).is_zero(1e-12)) self.assertTrue((- sinh(p1)*sinh(p1) + cosh(p1)*cosh(p1) - 1).is_zero(1e-12)) res = sinh_and_cosh(p1); self.assertTrue((res[0] - sinh(p1)).is_zero(1e-12)) self.assertTrue((res[1] - cosh(p1)).is_zero(1e-12))
def test_function_methods(self): from pyaudi import gdual_double as gdual from pyaudi import exp, log, sin, cos x = gdual(0.5, "x", 11) self.assertEqual(exp(x), x.exp()) self.assertEqual(log(x), x.log()) self.assertEqual(sin(x), x.sin()) self.assertEqual(cos(x), x.cos())
def test_construction(self): from pyaudi import gdual_vdouble as gdual x = gdual([2., 3.], "x", 3) c = gdual([-2., -3]) with self.assertRaises(ValueError): x = gdual([2., 3.], "dx", 3) self.assertEqual(x.constant_cf, [2, 3]) self.assertEqual(x.find_cf([0]), [2, 3]) self.assertEqual(c.constant_cf, [-2, -3]) with self.assertRaises(ValueError): x.find_cf([1,3]) c.find_cf([1,3]) c.find_cf([0]) # no symbols in constants with self.assertRaises(TypeError): c.find_cf(["x"]) with self.assertRaises(AttributeError): x.find_cf(5) self.assertEqual(x.degree, 1) self.assertEqual(x.order, 3) self.assertEqual(x.symbol_set, ["x"]) self.assertEqual(x.symbol_set_size, 1) self.assertEqual(c.degree, 0) self.assertEqual(c.order, 0) self.assertEqual(c.symbol_set, []) self.assertEqual(c.symbol_set_size, 0) with self.assertRaises(AttributeError): gdual(1, "x", 2) gdual(1)
def test_construction(self): from pyaudi import gdual_double as gdual x = gdual(2., "x", 3) c = gdual(-2.) with self.assertRaises(ValueError): x = gdual(2., "dx", 3) self.assertEqual(x.constant_cf, 2) self.assertEqual(x.find_cf([0]), 2) self.assertEqual(c.constant_cf, -2) with self.assertRaises(ValueError): x.find_cf([1, 3]) c.find_cf([1, 3]) c.find_cf([0]) # no symbols in constants with self.assertRaises(ValueError): x.find_cf([5]) c.find_cf([1]) self.assertEqual(x.degree, 1) self.assertEqual(x.order, 3) self.assertEqual(x.symbol_set, ["x"]) self.assertEqual(x.symbol_set_size, 1) self.assertEqual(c.degree, 0) self.assertEqual(c.order, 0) self.assertEqual(c.symbol_set, []) self.assertEqual(c.symbol_set_size, 0) with self.assertRaises(TypeError): gdual([1.], "x", 2) gdual([1.])
def test_construction(self): from pyaudi import gdual_vdouble as gdual x = gdual([2., 3.], "x", 3) c = gdual([-2., -3]) with self.assertRaises(ValueError): x = gdual([2., 3.], "dx", 3) self.assertEqual(x.constant_cf, [2, 3]) self.assertEqual(x.find_cf([0]), [2, 3]) self.assertEqual(c.constant_cf, [-2, -3]) with self.assertRaises(ValueError): x.find_cf([1, 3]) c.find_cf([1, 3]) c.find_cf([0]) # no symbols in constants with self.assertRaises(TypeError): c.find_cf(["x"]) with self.assertRaises(AttributeError): x.find_cf(5) self.assertEqual(x.degree, 1) self.assertEqual(x.order, 3) self.assertEqual(x.symbol_set, ["x"]) self.assertEqual(x.symbol_set_size, 1) self.assertEqual(c.degree, 0) self.assertEqual(c.order, 0) self.assertEqual(c.symbol_set, []) self.assertEqual(c.symbol_set_size, 0) with self.assertRaises(AttributeError): gdual(1, "x", 2) gdual(1)
def test_construction(self): from pyaudi import gdual_double as gdual x = gdual(2., "x", 3) c = gdual(-2.) with self.assertRaises(ValueError): x = gdual(2., "dx", 3) self.assertEqual(x.constant_cf, 2) self.assertEqual(x.find_cf([0]), 2) self.assertEqual(c.constant_cf, -2) with self.assertRaises(ValueError): x.find_cf([1,3]) c.find_cf([1,3]) c.find_cf([0]) # no symbols in constants with self.assertRaises(ValueError): x.find_cf([5]) c.find_cf([1]) self.assertEqual(x.degree, 1) self.assertEqual(x.order, 3) self.assertEqual(x.symbol_set, ["x"]) self.assertEqual(x.symbol_set_size, 1) self.assertEqual(c.degree, 0) self.assertEqual(c.order, 0) self.assertEqual(c.symbol_set, []) self.assertEqual(c.symbol_set_size, 0) with self.assertRaises(TypeError): gdual([1.], "x", 2) gdual([1.])
def test_numpy_calls(self): from pyaudi import gdual_double as gdual from pyaudi import exp, log, sin, cos import numpy as np x = gdual(0.5, "x", 11) self.assertEqual(np.exp(x), x.exp()) self.assertEqual(np.log(x), x.log()) self.assertEqual(np.sin(x), x.sin()) self.assertEqual(np.cos(x), x.cos())
def test_gdual_double(self): from dcgpy import expression_gdual_double as expression from dcgpy import kernel_set_gdual_double as kernel_set from pyaudi import gdual_double as gdual ex = expression(1, 1, 1, 6, 6, 2, kernel_set(["sum", "mul", "div", "diff"])(), 0, 20) self.assertEqual(ex([gdual(1, "x", 2)]), [gdual(0.)]) self.assertEqual(ex([gdual(2, "x", 2)]), [gdual(0.)]) self.assertEqual(ex([gdual(-1, "x", 2)]), [gdual(0.)]) self.assertEqual(ex([gdual(-2, "x", 2)]), [gdual(0.)])
def test_subtraction(self): from pyaudi import gdual_double as gdual p1 = gdual(1) p2 = gdual(0, "x", 4) self.assertEqual(p1 - p1, gdual(0)) self.assertEqual(p2 - p2, gdual(0)) self.assertEqual(p1 - p2, - (p2 - p1)) self.assertEqual(1 + p1 - p1, gdual(1)) self.assertEqual(1 + p2 - p2, gdual(1)) self.assertEqual(1. + p1 - p1, gdual(1)) self.assertEqual(1. + p2 - p2, gdual(1)) self.assertEqual((1 - p1) + (p1 + p2), 1 + p2)
def test_subtraction(self): from pyaudi import gdual_double as gdual p1 = gdual(1) p2 = gdual(0, "x", 4) self.assertEqual(p1 - p1, gdual(0)) self.assertEqual(p2 - p2, gdual(0)) self.assertEqual(p1 - p2, -(p2 - p1)) self.assertEqual(1 + p1 - p1, gdual(1)) self.assertEqual(1 + p2 - p2, gdual(1)) self.assertEqual(1. + p1 - p1, gdual(1)) self.assertEqual(1. + p2 - p2, gdual(1)) self.assertEqual((1 - p1) + (p1 + p2), 1 + p2)
def test_sin_and_cos(self): from pyaudi import gdual_double as gdual from pyaudi import sin, cos, sin_and_cos x = gdual(2.3, "x", 8) y = gdual(1.5, "y", 8) p1 = x + y self.assertTrue((sin(2 * p1) - 2 * sin(p1) * cos(p1)).is_zero(1e-12)) self.assertTrue( (cos(2 * p1) - 1 + 2 * sin(p1) * sin(p1)).is_zero(1e-12)) self.assertTrue( (cos(2 * p1) + 1 - 2 * cos(p1) * cos(p1)).is_zero(1e-12)) self.assertTrue((cos(2 * p1) - cos(p1) * cos(p1) + sin(p1) * sin(p1)).is_zero(1e-12)) self.assertTrue( (sin(p1) * sin(p1) + cos(p1) * cos(p1) - 1).is_zero(1e-12)) res = sin_and_cos(p1) self.assertTrue((res[0] - sin(p1)).is_zero(1e-12)) self.assertTrue((res[1] - cos(p1)).is_zero(1e-12))
def test_loss_gdual_vdouble(self): from dcgpy import expression_gdual_vdouble as expression from dcgpy import kernel_set_gdual_vdouble as kernel_set from pyaudi import gdual_vdouble as gdual import numpy as np ex = expression(1, 1, 1, 6, 6, 2, kernel_set(["sum", "mul", "div", "diff"])(), 32) x = gdual([1., 2.], "x", 3) loss_list = ex.loss([[x]], [ex([x])], "MSE") loss_array = ex.loss(np.array([[x]]), np.array([ex([x])]), "MSE") self.assertEqual(loss_list, loss_array)
def test_order_promotion(self): from pyaudi import gdual_double as gdual c = gdual(1) x = gdual(2, "x", 4) y = gdual(-2, "y", 2) self.assertEqual(c.order, 0) self.assertEqual((x + y).order, 4) self.assertEqual((x - y).order, 4) self.assertEqual((x * y).order, 4) self.assertEqual((x / y).order, 4) self.assertEqual((x + c).order, 4) self.assertEqual((x - c).order, 4) self.assertEqual((x * c).order, 4) self.assertEqual((x / c).order, 4) self.assertEqual((y + x).order, 4) self.assertEqual((y - x).order, 4) self.assertEqual((y * x).order, 4) self.assertEqual((y / x).order, 4) self.assertEqual((c + x).order, 4) self.assertEqual((c - x).order, 4) self.assertEqual((c * x).order, 4) self.assertEqual((c / x).order, 4)
def test_exponentiation(self): from pyaudi import gdual_double as gdual x = gdual(0., "x",3) y = gdual(0., "y",3) p1 = x*x*y + x*y*x*x*x - 3*y*y*y*y*x*y*x + 3.2 self.assertEqual(p1**3, p1*p1*p1) self.assertEqual(p1**3., p1*p1*p1) self.assertTrue((p1**gdual(3)- p1*p1*p1).is_zero(1e-12)) self.assertTrue((p1**gdual(3.1) - p1**3.1).is_zero(1e-12)) x = gdual(0., "x",3) y = gdual(0., "y",3) p1 = x+y-3*x*y+y*y p2 = p1 - 3.5 self.assertTrue( (3**gdual(3.2) - 3**3.2).is_zero(1e-12) ) self.assertTrue( (p2**3 - p2**3.).is_zero(1e-12) ) self.assertTrue( (p2**-1 - 1 / p2).is_zero(1e-12) ) self.assertTrue( (p2**-1. - 1 / p2).is_zero(1e-12) ) self.assertTrue( ((p1+3.5)**gdual(-1.1) - (p1+3.5)**-1.1).is_zero(1e-12) )
def test_derivatives(self): from pyaudi import gdual_double as gdual x = gdual(1, "x",4) y = gdual(1, "y",4) z = gdual(1, "z",4) f = x*x*x*x*x + x*y*z*x*x + z*x*y*y*y self.assertEqual(f.get_derivative([1,1,1]), 6.) self.assertEqual(f.get_derivative([2,1,1]), 6.) self.assertEqual(f.get_derivative([1,2,1]), 6.) self.assertEqual(f.get_derivative([1,1,2]), 0.) self.assertEqual(f.get_derivative([4,0,0]),120.) with self.assertRaises(ValueError): f.get_derivative([4,1,1]) x = gdual(1, "x",8) y = gdual(1, "y",8) f = (x * y + 2 * x * x * y) / (1 + x + y) self.assertEqual(f.get_derivative([1,1]), 1.) self.assertAlmostEqual(f.get_derivative([2,2]), 0, delta=1e-12) self.assertAlmostEqual(f.get_derivative([3,3]), 0, delta=1e-12) self.assertAlmostEqual(f.get_derivative([4,4]), 0, delta=1e-12) # we test the dictionary interface x = gdual(1, "x",4) y = gdual(1, "y",4) z = gdual(1, "z",4) f = x*x*x*x*x + x*y*z*x*x + z*x*y*y*y dictionary = {"dx": 1, "dy": 1, "dz": 1} self.assertEqual(f.get_derivative(dictionary), 6.) with self.assertRaises(ValueError): f.get_derivative([4,1,1]) dictionary = {"dx": 4, "dy": 1, "dz": 1} f.get_derivative(dictionary) dictionary = {"dx": 1, "dr": 1, "dz": 1} self.assertEqual(f.get_derivative(dictionary), 0.)
from pyaudi import gdual_double as gdual from pyaudi import exp, log, cbrt # We want to compute the Taylor expansion of a function f (and thus all derivatives) at x=2, y=3 # 1 - Define the generalized dual numbers (7 is the truncation order, i.e. the maximum order of derivation we will need) x = gdual(2, "x", 7); y = gdual(3, "y", 7); # 2 - Compute your function as usual f = exp(x*x + cbrt(y) / log(x*y)); # 3 - Inspect the results (this does not require any more computations) print("Taylor polynomial: " + str(f)) # This is the Taylor expansion of f (truncated at the 7th order) print("Derivative value [1,0]: " + str(f.get_derivative([1,0]))) # This is the value of the derivative (d / dx) print("Derivative value [4,3]: " + str(f.get_derivative([4,3]))) # This is the value of the mixed derivative (d^7 / dx^4dy^3) # 4 - Using the dictionary interface (note the presence of the "d" before all variables) print("Derivative value [1,0]: " + str(f.get_derivative({"dx":1}))) # This is the value of the derivative (d / dx) print("Derivative value [4,3]: " + str(f.get_derivative({"dx":4, "dy":3}))) # This is the value of the mixed derivative (d^7 / dx^4dy^3)
from dcgpy import expression_gdual_double as expression from dcgpy import kernel_set_gdual_double as kernel_set from pyaudi import gdual_double as gdual # 1- Instantiate a random expression using the 4 basic arithmetic operations ks = kernel_set(["sum", "diff", "div", "mul"]) ex = expression(1, 1, 1, 6, 6, 2, ks(), 4232123212) # 2 - Define the symbol set (in our case, 1 input variable named "x") and print the expression in_sym = ["x"] print("Expression:", ex(in_sym)[0]) # 3 - Print the simplified expression print("Simplified expression:", ex.simplify(in_sym)) # 4 - Visualize the dCGP graph ex.visualize(in_sym) # 5 - Define a gdual number of value 1.2 and truncation order 2 x = gdual(1.2, "x", 2) # 6 - Compute the output of the expression and its second derivative in x = 1.2 and print print("Expression in x=1.2:", ex([x])[0]) print("Second derivative:", ex([x])[0].get_derivative([2])) # 5 - Mutate the expression with 2 random mutations of active genes and print ex.mutate_active(2) print("Mutated expression:", ex(in_sym)[0])