def test_vec_add():
f1 = AutoDiffRev(name='x', val=-1)
f2 = AutoDiffRev(name='y', val=3)
u = AutoDiffRevVector((f1, f2))
l = AutoDiffRevVector((f1, f2, f1))
v = AutoDiffRevVector((-f2, f1))
w = AutoDiffRevVector([10, 10])
r = AutoDiffRevVector([-3, -3])
q = [2, 1.5]
np.testing.assert_array_equal((u + q).val, [1, 4.5]), 'Addition failed'
np.testing.assert_array_equal((q + u).val, [1, 4.5]), 'Addition failed'
J, order = (u + q).get_jacobian()
np.testing.assert_array_equal(J, [[1, 0], [0, 1]]), 'Addition failed'
J, order = (v + q).get_jacobian()
np.testing.assert_array_equal(J, [[0, -1], [1, 0]]), 'Addition failed'
J, order = (q + u).get_jacobian()
np.testing.assert_array_equal(J, [[1, 0], [0, 1]]), 'Addition failed'
np.testing.assert_array_equal((u + v).val, [-4, 2]), 'Addition failed'
np.testing.assert_array_equal((v + u).val, [-4, 2]), 'Addition failed'
J, order = (u + v).get_jacobian()
np.testing.assert_array_equal(J, [[1, -1], [1, 1]]), 'Addition failed'
np.testing.assert_array_equal((w + r), [7, 7]), "Addition failed"
J, order = (w + r).get_jacobian()
np.testing.assert_array_equal(J, [[0], [0]]), "Addition failed"
try:
u + l
except Exception:
print("Caught error as expected")
def test_duplicate_instantiation():
f1 = AutoDiffRev(name='x', val=1)
f2 = AutoDiffRev(name='x', val=3)
try:
AutoDiffRevVector((f1, f2))
except Exception:
print("Caught error as expected")
def test_or():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
y = AutoDiffRevVector((f2, 8))
assert u == [3, 5] or y == [0,0], "Or failed"
assert u == [3, 5] or y == [5,8], "Or failed"
def test_round():
x = AutoDiffRev(name='x', val=5.7)
y = AutoDiffRev(name='y', val=-4.6)
z = AutoDiffRev(name='z', val=0)
assert round(x) == 6, "Round failed"
assert -5 == round(y), "Round failed"
assert 0 == round(z), "Round failed"
def test_eq():
x = AutoDiffRev(name='x', val=2)
y = AutoDiffRev(name='x', val=2)
assert 2 == x, "Equals failed"
assert x == 2, "Equals failed"
assert x == y, "Equals failed"
assert y == x, "Equals failed"
def test_divide():
x = AutoDiffRev(name='x', val=6)
y = AutoDiffRev(name='y', val=-12)
z = AutoDiffRev(name='z', val=0)
q = AutoDiffRev(name='b0', val="string")
assert (x / 2) == 3, 'Division failed'
g, _ = (x / 2).get_gradient()
assert g == [1 / 2], 'Division failed'
assert (18 / x) == 3, 'Division failed'
g, _ = (18 / x).get_gradient()
assert g == [-1/2], "Division failed"
assert (y / x) == -2, 'Division failed'
g, _ = (y / x).get_gradient()
np.testing.assert_array_equal(g, [(12 / 36), (1 / 6)]), 'Division failed'
assert (x / y).get_value() == -0.5, 'Division failed'
g, _ = (x / y).get_gradient()
np.testing.assert_array_equal(g, [(1 / -12), (-6 / 144)]), 'Division failed'
try:
assert (z / z).get_value() == 0
except ZeroDivisionError:
print("Caught Zero Division Error")
try:
assert (z / z).get_gradient() == 0
except ZeroDivisionError:
print("Caught Zero Division Error")
try:
(q / 5).get_value()
except TypeError:
print("Caught error as expected")
def test_instantiation_pos():
f1 = AutoDiffRev(name='x', val=1)
f2 = AutoDiffRev(name='y', val=3)
u = AutoDiffRevVector((f1, f2))
v = AutoDiffRevVector([2, 2])
z = AutoDiffRevVector((f1, 9))
q = AutoDiffRevVector((f1, f1, 9, 3))
np.testing.assert_array_equal(u.get_values(),
[1, 3]), "Positive instantiation failed"
J, order = u.get_jacobian()
np.testing.assert_array_equal(
J, [[1, 0], [0, 1]]), "Positive instantiation failed"
np.testing.assert_almost_equal(v.val,
[2, 2]), "Positive instantiation failed"
J, order = v.get_jacobian()
np.testing.assert_array_equal(J,
[[0], [0]]), "Positive instantiation failed"
np.testing.assert_array_equal(z.get_values(),
[1, 9]), "Positive instantiation failed"
np.testing.assert_array_equal(
q.get_values(), [1, 1, 9, 3]), "Positive instantiation failed"
try:
x = AutoDiff(name='x', val=4)
p = AutoDiffRevVector((x, f1))
except ValueError:
print("Caught error as expected")
def test_vec_multiply():
f1 = AutoDiffRev(name='x', val=-1)
f2 = AutoDiffRev(name='y', val=3)
u = AutoDiffRevVector((f1, f2))
v = AutoDiffRevVector((-f2, f1))
c = AutoDiffRevVector((f1, f1, 9, 3))
q = [2, 0]
t = [4, 4]
np.testing.assert_array_equal((u * 3).val, [-3, 9]), 'Multiplication failed'
J, order = (u * 3).get_jacobian()
np.testing.assert_array_equal(J, [[3, 0], [0, 3]]), "Multiplication failed"
np.testing.assert_array_equal((-4 * u).val, [4, -12]), 'Multiplication failed'
np.testing.assert_array_equal((u * q).val, [-2, 0]), 'Multiplication failed'
np.testing.assert_array_equal((q * u).val, [-2, 0]), 'Multiplication failed'
J, order = (u * t).get_jacobian()
np.testing.assert_array_equal(J, [[4, 0], [0, 4]]), "Multiplication failed"
J, order = (u * q).get_jacobian()
np.testing.assert_array_equal(J, [[2, 0], [0, 0]]), 'Multiplication failed'
J, order = (q * u).get_jacobian()
np.testing.assert_array_equal(J, [[2, 0], [0, 0]]), 'Multiplication failed'
J, order = (u * v).get_jacobian()
np.testing.assert_array_equal(J, [[-3, 1], [3, -1]]), 'Multiplication failed'
J, order = (v * u).get_jacobian()
np.testing.assert_array_equal(J, [[-3, 1], [3, -1]]), 'Multiplication failed'
np.testing.assert_array_equal((c * 2), [-2, -2, 18, 6]), "Multiplication failed"
def test_contains():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=4)
u = AutoDiffRevVector((f1, f2))
try:
assert 2 in u
except NotImplementedError:
print("Caught error as expected")
def test_bool():
f1 = AutoDiffRev(name='x', val=0)
f2 = AutoDiffRev(name='y', val=0)
u = AutoDiffRevVector((f1, f2))
try:
bool(u)
except TypeError:
print("Caught error as expected")
def test_le():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
y = AutoDiffRevVector((f2, 8))
assert [3, 5] <= u, "Less than failed"
assert u <= [100, 100], "Less than failed"
assert u <= y, "Less than failed"
def test_lt():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
y = AutoDiffRevVector((f2, 8))
assert [0, 0] < u, "Less than failed"
assert u < [100, 100], "Less than failed"
assert u < y, "Less than failed"
def test_gt():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
y = AutoDiffRevVector((f2, 8))
assert u > [0, 0], "Greater than failed"
assert [100, 100] > u, "Greater than failed"
assert y > u, "Greater than failed"
def test_shift():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=4)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_equal(u >> 2, [16, 32]), "Shift failed"
np.testing.assert_array_equal(u << 2, [12, 16]), "Shift failed"
np.testing.assert_array_equal(3 >> u, [24, 32]), "Shift failed"
np.testing.assert_array_equal(3 << u, [24, 48]), "Shift failed"
def test_cos():
f1 = AutoDiffRev(name='x', val=0)
f2 = AutoDiffRev(name='y', val=np.pi / 2)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_almost_equal(ad.cos(u).val,
[1, 0]), 'Cosine failed'
J, order = (ad.cos(u)).get_jacobian()
np.testing.assert_array_equal(J, [[0, 0], [0, -1]]), 'Cosine failed'
def test_sin():
f1 = AutoDiffRev(name='x', val=0)
f2 = AutoDiffRev(name='y', val=np.pi / 2)
u = AutoDiffRevVector((f1, f2))
v = AutoDiffRevVector([0, np.pi / 2])
np.testing.assert_array_almost_equal(ad.sin(u).val, [0, 1]), 'Sine failed'
J, order = (ad.sin(u)).get_jacobian()
np.testing.assert_array_almost_equal(J, [[1, 0], [0, 0]]), 'Sine failed'
def test_ne():
x = AutoDiffRev(name='x', val=10)
y = AutoDiffRev(name='y', val=100)
q = AutoDiffRev(name='b0', val="string")
assert x != 11, "Not equal failed"
assert 11 != x, "Not equal failed"
assert x != y, "Not equal failed"
assert 12 != q, "Not equal failed"
def test_csc():
f1 = AutoDiffRev(name='x', val=-2)
f2 = AutoDiffRev(name='y', val=np.pi / 8)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_almost_equal(
ad.csc(u).val, [-1.09975, 2.613126]), 'Cosecant failed'
J, order = (ad.csc(u)).get_jacobian()
np.testing.assert_array_almost_equal(J, [[0.5033, 0], [0, -6.3086]],
decimal=4), 'Cosecant failed'
def test_instantiation_zero():
f1 = AutoDiffRev(name='x', val=0)
f2 = AutoDiffRev(name='y', val=0)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_equal(u.val,
[0, 0]), "Positive instantiation failed"
J, order = u.get_jacobian()
np.testing.assert_array_equal(
J, [[1, 0], [0, 1]]), "Positive instantiation failed"
def test_sec():
f1 = AutoDiffRev(name='x', val=0)
f2 = AutoDiffRev(name='y', val=np.pi)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_almost_equal(ad.sec(u).val,
[1, -1]), 'Secant failed'
J, order = (ad.sec(u)).get_jacobian()
np.testing.assert_array_almost_equal(J, [[0, 0], [0, 0]],
decimal=4), 'Secant failed'
def test_cot():
f1 = AutoDiffRev(name='x', val=4)
f2 = AutoDiffRev(name='y', val=np.pi / 8)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_almost_equal(
ad.cot(u).val, [0.863691, 2.414214]), 'Cotangent failed'
J, order = (ad.cot(u)).get_jacobian()
np.testing.assert_array_almost_equal(J, [[-1.746, 0], [0, -6.8284]],
decimal=4), 'Cotangent failed'
def test_ge():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
y = AutoDiffRevVector((f2, 8))
assert u >= [0, 0], "Greater than or equal to failed"
assert u >= [3, 5], "Greater than or equal to failed"
assert [100, 100] >= u, "Greater than or equal to failed"
assert y >= u, "Greater than or equal to failed"
def test_exponentiation():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_almost_equal(u ** 2, [9, 25]), "Exponentiation failed"
J, order = (u ** 2).get_jacobian()
np.testing.assert_array_almost_equal(J, [[6, 0], [0, 10]]), "Exponentiation failed"
J, order = (2 ** u).get_jacobian()
np.testing.assert_array_almost_equal(J, [[5.545177, 0], [0, 22.18071]]), "Exponentiation failed"
def test_tan():
f1 = AutoDiffRev(name='x', val=-2)
f2 = AutoDiffRev(name='y', val=np.pi / 8)
u = AutoDiffRevVector((f1, f2))
np.testing.assert_array_almost_equal(ad.tan(u).val,
[2.18504, 0.414214]), 'Tan failed'
J, order = (ad.tan(u)).get_jacobian()
np.testing.assert_array_almost_equal(J, [[5.774399, 0], [0, 1.171573]],
decimal=4), 'Tan failed'
def test_xor():
x = AutoDiffRev(name='x', val=0)
y = AutoDiffRev(name='y', val=1)
assert (x ^ y) == 1, "Xor failed"
assert (x ^ 1) == 1, "Xor failed"
assert (1 ^ x) == 1, "Xor failed"
try:
assert x ^ x == 1
except AssertionError:
print("Caught Error as expected")
def test_ne():
f1 = AutoDiffRev(name='x', val=3)
f2 = AutoDiffRev(name='y', val=5)
u = AutoDiffRevVector((f1, f2))
y = AutoDiffRevVector((f2, 8))
q = AutoDiffRev(name='b0', val="string")
assert u != 11, "Not equal failed"
assert 11 != u, "Not equal failed"
assert u != y, "Not equal failed"
assert y != q, "Not equal failed"
def test_double_instantiation():
try:
AutoDiffRevVector(name='x', val=3, trace=3)
except TypeError:
print("Caught error as expected")
f1 = AutoDiffRev(name='x', val=1)
f2 = AutoDiffRev(name='y', val=3)
try:
AutoDiffRevVector((f1, f2), f1)
except TypeError:
print("Caught error as expected")
def test_tan():
x = AutoDiffRev(name='x', val=np.pi)
y = AutoDiffRev(name='y', val=np.pi / 2)
q = AutoDiffRev(name='q', val="string")
assert ad.tan(x) == np.tan(np.pi), "Tan failed"
assert np.allclose(ad.tan(x).get_gradient()[0][0], (1 / np.cos(np.pi)) ** 2, atol=1e-12) is True, "Tan failed"
assert ad.tan(y).get_value() == np.tan(np.pi/2), "Tan failed"
try:
ad.tan(q)
except TypeError:
print("Caught error as expected")
def test_lt():
x = AutoDiffRev(name='x', val=10)
y = AutoDiffRev(name='y', val=100)
q = AutoDiffRev(name='b0', val="string")
assert 2 < x, "Less than failed"
assert x < 20, "Less than failed"
assert x < y, "Less than failed"
try:
(12 < q)
except TypeError:
print("Caught error as expected")
def test_gt():
x = AutoDiffRev(name='x', val=10)
y = AutoDiffRev(name='y', val=100)
q = AutoDiffRev(name='b0', val="string")
assert x > 2, "Greater than failed"
assert 20 > x, "Greater than failed"
assert y > x, "Greater than failed"
try:
(12 > q)
except TypeError:
print("Caught error as expected")