def product_to_dual_error(product, target, comb_func=sum): prod_digs = product.as_integer_base.digits targ_digs = target.digits while len(prod_digs) < len(targ_digs): prod_digs.append(0) assert len(prod_digs) == len(targ_digs) error = abs(digits_to_int(prod_digs) - digits_to_int(targ_digs)) error_rev = abs(digits_to_int(prod_digs[::-1]) - digits_to_int(targ_digs[::-1])) return comb_func([error, error_rev])
def filter_small_products(children, target): legit = [] for child in children: p_dig, q_dig = child.p.digits, child.q.digits # print p_dig for i in xrange(len(p_dig) - child.p.num_fixed_digits + 1): p_dig[i] = BASE - 1 # print p_dig for i in xrange(len(q_dig) - child.q.num_fixed_digits + 1): q_dig[i] = BASE - 1 if digits_to_int(p_dig) * digits_to_int(q_dig) < target.as_int: continue legit.append(child) return legit
def __init__(self, digits): if isinstance(digits, INT_TYPES): self._as_int = digits self._digits = tuple(int_to_digits(digits)) else: self._digits = tuple(digits) self._as_int = digits_to_int(digits)
def filter_large_products(children, target): legit = [] for child in children: p_dig, q_dig = child.p.digits, child.q.digits # print p_dig for i in xrange(child.p.num_fixed_digits_left, len(p_dig)-child.p.num_fixed_digits_right): p_dig[i] = 0 # print p_dig for i in xrange(child.q.num_fixed_digits_left, len(q_dig)-child.q.num_fixed_digits_right): q_dig[i] = 0 if digits_to_int(p_dig) * digits_to_int(q_dig) > target.as_int: continue legit.append(child) return legit
def product_to_error(product, target): # Extract the digits and pad product_digits = product.as_integer_base.digits[:] target_digits = target.digits[:] while len(product_digits) < len(target_digits): product_digits.append(0) while len(product_digits) > len(target_digits): target_digits.append(0) # while product_digits[-1] == target_digits[-1]: # product_digits.pop() # target_digits.pop() rev_prod = digits_to_int(product_digits[::-1]) rev_targ = digits_to_int(target_digits[::-1]) diff = abs(rev_prod - rev_targ) # print '\n'.join(map(str, [product, target, diff])) # print return diff
def product_to_error2(product, target): # Extract the digits and pad p_digits = product.p.digits q_digits = product.q.digits target_digits = target.digits num_digits = target_to_max_factor_num_digits(target, 0) fill_value = (BASE - 1) / 2.0 if BASE % 2: fill_value = intify(fill_value) while len(p_digits) < num_digits: p_digits.append(fill_value) while len(q_digits) < num_digits: q_digits.append(fill_value) filled_product = digits_to_int(p_digits) * digits_to_int(q_digits) filled_product = intify(filled_product) filled_product = IntegerBase(filled_product) product_digits = filled_product.digits while len(product_digits) < len(target_digits): product_digits.append(0) while len(product_digits) > len(target_digits): # product_digits.pop() target_digits.append(0) # while product_digits[0] == target_digits[0]: # product_digits.pop() # target_digits.pop() rev_prod = digits_to_int(product_digits[::-1]) rev_targ = digits_to_int(target_digits[::-1]) diff = abs(rev_prod - rev_targ) # print '\n'.join(map(str, [product, target, diff])) # print return diff
def product_to_hamming_distance(product, target): prod_digs = product.as_integer_base.digits targ_digs = target.digits # for _ in xrange(product.factor_num_digits): # print _, prod_digs, targ_digs # assert prod_digs[_] == targ_digs[_] targ_digs = targ_digs[product.factor_num_digits : len(prod_digs)] prod_digs = prod_digs[product.factor_num_digits :][: len(targ_digs)] # print targ_digs, prod_digs assert len(targ_digs) == len(prod_digs) hamming_distances = [abs(t_d - p_d) for t_d, p_d in itertools.izip(targ_digs, prod_digs)] return digits_to_int(hamming_distances[::-1])
def as_int(self): if self._as_int is None: assert self._digits is not None self._as_int = digits_to_int(self._digits, self.base) return self._as_int