def multiplication_n(size):
f = Function("mul").returns(Int())
for i in range(size):
f.takes(Int())
code = "*".join(p.name for p in f.params)
f.code("return {};".format(code))
return f
def __init__(self, start, end=None, step=1):
if end is None:
end = start
start = 0
start = Int().value(start)
end = Int().value(end)
step = Int().value(step)
iterator = RangeIterator(start, end, step)
generator = rand_int(start, end)
if (start.is_constructor() and start.value == 0 and
step.is_constructor() and step.value == 1):
size = end
indexer = identity
else:
size = range_size(start, end, step)
indexer = Function().returns(Int())
indexer.takes(Int(), "_v")
indexer.code("return (_v - {{start}}) / {{step}};",
start=start, step=step)
super().__init__(Int(),
iterator,
generator,
size,
indexer)
def addition_n(size):
f = Function("add").returns(Int())
for i in range(size):
f.takes(Int())
code = "+".join(p.name for p in f.params)
f.code("return {};".format(code))
return f
else:
size = range_size(start, end, step)
indexer = Function().returns(Int())
indexer.takes(Int(), "_v")
indexer.code("return (_v - {{start}}) / {{step}};",
start=start, step=step)
super().__init__(Int(),
iterator,
generator,
size,
indexer)
range_size = Function()
range_size.takes(Int(), "start")
range_size.takes(Int(), "end")
range_size.takes(Int(), "step")
range_size.returns(Int())
range_size.code("return (end - start) / step;")
class RangeIterator(Iterator):
def __init__(self, start, end, step):
itype = Int()
super().__init__(itype, Int())
self.reset_fn.code("iter = {{start}};", start=start)
self.next_fn.code("iter+={{step}};", step=step)
self.is_valid_fn.code("return iter < {{end}};", end=end)
self.value_fn = identity
mul = multiplication_n(2)
def addition_n(size):
f = Function("add").returns(Int())
for i in range(size):
f.takes(Int())
code = "+".join(p.name for p in f.params)
f.code("return {};".format(code))
return f
add = addition_n(2)
# Naive way of making power, but it is sufficient for now
power = Function("power").takes(Int(), "base").takes(Int(), "power").returns(Int())
power.code("""
int result = 1;
int p = power;
while(p > 0) {
result *= base;
p--;
}
return result;
""")
identity = Function("identity")
identity.takes(Int(), "a").returns(Int()).code("return a;")
subtract = Function("subtract")
subtract.takes(Int(), "a").takes(Int(), "b").returns(Int())
subtract.code("return a - b;")
from qit.base.function import Function
from qit.base.int import Int
rand_int = Function("rand_int")
rand_int.takes(Int(), "from").takes(Int(), "to")
rand_int.returns(Int())
rand_int.code("return std::uniform_int_distribution<qint>(from, to - 1)(QIT_GENERATOR);")
def prepare_write_function(self):
from qit.base.function import Function
from qit.base.file import File
f = Function(("write", self.name))
f.takes(File(), "output").takes(self, "value")
return f
