def test_symmetric(a, b):
"""
Write a test that ensures that :func:`minitorch.operators.mul` is symmetric, i.e.
gives the same value regardless of the order of its input.
"""
# TODO: Implement for Task 0.2.
assert operators.mul(a, b) == operators.mul(b, a)
def test_symmetric(x, y):
"""
Write a test that ensures that :func:`minitorch.operators.mul` is symmetric, i.e.
gives the same value regardless of the order of its input.
"""
#None
assert_close(operators.mul(x, y), operators.mul(y, x))
def test_distribute(a, b, c):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
assert_close(operators.mul(a, b + c),
operators.mul(a, b) + operators.mul(a, c))
def test_other(x, y):
"""
Write a test that ensures some other property holds for your functions.
"""
r1 = operators.mul(operators.neg(x), y)
r2 = operators.mul(operators.mul(-1.0, y), operators.mul(1.0, x))
assert_close(r1, r2)
def test_distribute(x, y, z):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
assert_close(operators.mul(z, operators.add(x, y)),
operators.add(operators.mul(x, z), operators.mul(y, z)))
def test_other(x, y, z):
"""
Write a test that ensures some other property holds for your functions.
"""
None
# TODO: Implement for Task 0.2.
assert_close(operators.mul(x, (y * z)), operators.mul((x * y), z))
def test_symmetric(x, y):
"""
Write a test that ensures that :func:`minitorch.operators.mul` is symmetric, i.e.
gives the same value regardless of the order of its input.
"""
assert operators.mul(x, y) == operators.mul(y, x)
assert operators.add(x, y) == operators.add(y, x)
def test_distribute(x, y, z):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
# TODO: Implement for Task 0.2.
assert operators.mul(z, (x + y)) == operators.mul(z, x) + operators.mul(z, y)
def test_other(x, y, z):
"""
Write a test that ensures some other property holds for your functions.
Associativity.
"""
a = operators.mul(x, operators.mul(y, z))
b = operators.mul(operators.mul(x, y), z)
assert_close(a, b)
def test_associate(x, y, z):
"""
Write a test that ensures some other property holds for your functions.
"""
assert_close(operators.mul(operators.mul(x, y), z),
operators.mul(x, operators.mul(y, z)))
assert_close(operators.add(operators.add(x, y), z),
operators.add(x, operators.add(y, z)))
def test_distribute(x, y, z):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
r1 = operators.mul(z, operators.add(x, y))
r2 = operators.add(operators.mul(z, x), operators.mul(z, y))
assert_close(r1, r2)
def test_distribute(x,y,z):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
None
# TODO: Implement for Task 0.2.
assert_close(operators.mul(z, (x+y)), operators.add(operators.mul(z,x), operators.mul(z,y)))
def test_symmetric():
"""
A test that ensures that :func:`minitorch.operators.mul` is symmetric, i.e.
gives the same value regardless of the order of its input.
"""
a = list(range(-500, 501))
b = list(range(-500, 501))
for i, j in zip(a, b):
assert operators.mul(i, j) == operators.mul(j, i)
def test_distribute(x, y, z):
"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
#None
assert_close(operators.add((operators.mul(z, y)), operators.mul(z, x)),
(z * x) + (z * y))
assert_close(operators.mul(z, operators.add(x, y)), z * (x + y))
def test_distribute():
r"""
A test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
a = list(range(-500, 501))
b = list(range(-500, 501))
c = list(range(-500, 501))
for i, j, z in zip(a, b, c):
assert operators.mul(z, operators.add(i, j)) == operators.add(
operators.mul(z, i), operators.mul(z, j))
def test_inv(x):
"""
Write a test that ensures some other property holds for your functions.
"""
if x != 0:
assert_close(operators.mul(x, operators.inv(x)), 1)
assert_close(operators.add(x, operators.neg(x)), 0)
def test_other():
"""
Write a test that ensures some other property holds for your functions.
"""
a = 10.0
assert operators.neg(a) == -10.0
assert operators.mul(a, -1) == -1 * a
def test_same_as_python(x, y):
"Check that the main operators all return the same value of the python version"
assert_close(mul(x, y), x * y)
assert_close(add(x, y), x + y)
assert_close(neg(x), -x)
assert_close(max(x, y), x if x > y else y)
if x != 0.0:
assert_close(inv(x), 1.0 / x)
def test_symmetric(x, y):
assert_close(operators.mul(x, y), operators.mul(y, x))
def test_add_and_mul(x, y):
assert_close(operators.mul(x, y), x * y)
assert_close(operators.add(x, y), x + y)
assert_close(operators.neg(x), -x)
def test_distribute(x, y, z):
assert_close(op.mul(z, op.add(x, y)), op.add(op.mul(z, x), op.mul(z, y)))
def test_symmetric(x, y):
assert op.mul(x, y) == op.mul(y, x)
assert op.add(x, y) == op.add(y, x)
assert op.max(x, y) == op.max(y, x)
assert op.eq(x, y) == op.eq(y, x)
def test_other(x):
"""
Write a test that ensures some other property holds for your functions.
"""
assert_close(operators.mul(x, 1), x)
def test_other(x):
"""
Write a test that ensures some other property holds for your functions.
"""
assert operators.neg(x) == operators.mul(-1, x)
def test_distribute(a, b, c):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
assert operators.mul(a, operators.add(b, c)) == operators.add(operators.mul(a, b), operators.mul(a, c))
def test_distribute(x, y, z):
assert_close(operators.mul(x, operators.add(y, z)),
operators.add(operators.mul(x, y), operators.mul(x, z)))
def test_other(x, y, z):
assert_close(operators.mul(x, operators.mul(y, z)),
operators.mul(operators.mul(x, y), z))
def test_distribute(x, y, z):
r"""
Write a test that ensures that your operators distribute, i.e.
:math:`z \times (x + y) = z \times x + z \times y`
"""
assert operators.mul(z, x + y) == operators.mul(z, x) + operators.mul(z, y)