def test_can_shift_right(self):
value = Number().fromNumber(0b11010100)
result = value >> Number().fromNumber(1)
self.assertEqual(0b1101010, result.number)
self.assertEqual("0110 1010", result.asBinary)
def primary(self):
'''
primary
:= hex_number | binary_number | octal_number | decimal_number | '(' start_expr ')'
'''
if self._accept(TokenType.DECIMAL):
if self.currentToken.type != TokenType.DECIMAL:
raise SyntaxError(
f'Expected decimal number, got {self.currentToken.value}')
return Number().fromString(self.currentToken.value)
if self._accept(TokenType.HEX):
if self.currentToken.type != TokenType.HEX:
raise SyntaxError(
f'Expected hex number, got {self.currentToken.value}')
return Number().fromString(self.currentToken.value)
if self._accept(TokenType.BINARY):
if self.currentToken.type != TokenType.BINARY:
raise SyntaxError(
f'Expected binary number, got {self.currentToken.value}')
return Number().fromString(self.currentToken.value)
if self._accept(TokenType.OCTAL):
if self.currentToken.type != TokenType.OCTAL:
raise SyntaxError(
f'Expected octal number, got {self.currentToken.value}')
return Number().fromString(self.currentToken.value)
elif self._accept(TokenType.LPAREN):
result = self.startExpr()
self._expect(TokenType.RPAREN)
return result
else:
raise SyntaxError(f'Got unexpected token {self.nextToken.value}')
def test_can_shift_left(self):
value = Number().fromNumber(0b1101010)
result = value << Number().fromNumber(1)
self.assertEqual(0b11010100, result.number)
self.assertEqual("1101 0100", result.asBinary)
def __update_region(self, region):
center = region.get_center()
bounds = region.get_bounds()
if self.__numbers.__len__() == 0:
number = Number(bounds)
self.__numbers.append(number)
return number
distances = []
for number in self.__numbers:
distances.append(vec.distance(center, number.get_center()))
number = None
i = np.argmin(distances)
if distances[i] < 20:
number = self.__numbers[i]
if number is None:
number = Number(bounds)
self.__numbers.append(number)
else:
number.set_bounds(bounds)
return number
def test_can_and(self):
left = Number().fromNumber(0b110101)
right = Number().fromNumber(0b1)
result = left & right
self.assertEqual(0x01, result.number)
self.assertEqual("0001", result.asBinary)
def test_can_multiply_with_negative_result(self):
left = Number().fromNumber(0x17)
right = Number().fromNumber(-0x07)
result = left * right
self.assertEqual(-0xA1, result.number)
self.assertEqual("-00A1", result.asHex)
def test_can_add_with_positive_result(self):
left = Number().fromNumber(0x17)
right = Number().fromNumber(0x07)
result = left + right
self.assertEqual(0x1E, result.number)
self.assertEqual("001E", result.asHex)
def test_can_divide_with_negative_result(self):
left = Number().fromNumber(-0x10)
right = Number().fromNumber(0x04)
result = left // right
self.assertEqual(-0x04, result.number)
self.assertEqual("-0004", result.asHex)
def test_can_subtract_with_positive_result(self):
left = Number().fromNumber(0x20)
right = Number().fromNumber(0x10)
result = left - right
self.assertEqual(16, result.number)
self.assertEqual("0010", result.asHex)
def test_can_or(self):
left = Number().fromNumber(0b110101)
right = Number().fromNumber(0b11)
result = left | right
self.assertEqual(0b110111, result.number)
self.assertEqual("0011 0111", result.asBinary)
def main():
a = Number(Digits.eight)
b = Number(Digits.seven)
print(f"{a} + {b} = {a + b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} ** {b} = {a ** b}")
print()
def test_number_equality():
n = 10
number = Number(10)
assert number == n
other = Number(n)
assert number == other
async def run(self, first=3, second=5):
tasks = [
Number(value=first),
Number(value=second)
]
result = min(await join(tasks))
print('Minimum value:', result)
return result
def test_can_invert(self):
value = Number().fromNumber(0x15)
result = ~value
self.assertEqual(-22, result.number)
self.assertEqual("-0016", result.asHex)
def _parseOperand(self, operand):
retval = None
rettype = OperandType.NONE
# First try symbol lookup.
entry = self.context.symtab.lookup(operand)
if entry != None:
retval = entry.value
rettype = OperandType.SYMBOLIC
self.length = entry.length
self.refType = entry.type
else:
tmpop = operand
if self.addressExpr and (operand.startswith('+')
or operand.startswith('-')):
tmpop = operand[1:]
try:
# Next try number.
op = Number(tmpop)
if op.isValid():
retval = op.value
rettype = OperandType.DECIMAL
self.refType = RecordType.CONST
except:
# Assume it is a symbol as yet undefined.
pass
return (retval, rettype)
def rpn(output, variables, file, samples):
stack = []
for element in output:
if type(element) is Operator:
num2 = stack.pop()
num1 = stack.pop()
evaluated = element.function(num1, num2)
if samples:
file.write(evaluated.getError() + "\n")
stack.append(evaluated)
elif type(element) is Function:
count = 0
args = []
while count < element.args:
args.append(stack.pop())
count += 1
if len(args) == 1:
args = args[0]
evaluated = element.function(args)
if samples:
file.write(evaluated.getError() + "\n")
stack.append(evaluated)
else:
if element in variables:
stack.append(variables.get(element))
elif element in CONSTANTS:
stack.append(CONSTANTS.get(element))
else:
number = Number(float(element), element)
stack.append(number)
return stack.pop()
def test_parse_decimal_negative_number_string(self):
string = "-1699"
obj = Number().fromString(string)
self.assertEqual(-0x6A3, obj.number)
self.assertEqual("-06A3", obj.asHex)
self.assertEqual("-1,699", obj.asDecimal)
self.assertEqual("-3243", obj.asOctal)
self.assertEqual("-0110 1010 0011", obj.asBinary)
def test_parse_decimal_negative_number(self):
number = -1699
obj = Number().fromNumber(number)
self.assertEqual(number, obj.number)
self.assertEqual("-06A3", obj.asHex)
self.assertEqual("-1,699", obj.asDecimal)
self.assertEqual("-3243", obj.asOctal)
self.assertEqual("-0110 1010 0011", obj.asBinary)
def test_parse_decimal_positve_number_string(self):
string = "1699"
obj = Number().fromString(string)
self.assertEqual(0x6A3, obj.number)
self.assertEqual("06A3", obj.asHex)
self.assertEqual("1,699", obj.asDecimal)
self.assertEqual("3243", obj.asOctal)
self.assertEqual("0110 1010 0011", obj.asBinary)
def test_parse_binary_positve_number(self):
number = 0b11010100011
obj = Number().fromNumber(number)
self.assertEqual(number, obj.number)
self.assertEqual("06A3", obj.asHex)
self.assertEqual("1,699", obj.asDecimal)
self.assertEqual("3243", obj.asOctal)
self.assertEqual("0110 1010 0011", obj.asBinary)
def powers_of_ten():
for exponent in count():
value = 10**exponent
with_commas = "{:,}".format(value)
yield Number(
value=value,
display_value=with_commas,
formatted_value=with_commas,
category="powers of ten",
)
def powers_of_two():
# Start at 2^2=4 because 2^0=1 and 2^1=2 aren't interesting.
for exponent in count(2):
value = 2**exponent
with_commas = "{:,}".format(value)
yield Number(
value=value,
display_value="2^%s" % exponent,
formatted_value=with_commas,
category="powers of two",
)
def __init__(self, number, session_obj=None):
"""The constructor for this class takes in a number and saves it as an attribute. It also creates a list of digits
that make up that number, as well as a list of factors of the number, and saves those lists as attributes."""
self.number = number
self.digits = [int(d) for d in str(self.number) if d != '-']
self.factors = [i for i in range(1, self.number + 1) if self._is_factor(self.number, i)]
self.hints = []
self.app_text = AppText()
self.num_obj = Number()
self.session_obj = session_obj
def factors_of_ten():
# 2, 5, 20, 50, 200, 500, ... 2,000,000, 5,000,000, ...
factors = (2, 5)
for exponent in count():
power_of_ten = 10**exponent
for factor in factors:
value = factor * power_of_ten
with_commas = "{:,}".format(value)
yield Number(value=value,
display_value=with_commas,
formatted_value=with_commas,
category="factors of ten")
def generate_number_list(lowerbound=2, upperbound=10):
'''
Generate a list of Number objects
'''
number_list = []
for value in range(lowerbound, upperbound + 1):
if pp.isprime(value) and not include_primes:
continue
number = Number(value=value)
number_list.append(number)
return number_list
def __init__(self):
self.board = [[Empty(x='',y='',sl='.',team='')]*9 for _ in range(9)]
self.board[0][0] = Rook(x=0,y=0,sl='r',team='black')
self.board[0][1] = Knight(x=0,y=1,sl='n',team='black')
self.board[0][2] = Bishop(x=0,y=2,sl='b',team='black')
self.board[0][3] = Queen(x=0,y=3,sl='q',team='black')
self.board[0][4] = King(x=0,y=4,sl='k',team='black')
self.board[0][5] = Bishop(x=0,y=5,sl='b',team='black')
self.board[0][6] = Knight(x=0,y=6,sl='n',team='black')
self.board[0][7] = Rook(x=0,y=7,sl='r',team='black')
self.board[1][0] = Pawn(x=1,y=0,sl='p',team='black')
self.board[1][1] = Pawn(x=1,y=1,sl='p',team='black')
self.board[1][2] = Pawn(x=1,y=2,sl='p',team='black')
self.board[1][3] = Pawn(x=1,y=3,sl='p',team='black')
self.board[1][4] = Pawn(x=1,y=4,sl='p',team='black')
self.board[1][5] = Pawn(x=1,y=5,sl='p',team='black')
self.board[1][6] = Pawn(x=1,y=6,sl='p',team='black')
self.board[1][7] = Pawn(x=1,y=7,sl='p',team='black')
self.board[7][0] = Rook(x=7,y=0,sl='R',team='white')
self.board[7][1] = Knight(x=7,y=1,sl='N',team='white')
self.board[7][2] = Bishop(x=7,y=2,sl='B',team='white')
self.board[7][3] = Queen(x=7,y=3,sl='Q',team='white')
self.board[7][4] = King(x=7,y=4,sl='K',team='white')
self.board[7][5] = Bishop(x=7,y=5,sl='B',team='white')
self.board[7][6] = Knight(x=7,y=6,sl='N',team='white')
self.board[7][7] = Rook(x=7,y=7,sl='R',team='white')
self.board[6][0] = Pawn(x=3,y=0,sl='P',team='white')
self.board[6][1] = Pawn(x=6,y=1,sl='P',team='white')
self.board[6][2] = Pawn(x=6,y=2,sl='P',team='white')
self.board[6][3] = Pawn(x=6,y=3,sl='P',team='white')
self.board[6][4] = Pawn(x=6,y=4,sl='P',team='white')
self.board[6][5] = Pawn(x=6,y=5,sl='P',team='white')
self.board[6][6] = Pawn(x=6,y=6,sl='P',team='white')
self.board[6][7] = Pawn(x=6,y=7,sl='P',team='white')
for i in range(9):
self.board[i][8 ]= Number(sl=i)
for j in range(9):
self.board[8][j] = Number(sl=j)
def interpret(cls, *args):
context = args[0]
if not context[0]:
return Number(context[1]).interpret()
if context[0][0:2] == cls.nine:
context[1] += (9 * cls.multiplier)
context[0] = context[0][2:]
elif context[0][0] == cls.five:
context[1] += (5 * cls.multiplier)
context[0] = context[0][1:]
elif context[0][0:2] == cls.four:
context[1] += +(4 * cls.multiplier)
context[0] = context[0][2:]
while context[0] and context[0][0] == cls.one:
context[1] += (1 * cls.multiplier)
context[0] = context[0][1:]
return Number(context[1]).interpret()
def visit(self, node):
if type(node) is nodes.NumberNode:
result = Number(node.value)
return int(result) if str(result).isdigit() else result
if type(node) is nodes.OperatorNode:
left = self.visit(node.left)
right = self.visit(node.right)
types = {"ADD": left.__add__,
"SUB": left.__sub__,
"MUL": left.__mul__,
"DIV": left.__div__}
return types[node.operator.type](right)
def get_next():
"""Generates a new number with a key and returns the information."""
try:
app.logger.info("GET request to get_next action")
data = request.get_json(force=True)
if "key" not in data:
app.logger.info(f"No key present in request body")
return jsonify({
"success": False,
"message": "No key present in request body"
}), 401
key = data["key"]
if os.getenv("KEY") != key:
app.logger.info(f"Invalid key {key} for retrieving queue number")
return jsonify({
"success": False,
"message": "Invalid key"
}), 401
app.logger.info(f"Generating number...")
counter = Counter.get_counter()
number_key = generate_random_key()
number = Number(counter.get(), number_key)
# Save Number in the database
db.session.add(number)
db.session.commit()
# Increment counter
counter.increment()
db.session.commit()
app.logger.info(
f"Number {number.position} generated with key {number_key}"
)
return jsonify({
"success": True,
"number": number.position,
"key": number_key
}), 200
except Exception as err:
app.logger.error(err)
return jsonify({"success": False}), 500
def create_sorted():
"""
-------------------------------------------------------
Create a sorted list of Number objects.
-------------------------------------------------------
Postconditions:
returns
values - a sorted list of SIZE Number objects.
-------------------------------------------------------
"""
values = []
for i in range(100):
values.insert(-1, Number(i))
return values
