def test_values(self):
# Test multiply for numbers
self.assertEqual(multiply(5, 3), 15)
self.assertEqual(multiply(0, 0), 0)
self.assertEqual(multiply(-5, 3), -15)
self.assertEqual(multiply(.2, 1.7), .34)
self.assertEqual(multiply(-7.2, -1.7), 12.24)
def Calculator():
print("************MAIN MENU**************")
print()
choice = int(
input("""
1: Addition
2: Subtraction
3: Division
4: Multiplication
5: Remainder
6: Quit/log out
Please enter your choice: """))
if choice == 1:
add()
elif choice == 2:
subtract()
elif choice == 3:
divide()
elif choice == 4:
multiply()
elif choice == 5:
modulus()
elif choice == 6:
sys.exit
else:
print("You must only select either 1,2,3,4,5, or 6.")
print("Please try again")
Calculator()
def test_multiply(): """ Tests that the multiply function works """ assert mp.multiply(5,5) == 25 assert mp.multiply(3,0) == 0 assert mp.multiply(10,1) == 10
def test_multiply():
"""
Tests that the multiply function works
"""
assert mp.multiply(5, 5) == 25
assert mp.multiply(3, 0) == 0
assert mp.multiply(10, 1) == 10
def test_multiply_two_negative():
assert_equals(multiply(BigInteger("-5"), BigInteger("-3")).digits, [1,5])
result = multiply(BigInteger("-2"), BigInteger("3"))
assert_equals(result.digits, [6])
assert result.negative
result = multiply(BigInteger("2"), BigInteger("-1"))
assert_equals(result.digits, [2])
assert result.negative
def test_rand(self):
from inspect import isfunction
from random import randint
print("Should return 10 multiplications correctly")
for _ in range(10):
x, y = randint(0,100), randint(1,200)
self.assertEqual( multiply( x, y ), x * y,"that's not the multiplication!")
def sharpen(pic='lena.bmp', sharpen_times=2, img=None):
im = None
if img != None:
im = img
else:
im = Image.open(pic)
pixels = im.load()
h, w = im.size
r, g, b = seg_rgb(pixels, h, w)
multiply_image = multiply.multiply(pic, sharpen_times)
multiply_pixels = multiply_image.load()
mh, mw = multiply_image.size
mr, mg, mb = seg_rgb(multiply_pixels, mh, mw)
linear_blur_image = linear_blur.linear_blur(pic)
linear_blur_pixels = linear_blur_image.load()
lbh, lbw = linear_blur_image.size
lbr, lbg, lbb = seg_rgb(linear_blur_pixels, lbh, lbw)
sr = find_sharpen(r, mr, lbr)
sg = find_sharpen(g, mg, lbg)
sb = find_sharpen(b, mb, lbb)
sharpen_image = Image.new('RGB', (mh, mw), "black")
si = sharpen_image.load()
for i in xrange(mh):
for j in xrange(mw):
si[i, j] = (sr[i][j], sg[i][j], sb[i][j])
sharpen_image.show()
return sharpen_image
def exponent(m, n):
# base case
if n == 1:
return m
# moving toward base case using recursion
#return m*exponent(m,n-1)
return multiply(m, exponent(m, n - 1))
def runMultiply():
result = 0
results = {}
try:
x = int(request.args.get('x'))
y = int(request.args.get('y'))
except:
results = {
"x": 0,
"y": 0,
"answer": 0,
"error": True,
"errorMessage": "Please give both x and y values"
}
resultsJSON = json.dumps(results)
res = Response(response=resultsJSON,
status=400,
mimetype="application/json")
else:
result = multiply.multiply(x, y)
results = {"x": x, "y": y, "answer": result, "error": False}
resultsJSON = json.dumps(results)
res = Response(response=resultsJSON,
status=200,
mimetype="application/json")
res.headers["Content-Type"] = "application/json"
res.headers["Access-Control-Allow-Origin"] = "*"
return res
def dispatch(s):
resolve = s.split()
operation = resolve[1]
try:
resolve[0] = int(resolve[0])
resolve[2] = int(resolve[2])
except:
pass
if operation == "+":
return add.add(resolve[0], resolve[2])
elif operation == "-":
return minus.minus(resolve[0], resolve[2])
elif operation == "*":
return multiply.multiply(resolve[0], resolve[2])
elif operation == "/":
return divide.divide(resolve[0], resolve[2])
elif operation == "!":
return factorial.factorial(resolve[0])
elif operation == "to_hex":
return dec_to_hex.dec_to_hex(resolve[0])
elif operation == "to_bin":
pass
elif operation == "inv":
return inverse.inverse(resolve[0])
elif operation == "**":
return power.power(resolve[0], resolve[2])
def test_four_multiply_carson():
"""Function that checks TypeError is raised when input is
two strings."""
from multiply import multiply
try:
assert multiply('string', 'string') == TypeError
except TypeError:
print('Cannot multiply string values.')
def test(self):
self.assertEqual(multiply(1, 1), 1)
self.assertEqual(multiply(2, 1), 2)
self.assertEqual(multiply(2, 2), 4)
self.assertEqual(multiply(3, 5), 15)
self.assertEqual(multiply(1.5, 2.5), 3.75)
self.assertEqual(multiply(0, 5), 0)
self.assertEqual(multiply(0, 0), 0)
def test_multiply(setup_name):
shares_of_messages_for_multiply, _, _ = create_shares_for_messages(
setup_name, np.random.randint(0, prime - 1),
np.random.randint(0, prime - 1))
print("\nCalling multiply('{}', {})".format(
setup_name, shares_of_messages_for_multiply))
shares = multiply(setup_name,
shares_of_messages_for_multiply,
print_statements=print_statements)
print("Multiply successful. Computed messages: {}".format(shares))
def main():
print("\n\nWelcome to My Math!\n")
a = int(input("Enter your first whole number: "))
b = int(input("Enter your second whole number: "))
print("\n{} + {} = {}".format(a, b, add(a, b)))
print("\n{} - {} = {}".format(a, b, subtract(a, b)))
print("\n{} * {} = {}".format(a, b, multiply(a, b)))
print("\n{} / {} = {}".format(a, b, divide(a, b)))
print("\n{} % {} = {}".format(a, b, remainder(a, b)))
print("\n{} ^ {} = {}".format(a, b, exponent(a, b)))
def test_001_t (self): src_data = (0, 1, -2, 5.5, -0.5) expected_result = (0, 2, -4, 11, -1) src = blocks.vector_source_f (src_data) mult = multiply(2) snk = blocks.vector_sink_f () self.tb.connect (src, mult) self.tb.connect (mult, snk) self.tb.run () result_data = snk.data () self.assertFloatTuplesAlmostEqual (expected_result, result_data, 6)
def int_power(a, b):
# Raises a to the power b, where b needs to be an int
int_or_float_check(a)
int_check(b)
res = 1
for i in range(b):
res = multiply(res, a)
if res == 0 and a > 0:
return sys.float_info.min
else:
return res
def int_root(a, n):
# Return n-th root of a, where b needs to be an int
int_or_float_check(a)
int_check(n)
if n == 0:
raise SyntaxError("Cannot calculate zero-th root")
if a < 0 and modulo(n, 2) == 0:
raise SyntaxError("Cannot do even root of negative number")
epsilon = .00001
x_0 = divide(a, n)
x_1 = multiply(
divide(1, n),
add(multiply(add(n, -1), x_0), divide(a, int_power(x_0, add(n, -1)))))
while abs(add(x_0, -x_1)) > epsilon:
x_0 = x_1
x_1 = multiply(
divide(1, n),
add(multiply(add(n, -1), x_0), divide(a,
int_power(x_0, add(n, -1)))))
return x_1
def tick(self):
self.led_matrix_painter.show_Text(self.get_date_string())
back = Field(10, 20)
self.currentrainbowstart += 1
self.currentrainbowstart %= self.COLORS
for x in range(10):
for y in range(20):
back.set_pixel(x, y, self.r[y + self.currentrainbowstart])
self.draw_clock([255, 255, 255])
rainbowtime = multiply(back, self.field_leds)
self.rgb_field_painter.draw(rainbowtime)
sleep(0.05)
def isOrthogonal(matrix):
if squareErr(matrix):
print("The matrix is not orthogonal.")
return False
matrixT = transpose(matrix)
if isIdentity(multiply(matrix, matrixT)):
print("The matrix is orthogonal.")
return True
else:
print("The matrix is not orthogonal.")
return False
def power(base, exponent, cache=None):
"""Returns base to the power of exponent.
If exponent is less than 0, returns a BigInteger of 0.
Neither BigInteger is modified during this operation.
Args:
base: BigInteger, the number to be multiplied.
exponent: BigInteger, the exponent to apply to the base.
Returns:
A new BigInteger of the result of base**exponent.
"""
if cache is None:
cache = {}
# Any negative exponent will be a fraction 0 < x < 1, so round down to 0
if exponent < BigInteger("0"):
return BigInteger("0")
if exponent == BigInteger("0"):
return BigInteger("1")
if exponent == BigInteger("1"):
return base
print "Printing"
print exponent.__hash__()
if exponent in cache:
print "Accessing cache: ", exponent
return cache[exponent]
half_exponent = divide(exponent, BigInteger("2"))
half_result = power(base, half_exponent, cache)
# a**n = a**(n/2) * 2 if n is even
result = multiply(half_result, half_result)
# Divide doesn't support mod or remainder, so check for an odd number
# If exponent is odd, multiply by base one more time
if exponent.digits[-1] in (1, 3, 5, 7, 9):
result = multiply(result, base)
cache[exponent] = result
return result
def draw_clock(self, color: list = None):
hour, minute, second = self.get_time()
self.draw_digit(hour, 1, [255, 255, 255])
self.draw_digit(minute, 4, [255, 255, 255])
self.draw_digit(second, 7, [255, 255, 255])
back = Field(10, 20)
self.currentrainbowstart += 1
self.currentrainbowstart %= self.COLORS
for x in range(10):
for y in range(20):
back.set_pixel(x, y, self.r[y + self.currentrainbowstart])
rainbowtime = multiply(back, self.field_leds)
self.field_leds.field = rainbowtime.field
def test_matrix_multiplication(self):
"""Test the multiplication of matrices"""
m1 = [
[1, 2, 3],
[2, 4, 6]
]
m2 = [
[1, 2],
[2, 4],
[3, 6]
]
correct_answer = [
[14, 28],
[28, 56]
]
result = multiply.multiply(m1, m2)
self.assertEqual(result, correct_answer)
def test_matrix_multiply():
matrix1 = [[1, 2], [4.2, 5], [7, 8]]
matrix2 = [[2.1, 1.1], [4.1, -1.1]]
result = multiply(matrix1, matrix2)
assert len(result) == 3
assert len(result[0]) == 2
assert result[0][0] == approx(10.3, rel=1e-5)
assert result[0][1] == approx(-1.1, rel=1e-5)
assert result[1][0] == approx(29.32, rel=1e-5)
assert result[1][1] == approx(-0.88, rel=1e-5)
assert result[2][0] == approx(47.5, rel=1e-5)
assert result[2][1] == approx(-1.1, rel=1e-5)
def test_matrix_multiply_1000x1000_benchmark():
size = 1000
rows1 = size
columns1 = size
columns2 = size
matrix1 = [[random.uniform(-1, 1) for _ in range(columns1)]
for _ in range(rows1)]
matrix2 = [[random.uniform(-1, 1) for _ in range(columns2)]
for _ in range(columns1)]
start = timer()
result = multiply(matrix1, matrix2)
end = timer()
print(
f"\nMultiply {size}x{size} matrices with three loops: {end - start} s\n"
)
assert result[0][0] != 42
def get_fraction(a):
# Turns float into fraction
int_or_float_check(a)
if isinstance(a, int):
return a, 1
else:
is_negative = False
if a < 0:
is_negative = True
a = abs(a)
fraction = str(a).split(".")
original_denominator = 1
for i in range(len(fraction[1])):
original_denominator = multiply(original_denominator, 10)
original_numerator = int(fraction[0] +
fraction[1]) # Not addition but string concat
common_denominator = GCD(original_numerator, original_denominator)
numerator = int(divide(original_numerator, common_denominator))
denominator = int(divide(original_denominator, common_denominator))
if is_negative:
numerator = -numerator
return numerator, denominator
from multiply import multiply
"""
_.multiply(6, 4);
// => 24
"""
print("multiply(6, 4) = {}".format(multiply(6, 4)))
def test_numbers_3_4(): assert multiply(3, 4) == 12
def test_multiply_one_large():
# 2**64 is just beyond the bounds of int, so Python makes it a long
a = BigInteger("18446744073709551616")
expect = [1, 8, 4, 4, 6, 7, 4, 4, 0, 7, 3, 7, 0, 9, 5, 5, 1, 6, 1, 6, 0, 0]
assert_equals(multiply(a, BigInteger("100")).digits, expect)
def test_one_each(self): self.assertEqual(multiply.multiply(-5.5, 2), -11.0)
def test_two_pos(self): self.assertEqual(multiply.multiply(3, 6), 18)
def test_string_a_3():
assert multiply('a', 3) == 'aaa'
def test_two_neg(self): self.assertEqual(multiply.multiply(-1, -6), 6)
def test_multiply_different_lengths():
a = BigInteger("1012")
b = BigInteger("35")
assert_equals(multiply(a, b).digits, [3, 5, 4, 2, 0])
def test_multiply_two_large():
a = BigInteger("48446744073709551616")
b = BigInteger("130808823666624465123")
expected = BigInteger("6337261602759956545834207900472160288768")
assert_equals(multiply(a, b), expected)
def test_multiply(a, b, answer):
"""Test for multiply function."""
from multiply import multiply
assert multiply(a, b) == answer
def test1():
"""checks that 3 * 4 is 12"""
from multiply import multiply
assert multiply(3, 4) == 12
def test_multiply_carry():
a = BigInteger("12")
b = BigInteger("56")
expected = BigInteger("672")
assert_equals(multiply(a, b), expected)
def test_multiply_small_numbers():
a = BigInteger("2")
b = BigInteger("3")
assert_equals(multiply(a, b).digits, [6])
#!/usr/bin/env python """ simple test of the multiply.pyx and c_multiply.c test code """ import numpy as np import multiply a = np.arange(12, dtype=np.float64).reshape((3,4)) print a multiply.multiply(a, 3) print a
def test2():
"""checks that we can also multiply by non-integers"""
from multiply import multiply
assert multiply(2, 5.5) == 11
def test3():
"""checks that we can also multiply by negatives"""
from multiply import multiply
assert multiply(-2, 5.5) == -11
break
except ValueError:
print("Необходимо ввести ЧИСЛО!")
print("")
print("")
while True:
sign = input(
'''Нажмите кнопку, которая соответствует требуемому действию:
1) +
2) -
3) *
4) /
:''')
if sign in ['+', '-', '*', '/', '1', '2', '3', '4']:
break
else:
print("Введите знак или цифру соответствующую знаку!")
continue
print("")
if sign == '+' or sign == '1':
from add import add
add(value1, value2)
elif sign == '-' or sign == '2':
from subtraction import subtraction
subtraction(value1, value2)
elif sign == '*' or sign == '3':
from multiply import multiply
multiply(value1, value2)
elif sign == '/' or sign == '4':
from divide import divide
divide(value1, value2)
def test_multiply_zeroes():
a = BigInteger("0")
assert_equals(multiply(a, BigInteger("10")).digits, [0])
assert_equals(multiply(a, a).digits, [0])
assert_equals(multiply(BigInteger("5"), a).digits, [0])
assert_equals(multiply(a, BigInteger("-5")).digits, [0])
