def test_less_than():
x = ad.variable(3.0)
y = ad.variable(4.0)
a = 1
assert x < y
def test_equal():
x = ad.variable(3.0)
y = ad.variable(3.0)
assert x == y
x = ad.variable(3.0)
y = ad.variable(4.0)
assert x != y
alpha = 2.0
beta = 3.0
f1 = alpha * x + beta
f2 = x * alpha + beta
f3 = beta + alpha * x
f4 = beta + x * alpha
assert f1 == f2
assert f1 == f3
assert f1 == f4
f5 = beta * x + alpha
assert f1 != f5
z = 3.0
assert x != z
def test_logistic():
L = 1
k = 1
x0 = 1
logistic = lambda x: L / (1 + np.exp(-k * (x - x0)))
log_der = lambda x: (1 - logistic(x)) * logistic(x)
f1 = ad.logistic(5)
assert np.allclose(f1.val, logistic(5))
x2 = ad.variable(10)
f2 = ad.logistic(x2)
assert np.allclose(f2.val, logistic(10))
assert np.allclose(f2.der, log_der(10))
x3 = ad.variable(-24)
f3 = ad.logistic(x3)
assert np.allclose(f3.val, logistic(-24))
assert np.allclose(f3.der, log_der(-24))
L = 2
k = 1
x0 = 1
x3 = ad.variable(-24)
f3 = ad.logistic(x3)
assert np.allclose(f3.val, logistic(-24))
assert np.allclose(f3.der, log_der(-24))
def test_less_equal():
x = ad.variable(3.0)
y = ad.variable(4.0)
z = ad.variable(4.0)
assert x <= y
assert z <= y
assert y <= z
def test_greater_than():
x = ad.variable(3.0)
y = ad.variable(4.0)
z = ad.variable(4.0)
assert not (y > z)
assert y > x
assert z > x
def test_greater_equal():
x = ad.variable(3.0)
y = ad.variable(3.0)
z = ad.variable(5.0)
assert y >= x
assert x >= y
assert z >= x
assert z >= y
def test_notequal():
x = ad.variable(3.0)
y = ad.variable(4.0)
assert x != y
alpha = 7.0
beta = 8.0
f1 = alpha * x + beta
f5 = beta * x + alpha
assert f1 != f5
assert f1 != 3
def test_sqrt():
# square root of a scalar
f1 = ad.sqrt(81)
assert np.allclose(f1.val, 9)
# square root of a variable
x2 = ad.variable(49)
f2 = ad.sqrt(x2)
assert np.allclose(f2.val, 7)
assert np.allclose(f2.der, 1 / 14)
x3 = ad.variable(64)
f3 = 5 + 2 * ad.sqrt(x3)
assert np.allclose(f3.val, 21)
assert np.allclose(f3.der, 1 / 8)
def test_cosh():
# cosh of a scalar
f1 = ad.cosh(0)
assert np.allclose(f1.val, (np.exp(0) + np.exp(0)) / 2)
# cosh of a variable
x2 = ad.variable(2)
f2 = ad.cosh(x2)
assert np.allclose(f2.val, (np.exp(2) + np.exp(-2)) / 2)
assert np.allclose(f2.der, (np.exp(2) - np.exp(-2)) / 2)
x3 = ad.variable(10)
f3 = ad.cosh(x3)
assert np.allclose(f3.val, (np.exp(10) - np.exp(-10)) / 2)
assert np.allclose(f3.der, (np.exp(10) + np.exp(-10)) / 2)
def test_sinh():
# sinh of a scalar
f1 = ad.sinh(2)
assert np.allclose(f1.val, (np.exp(2) - np.exp(-2)) / 2)
# sinh of a variable
x2 = ad.variable(4)
f2 = ad.sinh(x2)
assert np.allclose(f2.val, (np.exp(4) - np.exp(-4)) / 2)
assert np.allclose(f2.der, (np.exp(4) + np.exp(-4)) / 2)
x3 = ad.variable(-1)
f3 = ad.sinh(x3)
assert np.allclose(f3.val, (np.exp(-1) - np.exp(1)) / 2)
assert np.allclose(f3.der, (np.exp(-1) + np.exp(1)) / 2)
def test_exp():
# exponential of a scalar
f1 = ad.exp(10)
assert np.allclose(f1.val, np.exp(10))
# exponential of a variable
x2 = ad.variable(5)
f2 = ad.exp(x2)
assert np.allclose(f2.val, np.exp(5))
assert np.allclose(f2.der, np.exp(5))
x3 = ad.variable(4)
f3 = 5 + 2 * ad.exp(x3)
assert np.allclose(f3.val, 5 + 2 * np.exp(4))
assert np.allclose(f3.der, 2 * np.exp(4))
def test_arccos():
arccos = lambda x: np.arccos(x)
arccos_der = lambda x: -1 / np.sqrt(1 - x**2)
f1 = ad.arccos(np.pi / 4)
assert np.allclose(f1.val, arccos(np.pi / 4))
x2 = ad.variable(0)
f2 = ad.arccos(x2)
assert np.allclose(f2.val, arccos(0))
assert np.allclose(f2.der, arccos_der(0))
x3 = ad.variable(np.pi / 5)
f3 = ad.arccos(x3)
assert np.allclose(f3.val, arccos(np.pi / 5))
assert np.allclose(f3.der, arccos_der(np.pi / 5))
def test_tanh():
th = lambda x: ((np.exp(x) - np.exp(-x)) / 2) / (
(np.exp(x) + np.exp(-x)) / 2)
th_der = lambda x: 1 / ((np.exp(x) + np.exp(-x)) / 2)**2
# tanh of a scalar
f1 = ad.tanh(3)
assert np.allclose(f1.val, th(3))
# tanh of a variable
x2 = ad.variable(-2)
f2 = ad.tanh(x2)
assert np.allclose(f2.val, th(-2))
assert np.allclose(f2.der, th_der(-2))
x3 = ad.variable(0)
f3 = ad.tanh(x3)
assert np.allclose(f3.val, th(0))
assert np.allclose(f3.der, th_der(0))
def test_log():
# log of a scalar
f1 = ad.log(1)
assert np.allclose(f1.val, 0)
f2 = ad.log(10)
assert np.allclose(f2.val, np.log(10))
# log of a variable
x3 = ad.variable(1)
f3 = ad.log(x3)
assert np.allclose(f3.val, 0)
assert np.allclose(f3.der, 1)
x4 = ad.variable(3)
f4 = ad.log(x4) * 5 + 1
assert np.allclose(f4.val, np.log(3) * 5 + 1)
assert np.allclose(f4.der, 5 / 3)
def test_simpleFunc7():
func12_val = lambda x: np.sqrt(17) / np.exp(2 * x)
func12_der = lambda x: -2 * np.sqrt(17) * np.exp(-2 * x)
a12 = 2
x12 = ad.variable(a12)
f12 = ad.sqrt(17) / ad.exp(2 * x12)
assert f12.val == func12_val(a12)
assert f12.der == func12_der(a12)
def test_simpleFunc8():
func13_val = lambda x: np.log(5**2 - 2 * x**2)
func13_der = lambda x: (-4 * x) / (25 - 2 * x**2)
a13 = 1 / 2
x13 = ad.variable(a13)
f13 = ad.log(5**2 - 2 * x13**2)
assert f13.val == func13_val(a13)
assert f13.der == func13_der(a13)
def test_simpleFunc9():
func14_val = lambda x: np.sin(x) / (3 - 2 * np.cos(x))
func14_der = lambda x: (-2 + 3 * np.cos(x)) / (3 - 2 * np.cos(x))**2
a14 = np.pi / 4
x14 = ad.variable(a14)
f14 = ad.sin(x14) / (3 - 2 * ad.cos(x14))
assert np.isclose(f14.val, func14_val(a14))
assert np.isclose(f14.der, func14_der(a14))
def test_simpleFunc6():
func11_val = lambda x: ((x**3) + 4 * x) / np.sin(3)
func11_der = lambda x: ((3 * x**2) + 4) / np.sin(3)
a11 = 6
x11 = ad.variable(a11)
f11 = ((x11**3) + 4 * x11) / ad.sin(3)
assert f11.val == func11_val(a11)
assert f11.der == func11_der(a11)
def test_simpleFunc5():
def f1(x):
return 254 * np.sqrt(x) - np.tan(x) + 1
def f1_dx(x):
return 127 / np.sqrt(x) - (1 / np.cos(x))**2
x1 = ad.variable(65)
f = 254 * ad.sqrt(x1) - ad.tan(x1) + 1
assert f.val == f1(65)
assert f.der == f1_dx(65)
def test_simpleFunc4():
def f1(x):
return 17 * np.log(x) + 25 + 1 / x
def f1_dx(x):
return 17 / x - 1 / x**2
x1 = ad.variable(39)
f = 17 * ad.log(x1) + 25 + 1 / x1
assert f.val == f1(39)
assert f.der == f1_dx(39)
def test_simpleFunc3():
def f1(x):
return np.sin(x) / 3 + np.cos(x) / x
def f1_dx(x):
return -np.sin(x) / x - np.cos(x) / x**2 + np.cos(x) / 3
x1 = ad.variable(83)
f = ad.sin(x1) / 3 + ad.cos(x1) / x1
assert f.val == f1(83)
assert f.der == f1_dx(83)
def test_simpleFunc2():
def f1(x):
return x**4 - 30 / x
def f1_dx(x):
return 4 * x**3 + 30 / x**2
x1 = ad.variable(46)
f = x1**4 - 30 / x1
assert f.val == f1(46)
assert f.der == f1_dx(46)
def test_arctan():
arctan = lambda x: np.arctan(x)
arctan_der = lambda x: 1 / (1 + x**2)
f1 = ad.arctan(np.pi / 4)
assert np.allclose(f1.val, arctan(np.pi / 4))
x2 = ad.variable(0)
f2 = ad.arctan(x2)
assert np.allclose(f2.val, arctan(0))
assert np.allclose(f2.der, arctan_der(0))
def test_simpleFunc1():
def f1(x):
return 2 * x * np.exp(x) + np.sqrt(x)
def f1_dx(x):
return 2 * x * np.exp(x) + 2 * np.exp(x) + 1 / (2 * np.sqrt(x))
x1 = ad.variable(22)
f = 2 * x1 * ad.exp(x1) + ad.sqrt(x1)
assert f.val == f1(22)
assert f.der == f1_dx(22)
def test_simpleFunc10():
func15_val = lambda x: 3 * x**(-4) - x**2 * np.tan(x)
func15_der = lambda x: (-12 / x**5) - 2 * x * np.tan(x) - x**2 * (
(np.tan(x))**2 + 1)
a15 = 0.7
x15 = ad.variable(a15)
f15 = 3 * x15**(-4) - x15**2 * ad.tan(x15)
assert np.isclose(f15.val, func15_val(a15))
assert np.isclose(f15.der, func15_der(a15))
def test_cos():
# Cosine of variable:
f1 = ad.cos(np.pi * 3 / 4)
assert np.isclose(f1.val, -np.sqrt(2) / 2)
assert np.isclose(f1.der, 0)
# Cosine of variable:
x2 = ad.variable(np.pi)
f2 = ad.cos(x2)
assert np.isclose(f2.val, -1.0)
assert np.isclose(f2.der, 0.0)
# Cosine of variable times constant:
x3 = ad.variable(0.0)
f3 = ad.cos(x3) * 5
assert np.isclose(f3.val, 5.0)
assert np.isclose(f3.der, 0.0)
# Cosine of constant times variable:
x4 = ad.variable(np.pi)
f4 = ad.cos(x4 * 0.5)
assert np.isclose(f4.val, 0.0)
assert np.isclose(f4.der, -0.5)
def test_sin():
# Sine of variable:
f1 = ad.sin(np.pi)
assert np.isclose(f1.val, 0.0)
assert np.isclose(f1.der, 0.0)
# Sine of variable:
x2 = ad.variable(np.pi)
f2 = ad.sin(x2)
assert np.isclose(f2.val, 0.0)
assert np.isclose(f2.der, -1.0)
# Sine of variable times constant:
x3 = ad.variable(0.0)
f3 = ad.sin(x3) * 5
assert np.isclose(f3.val, 0.0)
assert np.isclose(f3.der, 5.0)
# Sine of constant times variable:
x4 = ad.variable(np.pi)
f4 = ad.sin(x4 * 2)
assert np.isclose(f4.val, 0.0)
assert np.isclose(f4.der, 2.0)
def test_tan():
# Tangent of variable:
f1 = ad.tan(np.pi)
assert np.isclose(f1.val, 0.0)
assert np.isclose(f1.der, 0.0)
# Tangent of variable:
x2 = ad.variable(np.pi)
f2 = ad.tan(x2)
assert np.isclose(f2.val, 0.0)
assert np.isclose(f2.der, 1.0)
# Tangent of variable times constant:
x3 = ad.variable(np.pi / 4)
f3 = ad.tan(x3) * 5
assert np.isclose(f3.val, 5.0)
assert np.isclose(f3.der, 10.0)
# Tangent of constant times variable:
x4 = ad.variable(np.pi * 2)
f4 = ad.tan(x4 * 0.5)
assert np.isclose(f4.val, 0.0)
assert np.isclose(f4.der, 0.5)
def test_operations():
# Addition and multiplication:
a = 5.0
x = ad.variable(a)
alpha = 2.0
beta = 3.0
f = alpha * x + beta
assert f.val == 13
assert f.der == 2
f = x * alpha + beta
assert f.val == 13
assert f.der == 2
f = beta + alpha * x
assert f.val == 13
assert f.der == 2
f = beta + x * alpha
assert f.val == 13
assert f.der == 2
# Power:
a = 5.0
x = ad.variable(a)
f = x**2
assert f.val == 25
assert f.der == 10
a = 3.0
d = 2.0
x = ad.variable(a, d)
f = x**3
assert f.val == 27
assert f.der == 54
with pytest.raises(ValueError):
# power should be a number
x**'n'
#division(truediv)
x = ad.variable(2)
y = ad.variable(4)
f = x / y
assert f.val == 0.5
assert f.der == 0.125
x = ad.variable(2)
with pytest.raises(ZeroDivisionError):
# cannot perform division by zero
x / 0
with pytest.raises(ValueError):
# should be a scalar or instance variable
x / 'n'
x = ad.variable(2, 2)
f = x / 2
assert f.val == 1
assert f.der == 1
#division(rtruediv)
x = ad.variable(4)
f = 4 / x
assert f.val == 1
assert f.der == -0.25
#rpow
a = 3
x = ad.variable(a)
f = 2**x
assert f.val == 8
assert f.der == 2**a * np.log(2)
with pytest.raises(ValueError):
# exponent should be a number
's'**x
