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);")