def __init__(self, domain, size):
vector = Vector(domain.type)
size = Int().value(size)
if domain.iterator is not None:
iterator = SequenceIterator(domain.iterator, size)
else:
iterator = None
if domain.generator is not None:
generator_fn = Function(("generator", self.name))
generator_fn.returns(vector).code("""
{{type}} result;
size_t size = {{size}};
result.reserve(size);
for(size_t i = 0; i < size; i++) {
result.push_back({{generator}});
}
return result;
""", generator=domain.generator, size=size, type=vector)
generator = generator_fn()
else:
generator = None
if domain.size is not None:
size = Int().value(size)
domain_size = power(domain.size, size)
else:
domain_size = None
super().__init__(vector, iterator, generator, domain_size)
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
def min_fn(self):
f = Function().takes(self, "keyval1").takes(self, "keyval2")
f.returns(self)
f.code("return keyval1.value > keyval2.value ? keyval2 : keyval1;")
return f
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);")
