def protocol(): inpts = setup() in_1 = inpts[0] sb = sal.sort_by(in_1, "sort_by", "a") out = sal.collect(sb, 1) return {in_1}
def protocol(): inpts = setup() in_1 = inpts[0] sorted = cc.sort_by(in_1, 'sorted1', 'a') out = cc.collect(sorted, 1) return {in_1}
def protocol(): inpts = setup() in_1 = inpts[0] sorted = sal.sort_by(in_1, 'sorted1', 'a') out = sal.collect(sorted, 1) return set([in_1])
def protocol(): diagnosis_col = "12" num_diagnosis_cols = 13 left_diagnosis_cols = [ defCol(str(i), "INTEGER", 1) for i in range(num_diagnosis_cols) ] left_diagnosis = cc.create("left_diagnosis", left_diagnosis_cols, {1}) right_diagnosis_cols = [ defCol(str(i), "INTEGER", 1) for i in range(num_diagnosis_cols) ] right_diagnosis = cc.create("right_diagnosis", right_diagnosis_cols, {1}) cohort = cc.concat([left_diagnosis, right_diagnosis], "cohort") counts = cc.aggregate_count(cohort, "counts", [diagnosis_col], "total") cc.sort_by(counts, "expected", "total") return {left_diagnosis, right_diagnosis}
def protocol(): input_columns_left = [ defCol("column_a", "INTEGER", [1]), defCol("column_b", "INTEGER", [1]) ] left = cc.create("left", input_columns_left, {1}) input_columns_right = [ defCol("column_a", "INTEGER", [1]), defCol("column_b", "INTEGER", [1]) ] right = cc.create("right", input_columns_right, {1}) rel = cc.concat([left, right], "rel") filtered = cc.cc_filter(rel, "filtered", "column_b", "==", scalar=1) in_order = cc.sort_by(filtered, "in_order", "column_a") cc.distinct_count(in_order, "expected", "column_a") return {left, right}
def hybrid_agg(in1): shuffled = sal.shuffle(in1, "shuffled") shuffled.out_rel.stored_with = set([1, 2, 3]) shuffled.is_mpc = True persisted = sal._persist(shuffled, "persisted") persisted.out_rel.stored_with = set([1, 2, 3]) persisted.is_mpc = True keys_closed = sal.project(shuffled, "keys_closed", ["b"]) keys_closed.out_rel.stored_with = set([1, 2, 3]) keys_closed.is_mpc = True keys = sal._open(keys_closed, "keys", 1) keys.is_mpc = True indexed = sal.index(keys, "indexed", "rowIndex") indexed.is_mpc = False indexed.out_rel.stored_with = set([1]) sorted_by_key = sal.sort_by(indexed, "sorted_by_key", "b") sorted_by_key.is_mpc = False sorted_by_key.out_rel.stored_with = set([1]) eq_flags = sal._comp_neighs(sorted_by_key, "eq_flags", "b") eq_flags.is_mpc = False eq_flags.out_rel.stored_with = set([1]) # TODO: should be a persist op sorted_by_key_stored = sal.project( sorted_by_key, "sorted_by_key_stored", ["rowIndex", "b"]) sorted_by_key_stored.is_mpc = False sorted_by_key_stored.out_rel.stored_with = set([1]) closed_eq_flags = sal._close(eq_flags, "closed_eq_flags", set([1, 2, 3])) closed_eq_flags.is_mpc = True closed_sorted_by_key = sal._close( sorted_by_key_stored, "closed_sorted_by_key", set([1, 2, 3])) closed_sorted_by_key.is_mpc = True agg = sal.index_aggregate( persisted, "agg", ["b"], "d", "+", "d", closed_eq_flags, closed_sorted_by_key) agg.is_mpc = True sal._open(agg, "ssnopened", 1)
def hybrid_agg(in1): shuffled = sal.shuffle(in1, "shuffled") shuffled.out_rel.storedWith = {1, 2, 3} shuffled.isMPC = True persisted = sal._persist(shuffled, "persisted") persisted.out_rel.storedWith = {1, 2, 3} persisted.isMPC = True keysclosed = sal.project(shuffled, "keysclosed", ["b"]) keysclosed.out_rel.storedWith = {1, 2, 3} keysclosed.isMPC = True keys = sal._open(keysclosed, "keys", 1) keys.isMPC = True indexed = sal.index(keys, "indexed", "rowIndex") indexed.isMPC = False indexed.out_rel.storedWith = {1} sortedByKey = sal.sort_by(indexed, "sortedByKey", "b") sortedByKey.isMPC = False sortedByKey.out_rel.storedWith = {1} eqFlags = sal._comp_neighs(sortedByKey, "eqFlags", "b") eqFlags.isMPC = False eqFlags.out_rel.storedWith = {1} # TODO: should be a persist op sortedByKeyStored = sal.project(sortedByKey, "sortedByKeyStored", ["rowIndex", "b"]) sortedByKeyStored.isMPC = False sortedByKeyStored.out_rel.storedWith = {1} closedEqFlags = sal._close(eqFlags, "closedEqFlags", {1, 2, 3}) closedEqFlags.isMPC = True closedSortedByKey = sal._close(sortedByKeyStored, "closedSortedByKey", {1, 2, 3}) closedSortedByKey.isMPC = True agg = sal.index_aggregate(persisted, "agg", ["b"], "d", "+", "d", closedEqFlags, closedSortedByKey) agg.isMPC = True sal._open(agg, "ssnopened", 1)
def protocol(): pid_col = "8" diagnosis_col = "16" cols_to_skip = 8 num_diagnosis_cols = 13 left_diagnosis_cols = [ defCol(str(i + cols_to_skip), "INTEGER", 1) for i in range(num_diagnosis_cols) ] left_diagnosis = cc.create("left_diagnosis", left_diagnosis_cols, {1}) left_cohort = cc.create("left_cohort", [defCol("pid", "INTEGER", 1)], {1}) left_selected = cc.filter_by(left_diagnosis, "left_selected", pid_col, left_cohort) right_diagnosis_cols = [ defCol(str(i + cols_to_skip), "INTEGER", 2) for i in range(num_diagnosis_cols) ] right_diagnosis = cc.create("right_diagnosis", right_diagnosis_cols, {2}) right_cohort = cc.create("right_cohort", [defCol("pid", "INTEGER", 2)], {2}) right_selected = cc.filter_by(right_diagnosis, "right_selected", pid_col, right_cohort) cohort = cc.concat([left_selected, right_selected], "cohort") counts = cc.aggregate_count(cohort, "counts", [diagnosis_col], "total") cc.collect(cc.sort_by(counts, "actual", "total"), 1) return {left_diagnosis, left_cohort, right_diagnosis, right_cohort}
def protocol(): # define inputs colsInA = [ defCol("a", "INTEGER", [1]), defCol("b", "INTEGER", [1]), ] in1 = sal.create("in1", colsInA, set([1])) in1.isMPC = False proja = sal.project(in1, "proja", ["a", "b"]) proja.isMPC = False proja.out_rel.storedWith = set([1]) # define inputs colsInB = [ defCol("a", "INTEGER", [2]), defCol("b", "INTEGER", [2]), ] in2 = sal.create("in2", colsInB, set([2])) in2.isMPC = False projb = sal.project(in2, "projb", ["a", "b"]) projb.isMPC = False projb.out_rel.storedWith = set([2]) # define inputs colsInC = [ defCol("a", "INTEGER", [3]), defCol("b", "INTEGER", [3]), ] in3 = sal.create("in3", colsInC, set([3])) in3.isMPC = False projc = sal.project(in3, "projc", ["a", "b"]) projc.isMPC = False projc.out_rel.storedWith = set([3]) clA = sal._close(proja, "clA", set([1, 2, 3])) clA.isMPC = True clB = sal._close(projb, "clB", set([1, 2, 3])) clB.isMPC = True clC = sal._close(projc, "clC", set([1, 2, 3])) clC.isMPC = True comb = sal.concat([clA, clB, clC], "comb") comb.out_rel.storedWith = set([1, 2, 3]) comb.isMPC = True shuffled = sal.shuffle(comb, "shuffled") shuffled.out_rel.storedWith = set([1, 2, 3]) shuffled.isMPC = True persisted = sal._persist(shuffled, "persisted") persisted.out_rel.storedWith = set([1, 2, 3]) persisted.isMPC = True keysclosed = sal.project(shuffled, "keysclosed", ["a"]) keysclosed.out_rel.storedWith = set([1, 2, 3]) keysclosed.isMPC = True keys = sal._open(keysclosed, "keys", 1) keys.isMPC = True indexed = sal.index(keys, "indexed", "rowIndex") indexed.isMPC = False indexed.out_rel.storedWith = set([1]) sortedByKey = sal.sort_by(indexed, "sortedByKey", "a") sortedByKey.isMPC = False sortedByKey.out_rel.storedWith = set([1]) eqFlags = sal._comp_neighs(sortedByKey, "eqFlags", "a") eqFlags.isMPC = False eqFlags.out_rel.storedWith = set([1]) # TODO: hack to get keys stored # need to fix later! sortedByKey = sal.project(sortedByKey, "sortedByKey", ["rowIndex", "a"]) sortedByKey.isMPC = False sortedByKey.out_rel.storedWith = set([1]) closedEqFlags = sal._close(eqFlags, "closedEqFlags", set([1, 2, 3])) closedEqFlags.isMPC = True closedSortedByKey = sal._close(sortedByKey, "closedSortedByKey", set([1, 2, 3])) closedSortedByKey.isMPC = True agg = sal.index_aggregate(persisted, "agg", ["a"], "b", "+", "b", closedEqFlags, closedSortedByKey) agg.out_rel.storedWith = set([1, 2, 3]) agg.isMPC = True sal._open(agg, "opened", 1) # create condag return set([in1, in2, in3])