def MulOp(x, y): # (* x = x * y *) global RH if (x.mode == ORB.Const) and (y.mode == ORB.Const): x.a = x.a * y.a elif (y.mode == ORB.Const) and (y.a >= 2) and (log2(y.a) == 1): load(x) Put1(Lsl, x.r, x.r, log2(y.a)) elif y.mode == ORB.Const: load(x) Put1a(Mul, x.r, x.r, y.a) elif (x.mode == ORB.Const) and (x.a >= 2) and (log2(x.a) == 1): load(y) Put1(Lsl, y.r, y.r, log2(x.a)) x.mode = Reg x.r = y.r elif x.mode == ORB.Const: load(y) Put1a(Mul, y.r, y.r, x.a) x.mode = Reg x.r = y.r else: load(x) load(y) Put0(Mul, RH - 2, x.r, y.r) RH -= 1 x.r = RH - 1
def _main(f): """ >>> _main('abaab') unigram: nbits < 7.906891 bigram: nbits < 7.584963 >>> _main('bababa') unigram: nbits < 9.129283 bigram: nbits < 6.584963 """ text = ''.join(l.strip() for l in f) A = len(set(text)) k_unigram = defaultdict(int) logprob_unigram = 0 for (n, ai) in enumerate(text): p = (k_unigram[ai] + 1) / (n + A) assert 0 <= p <= 1, 'probabilities must be in [0,1]' logprob_unigram += log2(p) k_unigram[ai] += 1 print 'unigram: nbits < %f' % (2 - logprob_unigram) k_bigram = defaultdict(int) njs = defaultdict(int) logprob_bigram = log2(1.0 / A) for (aj, ai) in bigrams(text): kij = k_bigram[(ai, aj)] nj = njs[aj] p = (kij + 1) / (nj + A) assert 0 <= p <= 1, 'probabilities must be in [0,1]' logprob_bigram += log2(p) k_bigram[(ai, aj)] += 1 njs[aj] += 1 print 'bigram: nbits < %f' % (2 - logprob_bigram)
def MulOp(x, y): # (* x = x * y *) global RH if (x.mode == ORB.Const) and (y.mode == ORB.Const): x.a = x.a * y.a elif (y.mode == ORB.Const) and (y.a >= 2) and (log2(y.a) == 1): load(x) Put1(Lsl, x.r, x.r, log2(y.a)) elif y.mode == ORB.Const: load(x) Put1a(Mul, x.r, x.r, y.a) elif (x.mode == ORB.Const) and (x.a >= 2) and (log2(x.a) == 1): load(y) Put1(Lsl, y.r, y.r, log2(x.a)) x.mode = Reg x.r = y.r elif x.mode == ORB.Const: load(y) Put1a(Mul, y.r, y.r, x.a) x.mode = Reg x.r = y.r else: load(x) load(y) Put0(Mul, RH-2, x.r, y.r) RH -= 1 x.r = RH-1
def setup(label, ps): progress(label, "starting setup") try: with open(jar(label), "rb") as brine: ps = pickle.load(brine) except IOError: progress(label, "generating distributions") secret_l2_dist = ps.secret_l2_distribution() progress(label, "done secret l2 dist") query_l2_dist = ps.query_l2_distribution() progress(label, "done query l2 dist") e3_dist = ps.e3_distribution() progress(label, "done e3 dist") one_shot_dist = ps.one_shot_distribution() progress(label, "done one shot dist") f = tail_probability(one_shot_dist, ps.threshold()) p(label, "oneshot", float(-log2(f))) p(label, "max_abs_e3", max(dist_absolute(e3_dist))) with open(jar(label), "wb") as brine: pickle.dump(ps, brine) progress(label, "done setup")
def volume_estimate(ps, query_l2_dist, alpha, optimize_e3=False): dim = ps.inner_product_dimension() threshold = ps.threshold() abs_e3_dist = dist_absolute(ps.e3_distribution()) def crunch(cutoff): e3_cutoff = sorted(abs_e3_dist)[cutoff] t = threshold - e3_cutoff f = partial(queries, dim=dim, t=t, alpha=alpha) result = expectation(query_l2_dist, f) return result cutoff = sorted(abs_e3_dist).index(min(top_quantile(abs_e3_dist, 100))) result = crunch(cutoff) e3_cutoff = sorted(abs_e3_dist)[cutoff] if optimize_e3: # Optimize e3_cutoff step = 16 #XXX: arbitrary while step > 0: decreasing = True while (len(abs_e3_dist) + cutoff - step > 0) and decreasing: candidate = crunch(cutoff - step) decreasing = candidate < result if decreasing: result = candidate e3_cutoff = sorted(abs_e3_dist)[cutoff - step] cutoff -= step step //= 2 result *= 2 # Account for absolute value bars return -log2(result), e3_cutoff
def do(label, lgsq, lgeq): with open(jar(label), "rb") as brine: ps = pickle.load(brine) progress(label, "starting s/{}/e/{}".format(lgsq, lgeq)) f = tail_probability(ps.one_shot_s_quantile(lgsq), ps.threshold()) p(label, "s/{}/e/{}/cost".format(lgsq, lgeq), float(-log2(f))) progress(label, "done s/{}/e/{}".format(lgsq, lgeq))
def calc_gain(lNums, p_iSum=None): if p_iSum is None: p_iSum = sum(lNums) fSum = float(p_iSum) fResult = 0 for num in lNums: value = (num / fSum) fResult += -value * log2(value) return fResult
def DivOp(op, x, y): # (* x = x op y *) global RH e = log2(y.a) # note: shadows math.e if op == ORS.div: if (x.mode == ORB.Const) and (y.mode == ORB.Const): if y.a > 0: x.a = x.a / y.a else: ORS.Mark("bad divisor") elif (y.mode == ORB.Const) and (y.a >= 2) and (e == 1): load(x) Put1(Asr, x.r, x.r, e) elif y.mode == ORB.Const: if y.a > 0: load(x) Put1a(Div, x.r, x.r, y.a) else: ORS.Mark("bad divisor") else: load(y) if check: Trap(LE, 6) load(x) Put0(Div, RH - 2, x.r, y.r) RH -= 1 x.r = RH - 1 else: # (*op == ORS.mod*) if (x.mode == ORB.Const) and (y.mode == ORB.Const): if y.a > 0: x.a = x.a % y.a else: ORS.Mark("bad modulus") elif (y.mode == ORB.Const) and (y.a >= 2) and (e == 1): load(x) if e <= 16: Put1(And, x.r, x.r, y.a - 1) else: Put1(Lsl, x.r, x.r, 32 - e) Put1(Ror, x.r, x.r, 32 - e) elif y.mode == ORB.Const: if y.a > 0: load(x) Put1a(Div, x.r, x.r, y.a) Put0(Mov + U, x.r, 0, 0) else: ORS.Mark("bad modulus") else: load(y) if check: Trap(LE, 6) load(x) Put0(Div, RH - 2, x.r, y.r) Put0(Mov + U, RH - 2, 0, 0) RH -= 1 x.r = RH - 1
def DivOp(op, x, y): # (* x = x op y *) global RH e = log2(y.a) # note: shadows math.e if op == ORS.div: if (x.mode == ORB.Const) and (y.mode == ORB.Const): if y.a > 0: x.a = x.a / y.a else: ORS.Mark("bad divisor") elif (y.mode == ORB.Const) and (y.a >= 2) and (e == 1): load(x) Put1(Asr, x.r, x.r, e) elif y.mode == ORB.Const: if y.a > 0: load(x) Put1a(Div, x.r, x.r, y.a) else: ORS.Mark("bad divisor") else: load(y); if check: Trap(LE, 6) load(x) Put0(Div, RH-2, x.r, y.r) RH -= 1 x.r = RH-1 else: # (*op == ORS.mod*) if (x.mode == ORB.Const) and (y.mode == ORB.Const): if y.a > 0: x.a = x.a % y.a else: ORS.Mark("bad modulus") elif (y.mode == ORB.Const) and (y.a >= 2) and (e == 1): load(x); if e <= 16: Put1(And, x.r, x.r, y.a-1) else: Put1(Lsl, x.r, x.r, 32-e) Put1(Ror, x.r, x.r, 32-e) elif y.mode == ORB.Const: if y.a > 0: load(x) Put1a(Div, x.r, x.r, y.a) Put0(Mov+U, x.r, 0, 0) else: ORS.Mark("bad modulus") else: load(y); if check: Trap(LE, 6) load(x) Put0(Div, RH-2, x.r, y.r) Put0(Mov+U, RH-2, 0, 0) RH -= 1 x.r = RH-1
def __init__(self, n, q=None, improper=False): self.n = n if q is None: self.q = int(2**round(0.5 + 3.5 + log2(n))) else: self.q = q self.improper = improper self.cache_dist_1 = None self.cache_dist_2 = None self.cache_dist_3 = None
def run(settings, load_cb=None): global _running _running = True # actual init of the UI is done via this callback, # which is posted to the MessageLoop at the end of this function def do_init(): # create them... resources = Resources(settings, ndbg.get_basedir()) global _mc mw = MainWindow(settings, resources) def run_load_cb(): log2("UI init: running on_load callback") if load_cb: load_cb(_mc) return False # ensure the timeout is a one-time thing def on_ready(*args): log2("UI init: window shown, scheduling load in 200ms") MessageLoop.add_delayed_message(run_load_cb, 200) if load_cb: mw.connect('show', on_ready) settings.set_delayed_save(True) _mc = MainControl(settings, mw) # Go! :) MessageLoop.add_message(do_init) MessageLoop.run() # cleanup _running = False if _mc: _mc.destroy() log2("ui.run done")
def setup(label, ps): progress(label, "starting setup") try: with open(jar(label), "rb") as brine: ps = pickle.load(brine) except IOError: progress(label, "generating distributions") secret_l2_dist = ps.secret_l2_distribution() query_l2_dist = ps.query_l2_distribution() one_shot_dist = ps.one_shot_distribution() f = tail_probability(one_shot_dist, ps.threshold()) p(label, "oneshot", float(-log2(f))) with open(jar(label), "wb") as brine: pickle.dump(ps, brine)
def log_cap(dim, theta): return -0.5 * log2(2 * mp.pi * dim) - log2( mp.cos(theta)) + (dim - 1) * log2(mp.sin(theta))
def on_ready(*args): log2("UI init: window shown, scheduling load in 200ms") MessageLoop.add_delayed_message(run_load_cb, 200)
def run_load_cb(): log2("UI init: running on_load callback") if load_cb: load_cb(_mc) return False # ensure the timeout is a one-time thing
import util if __name__ == '__main__': print(util.log2(1024)) util.test_util()