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