Python ast.FloorDiv() Examples
The following are 14
code examples of ast.FloorDiv().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
ast
, or try the search function
.
.
Example #1
| Source File: _toVHDL.py From myhdl with GNU Lesser General Public License v2.1 | 6 votes |
|
def visit_AugAssign(self, node):
# XXX apparently no signed context required for augmented assigns
left, op, right = node.target, node.op, node.value
isFunc = False
pre, suf = "", ""
if isinstance(op, (ast.Add, ast.Sub, ast.Mult, ast.Mod, ast.FloorDiv)):
pre, suf = self.inferBinaryOpCast(node, left, right, op)
elif isinstance(op, (ast.LShift, ast.RShift)):
isFunc = True
pre, suf = self.inferShiftOpCast(node, left, right, op)
self.visit(left)
self.write(" := ")
self.write(pre)
if isFunc:
self.write("%s(" % opmap[type(op)])
self.visit(left)
if isFunc:
self.write(", ")
else:
self.write(" %s " % opmap[type(op)])
self.visit(right)
if isFunc:
self.write(")")
self.write(suf)
self.write(";")
Example #2
| Source File: helper.py From YAPyPy with MIT License | 6 votes |
|
def term_rewrite(head, tail):
if tail:
for op, each in tail:
head = ast.BinOp(
head,
{
'*': ast.Mult,
'@': ast.MatMult,
'%': ast.Mod,
'//': ast.FloorDiv,
'/': ast.Div
}[op.value](),
each,
**loc @ op,
)
return head
Example #3
| Source File: helper.py From YAPyPy with MIT License | 6 votes |
|
def augassign_rewrite(it: Tokenizer):
return {
'+=': ast.Add,
'-=': ast.Sub,
'*=': ast.Mult,
'/=': ast.Div,
'//=': ast.FloorDiv,
'@=': ast.MatMult,
'%=': ast.Mod,
'&=': ast.BitAnd,
'|=': ast.BitOr,
'^=': ast.BitXor,
'<<=': ast.LShift,
'>>=': ast.RShift,
'**=': ast.Pow,
}[it.value]
Example #4
| Source File: core.py From ibis with Apache License 2.0 | 5 votes |
|
def visit_FloorDiv(self, node):
assert False, 'should never reach FloorDiv'
Example #5
| Source File: core.py From ibis with Apache License 2.0 | 5 votes |
|
def visit_BinOp(self, node):
left, op, right = node.left, node.op, node.right
if isinstance(op, ast.Pow):
return 'Math.pow({}, {})'.format(
self.visit(left), self.visit(right)
)
elif isinstance(op, ast.FloorDiv):
return 'Math.floor({} / {})'.format(
self.visit(left), self.visit(right)
)
return '({} {} {})'.format(
self.visit(left), self.visit(op), self.visit(right)
)
Example #6
| Source File: expressions.py From lexpredict-contraxsuite with GNU Affero General Public License v3.0 | 5 votes |
|
def stringify_operation(op: Any) -> str:
if isinstance(op, ast.Add):
return '+'
if isinstance(op, ast.Sub):
return '-'
if isinstance(op, ast.Mult):
return '*'
if isinstance(op, ast.Div) or isinstance(op, ast.FloorDiv):
return '/'
return str(op)
Example #7
| Source File: _recompute.py From icontract with MIT License | 5 votes |
|
def visit_BinOp(self, node: ast.BinOp) -> Any:
"""Recursively visit the left and right operand, respectively, and apply the operation on the results."""
# pylint: disable=too-many-branches
left = self.visit(node=node.left)
right = self.visit(node=node.right)
if isinstance(node.op, ast.Add):
result = left + right
elif isinstance(node.op, ast.Sub):
result = left - right
elif isinstance(node.op, ast.Mult):
result = left * right
elif isinstance(node.op, ast.Div):
result = left / right
elif isinstance(node.op, ast.FloorDiv):
result = left // right
elif isinstance(node.op, ast.Mod):
result = left % right
elif isinstance(node.op, ast.Pow):
result = left**right
elif isinstance(node.op, ast.LShift):
result = left << right
elif isinstance(node.op, ast.RShift):
result = left >> right
elif isinstance(node.op, ast.BitOr):
result = left | right
elif isinstance(node.op, ast.BitXor):
result = left ^ right
elif isinstance(node.op, ast.BitAnd):
result = left & right
elif isinstance(node.op, ast.MatMult):
result = left @ right
else:
raise NotImplementedError("Unhandled op of {}: {}".format(node, node.op))
self.recomputed_values[node] = result
return result
Example #8
| Source File: parser.py From vecpy with MIT License | 5 votes |
|
def binop(self, block, node, var=None):
if var is None:
var = self.add_variable(None)
left = self.expression(block, node.left)
right = self.expression(block, node.right)
if isinstance(node.op, ast.Add):
op = Operator.add
elif isinstance(node.op, ast.Sub):
op = Operator.subtract
elif isinstance(node.op, ast.Mult):
op = Operator.multiply
elif isinstance(node.op, ast.Div):
op = Operator.divide
elif isinstance(node.op, ast.FloorDiv):
op = Operator.divide_int
elif isinstance(node.op, ast.Mod):
op = Operator.mod
elif isinstance(node.op, ast.Pow):
op = Operator.pow
elif isinstance(node.op, ast.BitAnd):
op = Operator.bit_and
elif isinstance(node.op, ast.BitOr):
op = Operator.bit_or
elif isinstance(node.op, ast.BitXor):
op = Operator.bit_xor
elif isinstance(node.op, ast.LShift):
op = Operator.shift_left
elif isinstance(node.op, ast.RShift):
op = Operator.shift_right
else:
raise Exception('Unexpected BinOp (%s)'%(node.op.__class__))
operation = BinaryOperation(left, op, right)
assignment = Assignment(var, operation)
block.add(assignment)
return var
#Parses a unary uperation (AST UnaryOp)
Example #9
| Source File: hgawk_grammar.py From histogrammar-python with Apache License 2.0 | 5 votes |
|
def p_augassign_12(p):
'''augassign : DOUBLESLASHEQUAL'''
# 1
p[0] = ast.FloorDiv(rule=inspect.currentframe().f_code.co_name, **p[1][1])
# print_stmt: 'print' ( [ test (',' test)* [','] ] |
# '>>' test [ (',' test)+ [','] ] )
Example #10
| Source File: hgawk_grammar.py From histogrammar-python with Apache License 2.0 | 5 votes |
|
def p_term_star_4(p):
'''term_star : DOUBLESLASH factor'''
# 1 2
p[0] = [ast.FloorDiv(rule=inspect.currentframe().f_code.co_name, **p[1][1]), p[2]]
Example #11
| Source File: hgawk_grammar.py From histogrammar-python with Apache License 2.0 | 5 votes |
|
def p_term_star_8(p):
'''term_star : term_star DOUBLESLASH factor'''
# 1 2 3
p[0] = p[1] + [ast.FloorDiv(rule=inspect.currentframe().f_code.co_name, **p[2][1]), p[3]]
# factor: ('+'|'-'|'~') factor | power
Example #12
| Source File: _toVHDL.py From myhdl with GNU Lesser General Public License v2.1 | 4 votes |
|
def inferBinaryOpCast(self, node, left, right, op):
ns, os = node.vhd.size, node.vhdOri.size
ds = ns - os
if ds > 0:
if isinstance(left.vhd, vhd_vector) and isinstance(right.vhd, vhd_vector):
if isinstance(op, (ast.Add, ast.Sub)):
left.vhd.size = ns
# in general, resize right also
# for a simple name, resizing is not necessary
if not isinstance(right, ast.Name):
right.vhd.size = ns
node.vhdOri.size = ns
elif isinstance(op, ast.Mod):
right.vhd.size = ns
node.vhdOri.size = ns
elif isinstance(op, ast.FloorDiv):
left.vhd.size = ns
node.vhdOri.size = ns
elif isinstance(op, ast.Mult):
left.vhd.size += ds
node.vhdOri.size = ns
else:
raise AssertionError("unexpected op %s" % op)
elif isinstance(left.vhd, vhd_vector) and isinstance(right.vhd, vhd_int):
if isinstance(op, (ast.Add, ast.Sub, ast.Mod, ast.FloorDiv)):
left.vhd.size = ns
node.vhdOri.size = ns
elif isinstance(op, ast.Mult):
left.vhd.size += ds
node.vhdOri.size = 2 * left.vhd.size
else:
raise AssertionError("unexpected op %s" % op)
elif isinstance(left.vhd, vhd_int) and isinstance(right.vhd, vhd_vector):
if isinstance(op, (ast.Add, ast.Sub, ast.Mod, ast.FloorDiv)):
right.vhd.size = ns
node.vhdOri.size = ns
elif isinstance(op, ast.Mult):
node.vhdOri.size = 2 * right.vhd.size
else:
raise AssertionError("unexpected op %s" % op)
pre, suf = self.inferCast(node.vhd, node.vhdOri)
if pre == "":
pre, suf = "(", ")"
return pre, suf
Example #13
| Source File: _toVHDL.py From myhdl with GNU Lesser General Public License v2.1 | 4 votes |
|
def inferBinOpType(self, node):
left, op, right = node.left, node.op, node.right
if isinstance(left.vhd, (vhd_boolean, vhd_std_logic)):
left.vhd = vhd_unsigned(1)
if isinstance(right.vhd, (vhd_boolean, vhd_std_logic)):
right.vhd = vhd_unsigned(1)
if isinstance(right.vhd, vhd_unsigned):
if maybeNegative(left.vhd) or \
(isinstance(op, ast.Sub) and not hasattr(node, 'isRhs')):
right.vhd = vhd_signed(right.vhd.size + 1)
if isinstance(left.vhd, vhd_unsigned):
if maybeNegative(right.vhd) or \
(isinstance(op, ast.Sub) and not hasattr(node, 'isRhs')):
left.vhd = vhd_signed(left.vhd.size + 1)
l, r = left.vhd, right.vhd
ls, rs = l.size, r.size
if isinstance(r, vhd_vector) and isinstance(l, vhd_vector):
if isinstance(op, (ast.Add, ast.Sub)):
s = max(ls, rs)
elif isinstance(op, ast.Mod):
s = rs
elif isinstance(op, ast.FloorDiv):
s = ls
elif isinstance(op, ast.Mult):
s = ls + rs
else:
raise AssertionError("unexpected op %s" % op)
elif isinstance(l, vhd_vector) and isinstance(r, vhd_int):
if isinstance(op, (ast.Add, ast.Sub, ast.Mod, ast.FloorDiv)):
s = ls
elif isinstance(op, ast.Mult):
s = 2 * ls
else:
raise AssertionError("unexpected op %s" % op)
elif isinstance(l, vhd_int) and isinstance(r, vhd_vector):
if isinstance(op, (ast.Add, ast.Sub, ast.Mod, ast.FloorDiv)):
s = rs
elif isinstance(op, ast.Mult):
s = 2 * rs
else:
raise AssertionError("unexpected op %s" % op)
if isinstance(l, vhd_int) and isinstance(r, vhd_int):
node.vhd = vhd_int()
elif isinstance(l, (vhd_signed, vhd_int)) and isinstance(r, (vhd_signed, vhd_int)):
node.vhd = vhd_signed(s)
elif isinstance(l, (vhd_unsigned, vhd_int)) and isinstance(r, (vhd_unsigned, vhd_int)):
node.vhd = vhd_unsigned(s)
else:
node.vhd = vhd_int()
node.vhdOri = copy(node.vhd)
Example #14
| Source File: compiler.py From Transcrypt with Apache License 2.0 | 4 votes |
|
def visit_BinOp (self, node):
if type (node.op) == ast.FloorDiv:
if self.allowOperatorOverloading:
self.emit ('__floordiv__ (')
self.visitSubExpr (node, node.left)
self.emit (', ')
self.visitSubExpr (node, node.right)
self.emit (')')
else:
self.emit ('Math.floor (')
self.visitSubExpr (node, node.left)
self.emit (' / ')
self.visitSubExpr (node, node.right)
self.emit (')')
elif (
type (node.op) in (ast.Pow, ast.MatMult) or
(type (node.op) == ast.Mod and (self.allowOperatorOverloading or not self.allowJavaScriptMod)) or
(type (node.op) in (
ast.Mult, ast.Div, ast.Add, ast.Sub,
ast.LShift, ast.RShift, ast.BitOr, ast.BitXor, ast.BitAnd
) and self.allowOperatorOverloading)
):
self.emit ('{} ('.format (self.filterId (
# Non-overloaded
('__floordiv__' if self.allowOperatorOverloading else 'Math.floor') if type (node.op) == ast.FloorDiv else
('__pow__' if self.allowOperatorOverloading else 'Math.pow') if type (node.op) == ast.Pow else
'__matmul__' if type (node.op) == ast.MatMult else
('__jsmod__' if self.allowJavaScriptMod else '__mod__') if type (node.op) == ast.Mod else
# Overloaded arithmetic
'__mul__' if type (node.op) == ast.Mult else
'__truediv__' if type (node.op) == ast.Div else
'__add__' if type (node.op) == ast.Add else
'__sub__' if type (node.op) == ast.Sub else
# Overloaded bitwise
'__lshift__' if type (node.op) == ast.LShift else
'__rshift__' if type (node.op) == ast.RShift else
'__or__' if type (node.op) == ast.BitOr else
'__xor__' if type (node.op) == ast.BitXor else
'__and__' if type (node.op) == ast.BitAnd else
'Never here'
)))
self.visit (node.left)
self.emit (', ')
self.visit (node.right)
self.emit (')')
else:
self.visitSubExpr (node, node.left)
self.emit (' {} '.format (self.operators [type (node.op)][0]))
self.visitSubExpr (node, node.right)
