From 0ce03b48a04a7766f8694b1de8a88073542dcc20 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 15:17:42 +0000 Subject: [PATCH 01/12] make sets iterable --- py/objset.c | 39 ++++++++++++++++++++++++++++++++++ tests/basics/tests/set_iter.py | 5 +++++ 2 files changed, 44 insertions(+) create mode 100644 tests/basics/tests/set_iter.py diff --git a/py/objset.c b/py/objset.c index 67dab11dfb..5606c47516 100644 --- a/py/objset.c +++ b/py/objset.c @@ -15,6 +15,14 @@ typedef struct _mp_obj_set_t { mp_set_t set; } mp_obj_set_t; +typedef struct _mp_obj_set_it_t { + mp_obj_base_t base; + mp_obj_set_t *set; + machine_uint_t cur; +} mp_obj_set_it_t; + +static mp_obj_t set_it_iternext(mp_obj_t self_in); + void set_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in) { mp_obj_set_t *self = self_in; bool first = true; @@ -54,11 +62,42 @@ static mp_obj_t set_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args) } } +const mp_obj_type_t set_it_type = { + { &mp_const_type }, + "set_iterator", + .iternext = set_it_iternext, +}; + +static mp_obj_t set_it_iternext(mp_obj_t self_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_it_type)); + mp_obj_set_it_t *self = self_in; + machine_uint_t max = self->set->set.alloc; + mp_obj_t *table = self->set->set.table; + + for (machine_uint_t i = self->cur; i < max; i++) { + if (table[i] != NULL) { + self->cur = i + 1; + return table[i]; + } + } + + return mp_const_stop_iteration; +} + +static mp_obj_t set_getiter(mp_obj_t set_in) { + mp_obj_set_it_t *o = m_new_obj(mp_obj_set_it_t); + o->base.type = &set_it_type; + o->set = (mp_obj_set_t *)set_in; + o->cur = 0; + return o; +} + const mp_obj_type_t set_type = { { &mp_const_type }, "set", .print = set_print, .make_new = set_make_new, + .getiter = set_getiter, }; mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items) { diff --git a/tests/basics/tests/set_iter.py b/tests/basics/tests/set_iter.py new file mode 100644 index 0000000000..2960177303 --- /dev/null +++ b/tests/basics/tests/set_iter.py @@ -0,0 +1,5 @@ +s = {1, 2, 3, 4} +l = list(s) +l.sort() +print(l) + From 19b14d3d8ae229f17f8b63825f96220db37e3770 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 15:29:11 +0000 Subject: [PATCH 02/12] Implemented set.add --- py/objset.c | 23 +++++++++++++++++++++++ tests/basics/tests/set_add.py | 5 +++++ 2 files changed, 28 insertions(+) create mode 100644 tests/basics/tests/set_add.py diff --git a/py/objset.c b/py/objset.c index 5606c47516..a74d1eb6a3 100644 --- a/py/objset.c +++ b/py/objset.c @@ -92,12 +92,35 @@ static mp_obj_t set_getiter(mp_obj_t set_in) { return o; } + +/******************************************************************************/ +/* set methods */ + +static mp_obj_t set_add(mp_obj_t self_in, mp_obj_t item) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + mp_set_lookup(&self->set, item, true); + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_add_obj, set_add); + + +/******************************************************************************/ +/* set constructors & public C API */ + + +static const mp_method_t set_type_methods[] = { + { "add", &set_add_obj }, + { NULL, NULL }, // end-of-list sentinel +}; + const mp_obj_type_t set_type = { { &mp_const_type }, "set", .print = set_print, .make_new = set_make_new, .getiter = set_getiter, + .methods = set_type_methods, }; mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items) { diff --git a/tests/basics/tests/set_add.py b/tests/basics/tests/set_add.py new file mode 100644 index 0000000000..f2a372f307 --- /dev/null +++ b/tests/basics/tests/set_add.py @@ -0,0 +1,5 @@ +s = {1, 2, 3, 4} +print(s.add(5)) +l = list(s) +l.sort() +print(l) From 1d7fb2f21be8dd6f95e5889442a3735464c94dfb Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 15:44:26 +0000 Subject: [PATCH 03/12] Implemented set.clear --- py/map.c | 44 ++++++++++++++++++++++++--------- py/map.h | 1 + py/objset.c | 11 +++++++++ tests/basics/tests/set_clear.py | 3 +++ 4 files changed, 47 insertions(+), 12 deletions(-) create mode 100644 tests/basics/tests/set_clear.py diff --git a/py/map.c b/py/map.c index e44cf33d26..524b6c8a5b 100644 --- a/py/map.c +++ b/py/map.c @@ -132,9 +132,29 @@ void mp_set_init(mp_set_t *set, int n) { set->table = m_new0(mp_obj_t, set->alloc); } +static void mp_set_rehash(mp_set_t *set) { + int old_alloc = set->alloc; + mp_obj_t *old_table = set->table; + set->alloc = get_doubling_prime_greater_or_equal_to(set->alloc + 1); + set->used = 0; + set->table = m_new0(mp_obj_t, set->alloc); + for (int i = 0; i < old_alloc; i++) { + if (old_table[i] != NULL) { + mp_set_lookup(set, old_table[i], true); + } + } + m_del(mp_obj_t, old_table, old_alloc); +} + mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) { int hash = mp_obj_hash(index); - assert(set->alloc); /* FIXME: if alloc is ever 0 when doing a lookup, this'll fail: */ + if (set->alloc == 0) { + if (add_if_not_found) { + mp_set_rehash(set); + } else { + return NULL; + } + } int pos = hash % set->alloc; for (;;) { mp_obj_t elem = set->table[pos]; @@ -143,17 +163,7 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) { if (add_if_not_found) { if (set->used + 1 >= set->alloc) { // not enough room in table, rehash it - int old_alloc = set->alloc; - mp_obj_t *old_table = set->table; - set->alloc = get_doubling_prime_greater_or_equal_to(set->alloc + 1); - set->used = 0; - set->table = m_new(mp_obj_t, set->alloc); - for (int i = 0; i < old_alloc; i++) { - if (old_table[i] != NULL) { - mp_set_lookup(set, old_table[i], true); - } - } - m_del(mp_obj_t, old_table, old_alloc); + mp_set_rehash(set); // restart the search for the new element pos = hash % set->alloc; } else { @@ -173,3 +183,13 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) { } } } + +void mp_set_clear(mp_set_t *set) { + set->used = 0; + machine_uint_t a = set->alloc; + set->alloc = 0; + set->table = m_renew(mp_obj_t, set->table, a, set->alloc); + for (uint i=0; ialloc; i++) { + set->table[i] = NULL; + } +} diff --git a/py/map.h b/py/map.h index 5ce4e835b6..ba6bf9e6ee 100644 --- a/py/map.h +++ b/py/map.h @@ -32,3 +32,4 @@ void mp_map_clear(mp_map_t *map); void mp_set_init(mp_set_t *set, int n); mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found); +void mp_set_clear(mp_set_t *set); diff --git a/py/objset.c b/py/objset.c index a74d1eb6a3..8bd006a761 100644 --- a/py/objset.c +++ b/py/objset.c @@ -104,6 +104,16 @@ static mp_obj_t set_add(mp_obj_t self_in, mp_obj_t item) { } static MP_DEFINE_CONST_FUN_OBJ_2(set_add_obj, set_add); +static mp_obj_t set_clear(mp_obj_t self_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + + mp_set_clear(&self->set); + + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_1(set_clear_obj, set_clear); + /******************************************************************************/ /* set constructors & public C API */ @@ -111,6 +121,7 @@ static MP_DEFINE_CONST_FUN_OBJ_2(set_add_obj, set_add); static const mp_method_t set_type_methods[] = { { "add", &set_add_obj }, + { "clear", &set_clear_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_clear.py b/tests/basics/tests/set_clear.py new file mode 100644 index 0000000000..6fda93f0fb --- /dev/null +++ b/tests/basics/tests/set_clear.py @@ -0,0 +1,3 @@ +s = {1, 2, 3, 4} +print(s.clear()) +print(list(s)) From 3b0bd87906eb301ebfe6588773ebfe07b0509ad8 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 15:56:25 +0000 Subject: [PATCH 04/12] Implemented set.copy --- py/objset.c | 16 ++++++++++++++++ tests/basics/tests/set_copy.py | 8 ++++++++ 2 files changed, 24 insertions(+) create mode 100644 tests/basics/tests/set_copy.py diff --git a/py/objset.c b/py/objset.c index 8bd006a761..40f19c85d3 100644 --- a/py/objset.c +++ b/py/objset.c @@ -1,5 +1,6 @@ #include #include +#include #include #include "nlr.h" @@ -114,6 +115,20 @@ static mp_obj_t set_clear(mp_obj_t self_in) { } static MP_DEFINE_CONST_FUN_OBJ_1(set_clear_obj, set_clear); +static mp_obj_t set_copy(mp_obj_t self_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + + mp_obj_set_t *other = m_new_obj(mp_obj_set_t); + other->base.type = &set_type; + mp_set_init(&other->set, self->set.alloc); + other->set.used = self->set.used; + memcpy(other->set.table, self->set.table, self->set.alloc * sizeof(mp_obj_t)); + + return other; +} +static MP_DEFINE_CONST_FUN_OBJ_1(set_copy_obj, set_copy); + /******************************************************************************/ /* set constructors & public C API */ @@ -122,6 +137,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(set_clear_obj, set_clear); static const mp_method_t set_type_methods[] = { { "add", &set_add_obj }, { "clear", &set_clear_obj }, + { "copy", &set_copy_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_copy.py b/tests/basics/tests/set_copy.py new file mode 100644 index 0000000000..2ea308b0db --- /dev/null +++ b/tests/basics/tests/set_copy.py @@ -0,0 +1,8 @@ +s = {1, 2, 3, 4} +t = s.copy() +s.add(5) +t.add(7) +for i in s, t: + l = list(i) + l.sort() + print(l) From 2a24172cdcdb5286c48afd6cf726548848e4840f Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 16:39:39 +0000 Subject: [PATCH 05/12] Implemented set.discard --- py/map.c | 11 ++++++++--- py/map.h | 2 +- py/objset.c | 14 +++++++++++--- tests/basics/tests/set_discard.py | 3 +++ 4 files changed, 23 insertions(+), 7 deletions(-) create mode 100644 tests/basics/tests/set_discard.py diff --git a/py/map.c b/py/map.c index 524b6c8a5b..3dee058cd3 100644 --- a/py/map.c +++ b/py/map.c @@ -146,10 +146,10 @@ static void mp_set_rehash(mp_set_t *set) { m_del(mp_obj_t, old_table, old_alloc); } -mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) { +mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, mp_map_lookup_kind_t lookup_kind) { int hash = mp_obj_hash(index); if (set->alloc == 0) { - if (add_if_not_found) { + if (lookup_kind == MP_MAP_LOOKUP_ADD_IF_NOT_FOUND) { mp_set_rehash(set); } else { return NULL; @@ -160,7 +160,7 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) { mp_obj_t elem = set->table[pos]; if (elem == MP_OBJ_NULL) { // not in table - if (add_if_not_found) { + if (lookup_kind == MP_MAP_LOOKUP_ADD_IF_NOT_FOUND) { if (set->used + 1 >= set->alloc) { // not enough room in table, rehash it mp_set_rehash(set); @@ -176,6 +176,11 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) { } } else if (mp_obj_equal(elem, index)) { // found it + if (lookup_kind == MP_MAP_LOOKUP_REMOVE_IF_FOUND) { + set->used--; + set->table[pos] = NULL; + return elem; + } return elem; } else { // not yet found, keep searching in this table diff --git a/py/map.h b/py/map.h index ba6bf9e6ee..5b00e53f83 100644 --- a/py/map.h +++ b/py/map.h @@ -31,5 +31,5 @@ mp_map_elem_t* mp_map_lookup(mp_map_t *map, mp_obj_t index, mp_map_lookup_kind_t void mp_map_clear(mp_map_t *map); void mp_set_init(mp_set_t *set, int n); -mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found); +mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, mp_map_lookup_kind_t lookup_kind); void mp_set_clear(mp_set_t *set); diff --git a/py/objset.c b/py/objset.c index 40f19c85d3..363f7d365d 100644 --- a/py/objset.c +++ b/py/objset.c @@ -100,7 +100,7 @@ static mp_obj_t set_getiter(mp_obj_t set_in) { static mp_obj_t set_add(mp_obj_t self_in, mp_obj_t item) { assert(MP_OBJ_IS_TYPE(self_in, &set_type)); mp_obj_set_t *self = self_in; - mp_set_lookup(&self->set, item, true); + mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND); return mp_const_none; } static MP_DEFINE_CONST_FUN_OBJ_2(set_add_obj, set_add); @@ -129,6 +129,13 @@ static mp_obj_t set_copy(mp_obj_t self_in) { } static MP_DEFINE_CONST_FUN_OBJ_1(set_copy_obj, set_copy); +static mp_obj_t set_discard(mp_obj_t self_in, mp_obj_t item) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_REMOVE_IF_FOUND); + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_discard_obj, set_discard); /******************************************************************************/ /* set constructors & public C API */ @@ -138,6 +145,7 @@ static const mp_method_t set_type_methods[] = { { "add", &set_add_obj }, { "clear", &set_clear_obj }, { "copy", &set_copy_obj }, + { "discard", &set_discard_obj }, { NULL, NULL }, // end-of-list sentinel }; @@ -155,7 +163,7 @@ mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items) { o->base.type = &set_type; mp_set_init(&o->set, n_args); for (int i = 0; i < n_args; i++) { - mp_set_lookup(&o->set, items[i], true); + mp_set_lookup(&o->set, items[i], MP_MAP_LOOKUP_ADD_IF_NOT_FOUND); } return o; } @@ -163,5 +171,5 @@ mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items) { void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item) { assert(MP_OBJ_IS_TYPE(self_in, &set_type)); mp_obj_set_t *self = self_in; - mp_set_lookup(&self->set, item, true); + mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND); } diff --git a/tests/basics/tests/set_discard.py b/tests/basics/tests/set_discard.py new file mode 100644 index 0000000000..baac26413c --- /dev/null +++ b/tests/basics/tests/set_discard.py @@ -0,0 +1,3 @@ +s = {1, 2} +print(s.discard(1)) +print(list(s)) From 032129f3b595f132046b9f4c6f108f1677aef944 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 17:07:17 +0000 Subject: [PATCH 06/12] Implemented set.difference and set.difference_update --- py/objset.c | 41 ++++++++++++++++++++++++++++ tests/basics/tests/set_difference.py | 21 ++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 tests/basics/tests/set_difference.py diff --git a/py/objset.c b/py/objset.c index 363f7d365d..c6e0dcf137 100644 --- a/py/objset.c +++ b/py/objset.c @@ -137,6 +137,45 @@ static mp_obj_t set_discard(mp_obj_t self_in, mp_obj_t item) { } static MP_DEFINE_CONST_FUN_OBJ_2(set_discard_obj, set_discard); +static mp_obj_t set_diff_int(int n_args, const mp_obj_t *args, bool update) { + assert(n_args > 0); + assert(MP_OBJ_IS_TYPE(args[0], &set_type)); + mp_obj_set_t *self; + if (update) { + self = args[0]; + } else { + self = set_copy(args[0]); + } + + + for (int i = 1; i < n_args; i++) { + mp_obj_t other = args[i]; + if (self == other) { + set_clear(self); + } else { + mp_obj_t iter = rt_getiter(other); + mp_obj_t next; + while ((next = rt_iternext(iter)) != mp_const_stop_iteration) { + set_discard(self, next); + } + } + } + + return self; +} + +static mp_obj_t set_diff(int n_args, const mp_obj_t *args) { + return set_diff_int(n_args, args, false); +} +static MP_DEFINE_CONST_FUN_OBJ_VAR(set_diff_obj, 1, set_diff); + +static mp_obj_t set_diff_update(int n_args, const mp_obj_t *args) { + set_diff_int(n_args, args, true); + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR(set_diff_update_obj, 1, set_diff_update); + + /******************************************************************************/ /* set constructors & public C API */ @@ -146,6 +185,8 @@ static const mp_method_t set_type_methods[] = { { "clear", &set_clear_obj }, { "copy", &set_copy_obj }, { "discard", &set_discard_obj }, + { "difference", &set_diff_obj }, + { "difference_update", &set_diff_update_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_difference.py b/tests/basics/tests/set_difference.py new file mode 100644 index 0000000000..26976116f3 --- /dev/null +++ b/tests/basics/tests/set_difference.py @@ -0,0 +1,21 @@ +def report(s): + l = list(s) + l.sort() + print(l) + +l = [1, 2, 3, 4] +s = set(l) +outs = [s.difference(), + s.difference({1}), + s.difference({1}, [1, 2]), + s.difference({1}, {1, 2}, {2, 3})] +for out in outs: + report(out) + +s = set(l) +print(s.difference_update()) +report(s) +print(s.difference_update({1})) +report(s) +print(s.difference_update({1}, [2])) +report(s) From f1ae6b48fbc88d4acdbe1136f56c136f8e1b2991 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 17:54:03 +0000 Subject: [PATCH 07/12] Implemented set.intersection and set.intersection_update --- py/objset.c | 39 ++++++++++++++++++++++++++ tests/basics/tests/set_intersection.py | 12 ++++++++ 2 files changed, 51 insertions(+) create mode 100644 tests/basics/tests/set_intersection.py diff --git a/py/objset.c b/py/objset.c index c6e0dcf137..144bb6daa8 100644 --- a/py/objset.c +++ b/py/objset.c @@ -175,6 +175,43 @@ static mp_obj_t set_diff_update(int n_args, const mp_obj_t *args) { } static MP_DEFINE_CONST_FUN_OBJ_VAR(set_diff_update_obj, 1, set_diff_update); +static mp_obj_t set_intersect_int(mp_obj_t self_in, mp_obj_t other, bool update) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + if (self_in == other) { + return update ? mp_const_none : set_copy(self_in); + } + + mp_obj_set_t *self = self_in; + mp_obj_set_t *out = mp_obj_new_set(0, NULL); + + mp_obj_t iter = rt_getiter(other); + mp_obj_t next; + while ((next = rt_iternext(iter)) != mp_const_stop_iteration) { + if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) { + set_add(out, next); + } + } + + if (update) { + m_del(mp_obj_t, self->set.table, self->set.alloc); + self->set.alloc = out->set.alloc; + self->set.used = out->set.used; + self->set.table = out->set.table; + } + + return update ? mp_const_none : out; +} + +static mp_obj_t set_intersect(mp_obj_t self_in, mp_obj_t other) { + return set_intersect_int(self_in, other, false); +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_intersect_obj, set_intersect); + +static mp_obj_t set_intersect_update(mp_obj_t self_in, mp_obj_t other) { + return set_intersect_int(self_in, other, true); +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_intersect_update_obj, set_intersect_update); + /******************************************************************************/ /* set constructors & public C API */ @@ -187,6 +224,8 @@ static const mp_method_t set_type_methods[] = { { "discard", &set_discard_obj }, { "difference", &set_diff_obj }, { "difference_update", &set_diff_update_obj }, + { "intersection", &set_intersect_obj }, + { "intersection_update", &set_intersect_update_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_intersection.py b/tests/basics/tests/set_intersection.py new file mode 100644 index 0000000000..6f3dfc7414 --- /dev/null +++ b/tests/basics/tests/set_intersection.py @@ -0,0 +1,12 @@ +def report(s): + l = list(s) + l.sort() + print(l) + +s = {1, 2, 3, 4} +report(s) +report(s.intersection({1, 3})) +report(s.intersection([3, 4])) + +print(s.intersection_update([1])) +report(s) From 4a08067c0c9c8417525e89eef4c3693cdc05b954 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 18:03:21 +0000 Subject: [PATCH 08/12] Implemented set.isdisjoint --- py/objset.c | 16 ++++++++++++++++ tests/basics/tests/set_isdisjoint.py | 6 ++++++ 2 files changed, 22 insertions(+) create mode 100644 tests/basics/tests/set_isdisjoint.py diff --git a/py/objset.c b/py/objset.c index 144bb6daa8..afc426b3b0 100644 --- a/py/objset.c +++ b/py/objset.c @@ -212,6 +212,21 @@ static mp_obj_t set_intersect_update(mp_obj_t self_in, mp_obj_t other) { } static MP_DEFINE_CONST_FUN_OBJ_2(set_intersect_update_obj, set_intersect_update); +static mp_obj_t set_isdisjoint(mp_obj_t self_in, mp_obj_t other) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + + mp_obj_t iter = rt_getiter(other); + mp_obj_t next; + while ((next = rt_iternext(iter)) != mp_const_stop_iteration) { + if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) { + return mp_const_false; + } + } + return mp_const_true; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_isdisjoint_obj, set_isdisjoint); + /******************************************************************************/ /* set constructors & public C API */ @@ -226,6 +241,7 @@ static const mp_method_t set_type_methods[] = { { "difference_update", &set_diff_update_obj }, { "intersection", &set_intersect_obj }, { "intersection_update", &set_intersect_update_obj }, + { "isdisjoint", &set_isdisjoint_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_isdisjoint.py b/tests/basics/tests/set_isdisjoint.py new file mode 100644 index 0000000000..7fb7e769bb --- /dev/null +++ b/tests/basics/tests/set_isdisjoint.py @@ -0,0 +1,6 @@ +s = {1, 2, 3, 4} +print(s.isdisjoint({1})) +print(s.isdisjoint([2])) +print(s.isdisjoint([])) +print(s.isdisjoint({7,8,9,10})) +print(s.isdisjoint([7,8,9,1])) From ae00d334c6222fa9716135967a7c512b03f08191 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 18:23:36 +0000 Subject: [PATCH 09/12] Implemented set.remove --- py/map.c | 22 +++++++--- py/map.h | 7 +-- py/objset.c | 68 ++++++++++++++++++++++++++++++ tests/basics/tests/set_isfooset.py | 5 +++ tests/basics/tests/set_pop.py | 9 ++++ tests/basics/tests/set_remove.py | 9 ++++ 6 files changed, 110 insertions(+), 10 deletions(-) create mode 100644 tests/basics/tests/set_isfooset.py create mode 100644 tests/basics/tests/set_pop.py create mode 100644 tests/basics/tests/set_remove.py diff --git a/py/map.c b/py/map.c index 3dee058cd3..1ce763ab0e 100644 --- a/py/map.c +++ b/py/map.c @@ -147,20 +147,27 @@ static void mp_set_rehash(mp_set_t *set) { } mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, mp_map_lookup_kind_t lookup_kind) { - int hash = mp_obj_hash(index); + int hash; + int pos; if (set->alloc == 0) { - if (lookup_kind == MP_MAP_LOOKUP_ADD_IF_NOT_FOUND) { + if (lookup_kind & MP_MAP_LOOKUP_ADD_IF_NOT_FOUND) { mp_set_rehash(set); } else { return NULL; } } - int pos = hash % set->alloc; + if (lookup_kind & MP_MAP_LOOKUP_FIRST) { + hash = 0; + pos = 0; + } else { + hash = mp_obj_hash(index);; + pos = hash % set->alloc; + } for (;;) { mp_obj_t elem = set->table[pos]; if (elem == MP_OBJ_NULL) { // not in table - if (lookup_kind == MP_MAP_LOOKUP_ADD_IF_NOT_FOUND) { + if (lookup_kind & MP_MAP_LOOKUP_ADD_IF_NOT_FOUND) { if (set->used + 1 >= set->alloc) { // not enough room in table, rehash it mp_set_rehash(set); @@ -171,15 +178,16 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, mp_map_lookup_kind_t looku set->table[pos] = index; return index; } + } else if (lookup_kind & MP_MAP_LOOKUP_FIRST) { + pos++; } else { return MP_OBJ_NULL; } - } else if (mp_obj_equal(elem, index)) { + } else if (lookup_kind & MP_MAP_LOOKUP_FIRST || mp_obj_equal(elem, index)) { // found it - if (lookup_kind == MP_MAP_LOOKUP_REMOVE_IF_FOUND) { + if (lookup_kind & MP_MAP_LOOKUP_REMOVE_IF_FOUND) { set->used--; set->table[pos] = NULL; - return elem; } return elem; } else { diff --git a/py/map.h b/py/map.h index 5b00e53f83..2db0ac3ebc 100644 --- a/py/map.h +++ b/py/map.h @@ -19,9 +19,10 @@ typedef struct _mp_set_t { } mp_set_t; typedef enum _mp_map_lookup_kind_t { - MP_MAP_LOOKUP, - MP_MAP_LOOKUP_ADD_IF_NOT_FOUND, - MP_MAP_LOOKUP_REMOVE_IF_FOUND, + MP_MAP_LOOKUP, // 0 + MP_MAP_LOOKUP_ADD_IF_NOT_FOUND, // 1 + MP_MAP_LOOKUP_REMOVE_IF_FOUND, // 2 + MP_MAP_LOOKUP_FIRST = 4, } mp_map_lookup_kind_t; int get_doubling_prime_greater_or_equal_to(int x); diff --git a/py/objset.c b/py/objset.c index afc426b3b0..75bc7efb99 100644 --- a/py/objset.c +++ b/py/objset.c @@ -227,6 +227,70 @@ static mp_obj_t set_isdisjoint(mp_obj_t self_in, mp_obj_t other) { } static MP_DEFINE_CONST_FUN_OBJ_2(set_isdisjoint_obj, set_isdisjoint); +static mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) { + mp_obj_set_t *self; + bool cleanup_self = false; + if (MP_OBJ_IS_TYPE(self_in, &set_type)) { + self = self_in; + } else { + self = set_make_new(NULL, 1, &self_in); + cleanup_self = true; + } + + mp_obj_set_t *other; + bool cleanup_other = false; + if (MP_OBJ_IS_TYPE(other_in, &set_type)) { + other = other_in; + } else { + other = set_make_new(NULL, 1, &other_in); + cleanup_other = true; + } + mp_obj_t iter = set_getiter(self); + mp_obj_t next; + mp_obj_t out = mp_const_true; + while ((next = set_it_iternext(iter)) != mp_const_stop_iteration) { + if (!mp_set_lookup(&other->set, next, MP_MAP_LOOKUP)) { + out = mp_const_false; + break; + } + } + if (cleanup_self) { + set_clear(self); + } + if (cleanup_other) { + set_clear(other); + } + return out; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_issubset_obj, set_issubset); + +static mp_obj_t set_issuperset(mp_obj_t self_in, mp_obj_t other_in) { + return set_issubset(other_in, self_in); +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_issuperset_obj, set_issuperset); + +static mp_obj_t set_pop(mp_obj_t self_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + + if (self->set.used == 0) { + nlr_jump(mp_obj_new_exception_msg(MP_QSTR_KeyError, "pop from an empty set")); + } + mp_obj_t obj = mp_set_lookup(&self->set, NULL, + MP_MAP_LOOKUP_REMOVE_IF_FOUND | MP_MAP_LOOKUP_FIRST); + return obj; +} +static MP_DEFINE_CONST_FUN_OBJ_1(set_pop_obj, set_pop); + +static mp_obj_t set_remove(mp_obj_t self_in, mp_obj_t item) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + if (mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_REMOVE_IF_FOUND) == MP_OBJ_NULL) { + nlr_jump(mp_obj_new_exception(MP_QSTR_KeyError)); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_remove_obj, set_remove); /******************************************************************************/ /* set constructors & public C API */ @@ -242,6 +306,10 @@ static const mp_method_t set_type_methods[] = { { "intersection", &set_intersect_obj }, { "intersection_update", &set_intersect_update_obj }, { "isdisjoint", &set_isdisjoint_obj }, + { "issubset", &set_issubset_obj }, + { "issuperset", &set_issuperset_obj }, + { "pop", &set_pop_obj }, + { "remove", &set_remove_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_isfooset.py b/tests/basics/tests/set_isfooset.py new file mode 100644 index 0000000000..ce7952cd2c --- /dev/null +++ b/tests/basics/tests/set_isfooset.py @@ -0,0 +1,5 @@ +sets = [set(), {1}, {1, 2, 3}, {3, 4, 5}, {5, 6, 7}] +for i in sets: + for j in sets: + print(i.issubset(j)) + print(i.issuperset(j)) diff --git a/tests/basics/tests/set_pop.py b/tests/basics/tests/set_pop.py new file mode 100644 index 0000000000..0cd478ce25 --- /dev/null +++ b/tests/basics/tests/set_pop.py @@ -0,0 +1,9 @@ +s = {1} +print(s.pop()) +try: + print(s.pop(), "!!!") +except KeyError: + pass +else: + print("Failed to raise KeyError") + diff --git a/tests/basics/tests/set_remove.py b/tests/basics/tests/set_remove.py new file mode 100644 index 0000000000..208ab137f3 --- /dev/null +++ b/tests/basics/tests/set_remove.py @@ -0,0 +1,9 @@ +s = {1} +print(s.remove(1)) +print(list(s)) +try: + print(s.remove(1), "!!!") +except KeyError: + pass +else: + print("failed to raise KeyError") From 0de386bffec8acddcbe8c15913396035ea0b6405 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 19:39:48 +0000 Subject: [PATCH 10/12] Implemented set.update --- py/objset.c | 54 +++++++++++++++++++ .../basics/tests/set_symmetric_difference.py | 7 +++ tests/basics/tests/set_union.py | 1 + tests/basics/tests/set_update.py | 12 +++++ 4 files changed, 74 insertions(+) create mode 100644 tests/basics/tests/set_symmetric_difference.py create mode 100644 tests/basics/tests/set_union.py create mode 100644 tests/basics/tests/set_update.py diff --git a/py/objset.c b/py/objset.c index 75bc7efb99..27cc91e4f8 100644 --- a/py/objset.c +++ b/py/objset.c @@ -292,6 +292,56 @@ static mp_obj_t set_remove(mp_obj_t self_in, mp_obj_t item) { } static MP_DEFINE_CONST_FUN_OBJ_2(set_remove_obj, set_remove); +static mp_obj_t set_symmetric_difference_update(mp_obj_t self_in, mp_obj_t other_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + mp_obj_t iter = rt_getiter(other_in); + mp_obj_t next; + while ((next = rt_iternext(iter)) != mp_const_stop_iteration) { + mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_REMOVE_IF_FOUND | MP_MAP_LOOKUP_ADD_IF_NOT_FOUND); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_symmetric_difference_update_obj, set_symmetric_difference_update); + +static mp_obj_t set_symmetric_difference(mp_obj_t self_in, mp_obj_t other_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + self_in = set_copy(self_in); + set_symmetric_difference_update(self_in, other_in); + return self_in; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_symmetric_difference_obj, set_symmetric_difference); + +static void set_update_int(mp_obj_set_t *self, mp_obj_t other_in) { + mp_obj_t iter = rt_getiter(other_in); + mp_obj_t next; + while ((next = rt_iternext(iter)) != mp_const_stop_iteration) { + mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND); + } +} + +static mp_obj_t set_update(int n_args, const mp_obj_t *args) { + assert(n_args > 0); + assert(MP_OBJ_IS_TYPE(args[0], &set_type)); + + for (int i = 1; i < n_args; i++) { + set_update_int(args[0], args[i]); + } + + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR(set_update_obj, 1, set_update); + +static mp_obj_t set_union(mp_obj_t self_in, mp_obj_t other_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = set_copy(self_in); + set_update_int(self, other_in); + return self; +} +static MP_DEFINE_CONST_FUN_OBJ_2(set_union_obj, set_union); + + + /******************************************************************************/ /* set constructors & public C API */ @@ -310,6 +360,10 @@ static const mp_method_t set_type_methods[] = { { "issuperset", &set_issuperset_obj }, { "pop", &set_pop_obj }, { "remove", &set_remove_obj }, + { "symmetric_difference", &set_symmetric_difference_obj }, + { "symmetric_difference_update", &set_symmetric_difference_update_obj }, + { "union", &set_union_obj }, + { "update", &set_update_obj }, { NULL, NULL }, // end-of-list sentinel }; diff --git a/tests/basics/tests/set_symmetric_difference.py b/tests/basics/tests/set_symmetric_difference.py new file mode 100644 index 0000000000..acf298385a --- /dev/null +++ b/tests/basics/tests/set_symmetric_difference.py @@ -0,0 +1,7 @@ +print({1,2}.symmetric_difference({2,3})) +print({1,2}.symmetric_difference([2,3])) +s = {1,2} +print(s.symmetric_difference_update({2,3})) +l = list(s) +l.sort() +print(l) diff --git a/tests/basics/tests/set_union.py b/tests/basics/tests/set_union.py new file mode 100644 index 0000000000..2adcc972c0 --- /dev/null +++ b/tests/basics/tests/set_union.py @@ -0,0 +1 @@ +print({1}.union({2})) diff --git a/tests/basics/tests/set_update.py b/tests/basics/tests/set_update.py new file mode 100644 index 0000000000..78cd763560 --- /dev/null +++ b/tests/basics/tests/set_update.py @@ -0,0 +1,12 @@ +def report(s): + l = list(s) + l.sort() + print(l) + +s = {1} +s.update() +report(s) +s.update([2]) +report(s) +s.update([1,3], [2,2,4]) +report(s) From be790f94d5c66b96aa99b09a83639507f037f0a3 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 23:09:10 +0000 Subject: [PATCH 11/12] Implemented set binary ops. --- py/objset.c | 86 +++++++++++++++++++++++++++++---- tests/basics/tests/set_binop.py | 29 +++++++++++ 2 files changed, 105 insertions(+), 10 deletions(-) create mode 100644 tests/basics/tests/set_binop.py diff --git a/py/objset.c b/py/objset.c index 27cc91e4f8..2ed2abb611 100644 --- a/py/objset.c +++ b/py/objset.c @@ -9,6 +9,7 @@ #include "mpqstr.h" #include "obj.h" #include "runtime.h" +#include "runtime0.h" #include "map.h" typedef struct _mp_obj_set_t { @@ -227,7 +228,7 @@ static mp_obj_t set_isdisjoint(mp_obj_t self_in, mp_obj_t other) { } static MP_DEFINE_CONST_FUN_OBJ_2(set_isdisjoint_obj, set_isdisjoint); -static mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) { +static mp_obj_t set_issubset_internal(mp_obj_t self_in, mp_obj_t other_in, bool proper) { mp_obj_set_t *self; bool cleanup_self = false; if (MP_OBJ_IS_TYPE(self_in, &set_type)) { @@ -245,13 +246,17 @@ static mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) { other = set_make_new(NULL, 1, &other_in); cleanup_other = true; } - mp_obj_t iter = set_getiter(self); - mp_obj_t next; - mp_obj_t out = mp_const_true; - while ((next = set_it_iternext(iter)) != mp_const_stop_iteration) { - if (!mp_set_lookup(&other->set, next, MP_MAP_LOOKUP)) { - out = mp_const_false; - break; + bool out = true; + if (proper && self->set.used == other->set.used) { + out = false; + } else { + mp_obj_t iter = set_getiter(self); + mp_obj_t next; + while ((next = set_it_iternext(iter)) != mp_const_stop_iteration) { + if (!mp_set_lookup(&other->set, next, MP_MAP_LOOKUP)) { + out = false; + break; + } } } if (cleanup_self) { @@ -260,15 +265,39 @@ static mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) { if (cleanup_other) { set_clear(other); } - return out; + return MP_BOOL(out); +} +static mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) { + return set_issubset_internal(self_in, other_in, false); } static MP_DEFINE_CONST_FUN_OBJ_2(set_issubset_obj, set_issubset); +static mp_obj_t set_issubset_proper(mp_obj_t self_in, mp_obj_t other_in) { + return set_issubset_internal(self_in, other_in, true); +} + static mp_obj_t set_issuperset(mp_obj_t self_in, mp_obj_t other_in) { - return set_issubset(other_in, self_in); + return set_issubset_internal(other_in, self_in, false); } static MP_DEFINE_CONST_FUN_OBJ_2(set_issuperset_obj, set_issuperset); +static mp_obj_t set_issuperset_proper(mp_obj_t self_in, mp_obj_t other_in) { + return set_issubset_internal(other_in, self_in, true); +} + +static mp_obj_t set_equal(mp_obj_t self_in, mp_obj_t other_in) { + assert(MP_OBJ_IS_TYPE(self_in, &set_type)); + mp_obj_set_t *self = self_in; + if (!MP_OBJ_IS_TYPE(other_in, &set_type)) { + return mp_const_false; + } + mp_obj_set_t *other = other_in; + if (self->set.used != other->set.used) { + return mp_const_false; + } + return set_issubset(self_in, other_in); +} + static mp_obj_t set_pop(mp_obj_t self_in) { assert(MP_OBJ_IS_TYPE(self_in, &set_type)); mp_obj_set_t *self = self_in; @@ -341,6 +370,42 @@ static mp_obj_t set_union(mp_obj_t self_in, mp_obj_t other_in) { static MP_DEFINE_CONST_FUN_OBJ_2(set_union_obj, set_union); +static mp_obj_t set_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) { + mp_obj_t args[] = {lhs, rhs}; + switch (op) { + case RT_BINARY_OP_OR: + return set_union(lhs, rhs); + case RT_BINARY_OP_XOR: + return set_symmetric_difference(lhs, rhs); + case RT_BINARY_OP_AND: + return set_intersect(lhs, rhs); + case RT_BINARY_OP_SUBTRACT: + return set_diff(2, args); + case RT_BINARY_OP_INPLACE_OR: + return set_union(lhs, rhs); + case RT_BINARY_OP_INPLACE_XOR: + return set_symmetric_difference(lhs, rhs); + case RT_BINARY_OP_INPLACE_AND: + return set_intersect(lhs, rhs); + case RT_BINARY_OP_INPLACE_SUBTRACT: + return set_diff(2, args); + case RT_COMPARE_OP_LESS: + return set_issubset_proper(lhs, rhs); + case RT_COMPARE_OP_MORE: + return set_issuperset_proper(lhs, rhs); + case RT_COMPARE_OP_EQUAL: + return set_equal(lhs, rhs); + case RT_COMPARE_OP_LESS_EQUAL: + return set_issubset(lhs, rhs); + case RT_COMPARE_OP_MORE_EQUAL: + return set_issuperset(lhs, rhs); + case RT_COMPARE_OP_NOT_EQUAL: + return MP_BOOL(set_equal(lhs, rhs) == mp_const_false); + default: + // op not supported + return NULL; + } +} /******************************************************************************/ /* set constructors & public C API */ @@ -372,6 +437,7 @@ const mp_obj_type_t set_type = { "set", .print = set_print, .make_new = set_make_new, + .binary_op = set_binary_op, .getiter = set_getiter, .methods = set_type_methods, }; diff --git a/tests/basics/tests/set_binop.py b/tests/basics/tests/set_binop.py new file mode 100644 index 0000000000..46ecbcb63e --- /dev/null +++ b/tests/basics/tests/set_binop.py @@ -0,0 +1,29 @@ +def r(s): + l = list(s) + l.sort() + print(l) +s = {1, 2} +t = {2, 3} +r(s | t) +r(s ^ t) +r(s & t) +r(s - t) +u = s.copy() +u |= t +r(u) +u = s.copy() +u ^= t +r(u) +u = s.copy() +u &= t +r(u) +u = s.copy() +u -= t +r(u) + +print(s == t) +print(s != t) +print(s > t) +print(s >= t) +print(s < t) +print(s <= t) From 7244a1443930824b31498cd30f1840af648131c3 Mon Sep 17 00:00:00 2001 From: "John R. Lenton" Date: Sun, 12 Jan 2014 23:37:45 +0000 Subject: [PATCH 12/12] oops, nasty off-by-one in set_copy --- py/objset.c | 6 +++- tests/basics/tests/set_binop.py | 51 +++++++++++++++++---------------- 2 files changed, 31 insertions(+), 26 deletions(-) diff --git a/py/objset.c b/py/objset.c index 2ed2abb611..e41f2c47f4 100644 --- a/py/objset.c +++ b/py/objset.c @@ -27,6 +27,10 @@ static mp_obj_t set_it_iternext(mp_obj_t self_in); void set_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in) { mp_obj_set_t *self = self_in; + if (self->set.used == 0) { + print(env, "set()"); + return; + } bool first = true; print(env, "{"); for (int i = 0; i < self->set.alloc; i++) { @@ -122,7 +126,7 @@ static mp_obj_t set_copy(mp_obj_t self_in) { mp_obj_set_t *other = m_new_obj(mp_obj_set_t); other->base.type = &set_type; - mp_set_init(&other->set, self->set.alloc); + mp_set_init(&other->set, self->set.alloc - 1); other->set.used = self->set.used; memcpy(other->set.table, self->set.table, self->set.alloc * sizeof(mp_obj_t)); diff --git a/tests/basics/tests/set_binop.py b/tests/basics/tests/set_binop.py index 46ecbcb63e..d0d0b8027b 100644 --- a/tests/basics/tests/set_binop.py +++ b/tests/basics/tests/set_binop.py @@ -1,29 +1,30 @@ def r(s): l = list(s) l.sort() - print(l) -s = {1, 2} -t = {2, 3} -r(s | t) -r(s ^ t) -r(s & t) -r(s - t) -u = s.copy() -u |= t -r(u) -u = s.copy() -u ^= t -r(u) -u = s.copy() -u &= t -r(u) -u = s.copy() -u -= t -r(u) + return l +sets = [set(), {1}, {1, 2}, {1, 2, 3}, {2, 3}, {2, 3, 5}, {5}, {7}] +for s in sets: + for t in sets: + print(s, '|', t, '=', r(s | t)) + print(s, '^', t, '=', r(s ^ t)) + print(s, '&', t, '=', r(s & t)) + print(s, '-', t, '=', r(s - t)) + u = s.copy() + u |= t + print(s, "|=", t, '-->', r(u)) + u = s.copy() + u ^= t + print(s, "^=", t, '-->', r(u)) + u = s.copy() + u &= t + print(s, "&=", t, "-->", r(u)) + u = s.copy() + u -= t + print(s, "-=", t, "-->", r(u)) -print(s == t) -print(s != t) -print(s > t) -print(s >= t) -print(s < t) -print(s <= t) + print(s, '==', t, '=', s == t) + print(s, '!=', t, '=', s != t) + print(s, '>', t, '=', s > t) + print(s, '>=', t, '=', s >= t) + print(s, '<', t, '=', s < t) + print(s, '<=', t, '=', s <= t)