Esempio n. 1
0
    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))
Esempio n. 2
0
    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))
Esempio n. 3
0
    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"]))
Esempio n. 4
0
 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.)
Esempio n. 5
0
    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])
Esempio n. 6
0
 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.)
Esempio n. 7
0
    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])])
Esempio n. 8
0
    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))
Esempio n. 9
0
    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))
Esempio n. 10
0
 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))
Esempio n. 11
0
    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))
Esempio n. 12
0
    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))
Esempio n. 13
0
    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))
Esempio n. 14
0
    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))
Esempio n. 15
0
    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])])
Esempio n. 16
0
 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))
Esempio n. 17
0
    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))
Esempio n. 18
0
 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)
Esempio n. 19
0
 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)
Esempio n. 20
0
 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)
Esempio n. 21
0
 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)
Esempio n. 22
0
 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)
Esempio n. 23
0
    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)")
Esempio n. 24
0
    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)")
Esempio n. 25
0
    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))
Esempio n. 26
0
    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)")
Esempio n. 27
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))
Esempio n. 28
0
 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)
Esempio n. 29
0
    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)
Esempio n. 30
0
    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)
Esempio n. 31
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.)
Esempio n. 32
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.)
Esempio n. 33
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))
Esempio n. 34
0
    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)
Esempio n. 35
0
    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)
Esempio n. 36
0
    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)
Esempio n. 37
0
    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))
Esempio n. 38
0
 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())
Esempio n. 39
0
 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)
Esempio n. 40
0
 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.])
Esempio n. 41
0
 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)
Esempio n. 42
0
 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.])
Esempio n. 43
0
 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())
Esempio n. 44
0
    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.)])
Esempio n. 45
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)
Esempio n. 46
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)
Esempio n. 47
0
    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))
Esempio n. 48
0
    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)
Esempio n. 49
0
 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)
Esempio n. 50
0
 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)
Esempio n. 51
0
    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) )
Esempio n. 52
0
    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.)
Esempio n. 53
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)
Esempio n. 54
0
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])