def fill(self, qty, price):
for q in qty:
# globalAtomicPrinter.printit(q)
self.qty.append(Number(q).value)
for p in price:
# globalAtomicPrinter.printit(p)
self.price.append(Number(p).value)
def derive(self):
if isinstance(self.getOperand(), Variable):
return BinaryOp(Op.Mult, Number(-1), Sin(self.getOperand()))
else:
return BinaryOp(
Op.Mult,
BinaryOp(Op.Mult, Number(-1),
self.getOperand().derive()), Cos(self.getOperand()))
def derive(self):
if self.getPower() == 0:
return Number(0)
else:
if isinstance(self.__operand, Variable):
return BinaryOp(Op.Mult, Number(self.__power),
Poly(self.__operand, self.__power - 1))
else:
return BinaryOp(
Op.Mult, Number(self.__power),
BinaryOp(Op.Mult, self.__operand.derive(),
Poly(self.__operand, self.__power - 1)))
def __init__(self, terminalHandler=stdout, debug=None):
super().__init__(terminalHandler, debug)
self.bus = smbus.SMBus(1)
self.bus.write_byte(constants.BAT_BUTTONS_I2C_ADDRESS, 0xFF)
self.bus.write_byte(constants.BALL_LED_I2C_ADDRESS, 0xFF)
self.batButtonState = 0xFF
GPIO.setmode(GPIO.BCM)
GPIO.setup(constants.BAT_BUTTONS_INTERRUPT_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(
constants.BAT_BUTTONS_INTERRUPT_PIN, GPIO.FALLING, callback=self.handleControllerInterrupt)
for pin in constants.LED_PINS:
GPIO.setup(pin, GPIO.OUT)
self.lastLED = None
self.scoreLeft = Number(0, 29, 2, "cyan")
self.scoreRight = Number(0, 49, 2, "pink")
self.leftController = CPLDHandler(
self.bus, constants.LEFT_BAT_I2C_ADDRESS
)
self.rightController = OnBoardADCHandler(self.bus, constants.RIGHT_BAT_I2C_ADDRESS, constants.RIGHT_BAT_CMD_CODE)
self.batLeft = Bat(3, 12, 6, "cyan", self.leftController)
self.batRight = Bat(77, 12, -6, "pink", self.rightController)
self.edges = [
GameObject(0, -1, constants.PONG_WIDTH, 1, "red"),
#deleted the "+1" that followed constants.PONG_HEIGHT
GameObject(0, constants.PONG_HEIGHT + 1,
constants.PONG_WIDTH, 1, "red"),
]
self.ball = Ball(
10, 20, constants.SERVE_SPEED, "green", self.edges +
[self.batLeft, self.batRight], 25, 1, 1
)
self.addObjects(
[self.scoreLeft, self.scoreRight, self.batLeft, self.batRight, self.ball]
+ self.edges
)
self.ball.serving = 'right'
self.serves = 0
self.gameOver = False
self.winnerText = None
def create_randoms():
"""
-------------------------------------------------------
Create a 2D list of Number objects.
Use: lists = create_randoms()
-------------------------------------------------------
Returns:
lists - TEST lists of SIZE Number objects containing
values between 0 and XRANGE (list of List of Number)
-------------------------------------------------------
"""
lists = List()
for x in range(TESTS):
row = []
for i in range(SIZE):
v = randint(0, XRANGE)
num = Number(v)
row.append(num)
lists.append(row)
return lists
def create_randoms():
"""
-------------------------------------------------------
Create a 2D list of Number objects with TEST rows and
SIZE columns of values between 0 and XRANGE.
Use: lists = create_randoms()
-------------------------------------------------------
Returns:
arrays - TEST lists of SIZE Number objects containing
values between 0 and XRANGE (list of list of Number)
-------------------------------------------------------
"""
arrays = [ ]
list_1 = arrays
for i in range(TESTS):
row = [ ]
for j in range((SIZE)):
row.append(Number(random.randint(0,XRANGE)))
arrays.append(row)
arrays = list_1
return arrays
def updateValue(self, table_img):
self.value_container.numbers = []
if not (self.is_available): return
numbers_list = []
table_img_portion = table_img.crop(
(self.box.left, self.box.top, self.box.left + self.box.width,
self.box.top + self.box.height))
if (True):
#Attempt to locate stack
for i, file in enumerate(range(10)):
file = str(i) + '.png'
for j, box in enumerate(
pyautogui.locateAll(
constants.NUMBERS_BUTTON_PATH + file,
table_img_portion,
confidence=constants.NUMBERS_BUTTON_DET_CONFIDENCE)
):
if (box != None):
numbers_list.append(Number(value=i, box=box))
else:
pass
else:
pass
numbers_list.sort(key=lambda number: number.left)
#print([number.value for number in numbers_list])
for number in numbers_list:
self.value_container.addNumber(number)
self.value_container.computeValue()
self.value_container.corresponding_entity = self.id
self.value = self.value_container.value
print('[Button] ' + str(self.id) + ' holds value: ' + str(self.value))
return
def parse_term(cls, term):
""" Parse a string into a Term object """
#
# tests the term for syntactical errors
# then cleans up the string
# if it is a compound term like 3x^2 it first expands that to 3*x^2
# then parses 3 and x^2 separately, then simplifies it to a single term.
#
if isinstance(term, Term): return term
cls.test_term(term)
term = cls.clean_up(term)
terms = cls.separate(term, "*/()")
while "(" in terms:
start, end = cls.get_parentheses_location(terms)
result = cls.parse_term("".join(terms[start + 1:end]))
terms = cls.list_replace(terms, start, end, result)
if len(terms) == 1:
term = terms[0]
if number_pattern.fullmatch(term):
# its a number
return Term(Number(float(term)), [], [])
elif term in delimiters:
# it is an operator or parenthesis
return term
elif "^" in term:
# it was not a Number, operator, or parenthesis.
# it is something of the form (var)^(exponent)
return Term(Number(1), [Symbol(term[0])],
[Number(float(term[term.rfind("^") + 1:]))])
else:
# it is just a single variable such as "x" or "y"
return Term(Number(1), [Symbol(term)], [Number(1)])
else:
# it is not possible for recursion depth to exceed 2 here.
terms = [cls.parse_term(t) for t in terms]
while "*" in terms or "/" in terms:
index = cls.list_index(terms, ["*", "/"])
# ^^ this will be the first occurence of an operator.
terms = cls.list_substitute(terms, index)
return terms[0]
def __truediv__(self, other):
f = dict(zip(map(lambda v: v.symbol, self.syms), self.exps))
new_numerator, new_denominator = {}, {}
if other.syms:
for var, exp in zip(other.syms, other.exps):
var = var.symbol
if var in f.keys():
f[var] -= exp
number = f[var]
else:
f[var] = -exp
number = f[var]
null = Number(0)
if number < null:
new_denominator[var] = -number
elif number > null:
new_numerator[var] = number
else:
pass
# if the new exponent is 0, don't include it.
else:
new_numerator = dict(
zip(map(lambda s: s.symbol, self.syms), self.exps))
new_coef = self.coef / other.coef
numerator_term = Term(
Number(new_coef.numerator),
list(map(lambda v: Symbol(v), new_numerator.keys())),
list(new_numerator.values()))
denominator_term = Term(
Number(new_coef.denominator),
list(map(lambda v: Symbol(v), new_denominator.keys())),
list(new_denominator.values()))
if not denominator_term.syms:
return Term(new_coef, numerator_term.syms, numerator_term.exps)
else:
# not sure what to do here either. if this block executes it means
# that the division could not be simplified to a single term...
raise NotImplementedError
def VisitForNode(self, node, context):
res = RTResult()
elements = []
startVal = res.register(self.visit(node.startVal, context))
if res.shouldReturn(): return res
endVal = res.register(self.visit(node.endVal, context))
if res.shouldReturn(): return res
if node.stepVal:
stepVal = res.register(self.visit(node.stepVal, context))
if res.shouldReturn(): return res
else:
stepVal = Number(1)
i = startVal.value
if stepVal.value >= 0:
condition = lambda: i < endVal.value
else:
condition = lambda: i > endVal.value
while condition():
context.symbTable.set(node.varToken.value, Number(i))
i += stepVal.value
value = res.register(self.visit(node.body, context))
if res.shouldReturn(
) and res.contLoop == False and res.breakLoop == False:
return res
if res.contLoop:
continue
if res.breakLoop:
break
elements.append(value)
return res.success(
Number.null if node.returnNull else List(elements).
setContext(context).setPosition(node.startPos, node.endPos))
def run(n, r, test):
if n % 2 == 0:
return False
a = Number(n, n - 1)
while a > 0 and r > 0:
if not (gcd(a, n) == 1
and PrimeTests.condition_of_test(test, a, n)):
return False
a -= 1
r -= 1
return True
def VisitUnaryOperationNode(self, node, context):
res = RTResult()
number = res.register(self.visit(node.node, context))
if res.shouldReturn(): return res
error = None
if node.oper.type == MINUS_T:
number, error = number.mult(Number(-1))
elif node.oper.sameElem(KEYWORD_T, 'not'):
number, error = number.notBool()
if error:
return res.failure(error)
else:
return res.success(number.setPosition(node.startPos, node.endPos))
def create_reversed():
"""
-------------------------------------------------------
Create a reversed List of Number objects.
Use: values = create_reversed()
-------------------------------------------------------
Returns:
values - a reversed list of SIZE Number objects (List of Number)
-------------------------------------------------------
"""
values = List()
for i in range(SIZE - 1, -1, -1):
temp_num = Number(i)
values.append(temp_num)
return values
def main():
numbers = [Number(randint(-10, 10)), Number(randint(-10, 10)),
Number(randint(-10, 10)), Number(randint(-10, 10)),
Number(randint(-10, 10)), Number(randint(-10, 10))]
for number in numbers:
print("Angka:", number.number)
print("Positif Genap:", number.is_even_positive())
print("Negatif Genap:", number.is_even_negative())
print("Positif Ganjil:", number.is_odd_positive())
print("Negatif Ganjil:", number.is_odd_negative(), end="\n\n")
def visit_UnaryOpNode(self, node, context):
response = RunTimeResult()
number = response.register(self.visit(node.node, context))
if response.error: return response
error = None
if node.operation_token.token_type == TokenType.MINUS:
number, error = number.multed_by(Number(-1))
elif node.operation_token.matches(TokenType.KEYWORD, 'NOT'):
number, error = number.notted()
if error:
return response.failure(error)
else:
return response.success(
number.set_position(node.position_start, node.position_end))
def create_reversed():
"""
-------------------------------------------------------
Create a reversed list of Number objects.
Use: values = create_reversed()
-------------------------------------------------------
Returns:
values - a reversed list of SIZE Number objects (list of Number)
-------------------------------------------------------
"""
# your code here
values = []
for i in range(SIZE - 1, -1, -1):
num = Number(i)
values.append(num)
return values
def create_sorted():
"""
-------------------------------------------------------
Creates a sorted List of Number objects.
Use: values = create_sorted()
-------------------------------------------------------
Returns:
values - a sorted list of SIZE Number objects (List of Number)
-------------------------------------------------------
"""
# your code here
values = List()
for i in range(SIZE):
num = Number(i)
values.append(num)
return values
def create_reversed():
"""
-------------------------------------------------------
Create a reversed list of SIZE Number objects with values
from SIZE-1 down to 0.
Use: values = create_reversed()
-------------------------------------------------------
Returns:
values - a reversed list of SIZE Number objects (list of Number)
-------------------------------------------------------
"""
values = []
for i in range(SIZE-1,-1,-1):
values.append(Number(i))
return values
def create_sorted():
"""
-------------------------------------------------------
Creates a sorted list of SIZE Number objects with values
from 0 up to SIZE-1.
Use: values = create_sorted()
-------------------------------------------------------
Returns:
values - a sorted list of SIZE Number objects (list of Number)
-------------------------------------------------------
"""
values = []
for i in range(SIZE):
temp_num = Number(i)
values.append(temp_num)
return values
def main1():
import sqlite3
import pickle
c = NumberGenerator()
base = pickle.load(open('exceptions.pickle', 'rb')).get('français')
parser = Number(excpetions=base)
reche = "SELECT integer, ortho, phon FROM Lexique WHERE isinteger = 1"
with sqlite3.connect('Lexique.db') as conn:
cursor = conn.cursor()
intp = range(1, 9999)
# base2 = {x: (y, z) for x, y, z in cursor.execute(reche).fetchall()} # pour avoir int: (graphie, phonologie)
base2 = {x: y for x, y, z in cursor.execute(reche).fetchall()} # pour avoir int: graphie
for x in map(lambda x: c.convert_int2str(x, parser, base2), intp): print(x)
def create_randoms():
"""
-------------------------------------------------------
Create a 2D list of Number objects.
Use: lists = create_randoms()
-------------------------------------------------------
Returns:
arrays - TESTS lists of SIZE Number objects containing
values between 0 and XRANGE (list of list of Number)
-------------------------------------------------------
"""
# your code here
arrays = [[None for i in range(SIZE)] for j in range(TESTS)]
for i in range(TESTS):
for j in range(SIZE):
rand = random.randint(0, XRANGE)
num = Number(rand)
arrays[i][j] = num
return arrays
def create_randoms():
"""
-------------------------------------------------------
Create a 2D list of Number objects.
Use: lists = create_randoms()
-------------------------------------------------------
Returns:
lists - TEST lists of SIZE Number objects containing
values between 0 and XRANGE (list of List of Number)
-------------------------------------------------------
"""
lists = []
for i in range(TESTS):
temp = List()
for j in range(SIZE):
temp.append(Number(randint(0, XRANGE)))
lists.append(temp)
return lists
def updateStack(self, table_img):
self.stack_container.numbers = []
numbers_list = []
table_img_portion = table_img.crop(
(self.player_box.left, self.player_box.top,
self.player_box.left + self.player_box.width,
self.player_box.top + self.player_box.height + 25))
try:
#Attempt to locate stack
for i, file in enumerate(range(10)):
file = str(i) + '.png'
for j, box in enumerate(
pyautogui.locateAll(
constants.NUMBERS_STACK_PATH + file,
table_img_portion,
confidence=constants.NUMBERS_STACK_DET_CONFIDENCE)
):
if (box != None):
numbers_list.append(Number(value=i, box=box))
else:
pass
except:
pass
numbers_list.sort(key=lambda number: number.left)
#print([number.value for number in numbers_list])
for number in numbers_list:
self.stack_container.addNumber(number)
try:
self.stack_container.computeValue()
self.stack_container.corresponding_entity = self.id
self.stack_value = self.stack_container.value
except:
pass
#print('[Player] Player '+str(self.id)+' has stack of size: '+str(self.stack_value))
return
def create_randoms():
"""
-------------------------------------------------------
Create a 2D list of Number objects.
Use: lists = create_randoms()
-------------------------------------------------------
Returns:
lists - TEST lists of SIZE Number objects containing
values between 0 and XRANGE (list of List of Number)
-------------------------------------------------------
"""
# your code here
lists = []
for i in range(TESTS):
for _ in range(SIZE):
inner_list = List()
rand = random.randint(0, XRANGE)
num = Number(rand)
inner_list.append(num)
lists.append(inner_list)
return lists
from Number import Number
from TerminalHandler import TerminalHandler
from Game import Game
number = Number(4, 10, 2, 'red')
print(number.render())
game = Game()
game.addObject(Number(4, 10, 2, 'red'))
game.addObject(Number(1, 20, 2, 'red'))
game.addObject(Number(123, 3, 10, 'blue'))
game.render(0)
while(True):
pass
def VisitNumNode(self, node, context):
return RTResult().success(
Number(node.token.value).setContext(context).setPosition(
node.startPos, node.endPos))
def __neg__(self):
return self * Term(Number(-1), [], [])
from Number import Number X = Number(5) Y = X - 2 Y.data
for i in range(len)
]
result = [d[i] == (a[i] == (b[i] == c[i + 1])) for i in range(len)]
carry = [
c[i] == Or(And(a[i], b[i]), And(a[i], c[i + 1]),
And(b[i], c[i + 1])) for i in range(len)
]
edge = [Not(c[0]), Not(c[len])]
s = Solver()
s.add(result + carry + premiseA + premiseB + premiseD + edge)
if s.check() == sat:
ans = 0
for i in range(len):
ans <<= 1
if is_true(s.model()[b[i]]):
ans += 1
print('the answer is %d.' % ans)
else:
print('no solution!')
if __name__ == '__main__':
cal = Calculator()
print("请输入被减数：")
sum = Number()
sum.set_value(int(input()))
print("请输入减数：")
operand = Number()
operand.set_value(int(input()))
cal.substract(sum, operand)
def searchAllBets(table_img):
glob_file.all_bet_containers_found = False
glob_file.bet_containers = []
numbers_list = []
for player in glob_file.players:
player.bet_value = 0
table_img_portion = table_img #table_img.crop((self.box.left-100,self.box.top-100,self.box.left+self.box.width+100,self.box.top+self.box.height+100))
try:
#Attempt to locate bet
for i, file in enumerate(
range(10)): #os.listdir(constants.NUMBERS_BET_PATH)
file = str(i) + '.png'
for j, box in enumerate(
pyautogui.locateAll(
constants.NUMBERS_BET_PATH + file,
table_img_portion,
confidence=constants.NUMBERS_BET_DET_CONFIDENCE)):
if (box != None):
numbers_list.append(Number(value=i, box=box))
else:
pass
except:
pass
numbers_list.sort(key=lambda number: number.left)
numbers_list.sort(key=lambda number: number.top)
#print([number.value for number in numbers_list])
bet_container_id = 0
for i in range(len(numbers_list)):
if (i == 0):
number = numbers_list[i]
glob_file.bet_containers.append(
NumberContainer(id_=bet_container_id, type='BET'))
glob_file.bet_containers[bet_container_id].addNumber(number)
else:
previous_number = numbers_list[i - 1]
number = numbers_list[i]
if (previous_number.left) <= number.left and (
previous_number.left +
20) >= number.left and previous_number.top == number.top:
glob_file.bet_containers[bet_container_id].addNumber(number)
else:
bet_container_id += 1
glob_file.bet_containers.append(
NumberContainer(id_=bet_container_id, type='BET'))
glob_file.bet_containers[bet_container_id].addNumber(number)
#print(glob_file.players[0].center_pos)
for bet_container in glob_file.bet_containers:
bet_container.computeValue()
#print(bet_container.value)
bet_container.attributeEntity(glob_file.players,
glob_file.table.center_pos)
#if bet_container.corresponding_entity!='POT':
# glob_file.players[bet_container.corresponding_entity].bet_value = bet_container.value
glob_file.bet_containers.sort(key=lambda x: -1 if x.corresponding_entity ==
'POT' else x.corresponding_entity)
if (len(glob_file.bet_containers) == constants.NB_PLAYERS):
glob_file.all_bet_containers_found = True
return
