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
