def MSB(b, k):
# calculation of z
# x in order 0 - k
if (k > types.program.bit_length):
raise OverflowError("The supported bit \
lenght of the application is smaller than k")
x_order = b.bit_decompose(k)
x = [0] * k
# x i now inverted
for i in range(k - 1, -1, -1):
x[k - 1 - i] = x_order[i]
# y is inverted for PReOR and then restored
y_order = floatingpoint.PreOR(x)
# y in order (restored in orginal order
y = [0] * k
for i in range(k - 1, -1, -1):
y[k - 1 - i] = y_order[i]
# obtain z
z = [0] * (k + 1 - k % 2)
for i in range(k - 1):
z[i] = y[i] - y[i + 1]
z[k - 1] = y[k - 1]
return z
def Sep(x):
b = floatingpoint.PreOR(
list(reversed(x.v.bit_decompose(x.k, maybe_mixed=True))))
t = x.v * (1 + x.v.bit_compose(b_i.bit_not() for b_i in b[-2 * x.f + 1:]))
u = types.sfix._new(t.right_shift(x.f, 2 * x.k, signed=False))
b += [b[0].long_one()]
return u, [b[i + 1] - b[i] for i in reversed(range(x.k))]
def find_deeper(a, b, path, start, length, compute_level=True):
a_bits = a.value.bit_decompose(length)
b_bits = b.value.bit_decompose(length)
path_bits = path.bit_decompose(length)
a_bits.reverse()
b_bits.reverse()
path_bits.reverse()
level_bits = [0] * length
# make sure that winner is set at start if one input is empty
any_empty = OR(a.empty, b.empty)
a_diff = [XOR(a_bits[i], path_bits[i]) for i in range(start, length)]
b_diff = [XOR(b_bits[i], path_bits[i]) for i in range(start, length)]
diff = [XOR(ab, bb) for ab, bb in zip(a_bits, b_bits)[start:length]]
diff_preor = floatingpoint.PreOR([any_empty] + diff)
diff_first = [x - y for x, y in zip(diff_preor, diff_preor[1:])]
winner = sum((ad * df for ad, df in zip(a_diff, diff_first)), a.empty)
winner_bits = [if_else(winner, bd, ad) for ad, bd in zip(a_diff, b_diff)]
winner_preor = floatingpoint.PreOR(winner_bits)
level_bits = [x - y for x, y in zip(winner_preor, [0] + winner_preor)]
return [0] * start + level_bits + [1 - sum(level_bits)], winner
def norm_SQ(b, k):
# calculation of z
# x in order 0 - k
x_order = b.bit_decompose()
x = [0] * k
#x i now inverted
for i in range(k - 1, -1, -1):
x[k - 1 - i] = x_order[i]
# y is inverted for PReOR and then restored
y_order = floatingpoint.PreOR(x)
# y in order (restored in orginal order
y = [0] * k
for i in range(k - 1, -1, -1):
y[k - 1 - i] = y_order[i]
# obtain z
z = [0] * k
for i in range(k - 1):
z[i] = y[i] - y[i + 1]
z[k - 1] = y[k - 1]
# now reverse bits of z[i] to generate v
v = types.sint()
for i in range(k):
v += (2**(k - i - 1)) * z[i]
c = b * v
# construct m
m = types.sint()
for i in range(k):
m = m + (i + 1) * z[i]
# construct w, changes from what is on the paper
# and the documentation
k_over_2 = k / 2 + 1 #int(math.ceil((k/2.0)))+1
w_array = [0] * (k_over_2)
for i in range(1, k_over_2):
w_array[i] = z[2 * i - 1 - (1 - k % 2)] + z[2 * i - (1 - k % 2)]
w_array[0] = types.sfix(0)
w = types.sint()
for i in range(k_over_2):
w += (2**i) * w_array[i]
# return computed values
return c, v, m, w
def Norm(self, k, f, kappa=None, simplex_flag=False):
absolute_val = abs(self)
#next 2 lines actually compute the SufOR for little indian encoding
bits = absolute_val.bit_decompose(k)[::-1]
suffixes = floatingpoint.PreOR(bits)[::-1]
z = [0] * k
for i in range(k - 1):
z[i] = suffixes[i] - suffixes[i+1]
z[k - 1] = suffixes[k-1]
z.reverse()
t2k = self.get_type(2 * k)
acc = t2k.bit_compose(z)
sign = self.bit_decompose()[-1]
signed_acc = util.if_else(sign, -acc, acc)
absolute_val_2k = t2k.bit_compose(absolute_val.bit_decompose())
part_reciprocal = absolute_val_2k * acc
return part_reciprocal, signed_acc
def MSB(b, k):
# calculation of z
# x in order 0 - k
x_order = b.bit_decompose(k)
x = [0] * k
# x i now inverted
for i in range(k - 1, -1, -1):
x[k - 1 - i] = x_order[i]
# y is inverted for PReOR and then restored
y_order = floatingpoint.PreOR(x)
# y in order (restored in orginal order
y = [0] * k
for i in range(k - 1, -1, -1):
y[k - 1 - i] = y_order[i]
# obtain z
z = [0] * (k + 1 - k % 2)
for i in range(k - 1):
z[i] = y[i] - y[i + 1]
z[k - 1] = y[k - 1]
return z
