Skip to content

Commit 4bde4ef

Browse files
jeplerjepler
authored
Merge pull request #647 from v923z/circuitpython9
Drop certain CircuitPython workarounds that are no longer needed
2 parents a05ec05 + eacb0c9 commit 4bde4ef

30 files changed

+186
-446
lines changed

‎code/ndarray.c

Lines changed: 26 additions & 118 deletions
Original file line numberDiff line numberDiff line change
@@ -61,98 +61,6 @@ void ndarray_set_complex_value(void *p, size_t index, mp_obj_t value) {
6161
}
6262
}
6363

64-
#ifdef CIRCUITPY
65-
void ndarray_set_value(char typecode, void *p, size_t index, mp_obj_t val_in) {
66-
switch (typecode) {
67-
case NDARRAY_INT8:
68-
((signed char *)p)[index] = mp_obj_get_int(val_in);
69-
break;
70-
case NDARRAY_UINT8:
71-
((unsigned char *)p)[index] = mp_obj_get_int(val_in);
72-
break;
73-
case NDARRAY_INT16:
74-
((short *)p)[index] = mp_obj_get_int(val_in);
75-
break;
76-
case NDARRAY_UINT16:
77-
((unsigned short *)p)[index] = mp_obj_get_int(val_in);
78-
break;
79-
case NDARRAY_FLOAT:
80-
((mp_float_t *)p)[index] = mp_obj_get_float(val_in);
81-
break;
82-
#if ULAB_SUPPORTS_COMPLEX
83-
case NDARRAY_COMPLEX:
84-
ndarray_set_complex_value(p, index, val_in);
85-
break;
86-
#endif
87-
}
88-
}
89-
#endif
90-
91-
#if defined(MICROPY_VERSION_MAJOR) && MICROPY_VERSION_MAJOR == 1 && MICROPY_VERSION_MINOR == 11
92-
93-
void mp_obj_slice_indices(mp_obj_t self_in, mp_int_t length, mp_bound_slice_t *result) {
94-
mp_obj_slice_t *self = MP_OBJ_TO_PTR(self_in);
95-
mp_int_t start, stop, step;
96-
97-
if (self->step == mp_const_none) {
98-
step = 1;
99-
} else {
100-
step = mp_obj_get_int(self->step);
101-
if (step == 0) {
102-
mp_raise_ValueError(translate("slice step can't be zero"));
103-
}
104-
}
105-
106-
if (step > 0) {
107-
// Positive step
108-
if (self->start == mp_const_none) {
109-
start = 0;
110-
} else {
111-
start = mp_obj_get_int(self->start);
112-
if (start < 0) {
113-
start += length;
114-
}
115-
start = MIN(length, MAX(start, 0));
116-
}
117-
118-
if (self->stop == mp_const_none) {
119-
stop = length;
120-
} else {
121-
stop = mp_obj_get_int(self->stop);
122-
if (stop < 0) {
123-
stop += length;
124-
}
125-
stop = MIN(length, MAX(stop, 0));
126-
}
127-
} else {
128-
// Negative step
129-
if (self->start == mp_const_none) {
130-
start = length - 1;
131-
} else {
132-
start = mp_obj_get_int(self->start);
133-
if (start < 0) {
134-
start += length;
135-
}
136-
start = MIN(length - 1, MAX(start, -1));
137-
}
138-
139-
if (self->stop == mp_const_none) {
140-
stop = -1;
141-
} else {
142-
stop = mp_obj_get_int(self->stop);
143-
if (stop < 0) {
144-
stop += length;
145-
}
146-
stop = MIN(length - 1, MAX(stop, -1));
147-
}
148-
}
149-
150-
result->start = start;
151-
result->stop = stop;
152-
result->step = step;
153-
}
154-
#endif /* MICROPY_VERSION v1.11 */
155-
15664
void ndarray_fill_array_iterable(mp_float_t *array, mp_obj_t iterable) {
15765
mp_obj_iter_buf_t x_buf;
15866
mp_obj_t x_item, x_iterable = mp_getiter(iterable, &x_buf);
@@ -291,7 +199,7 @@ mp_obj_t ndarray_dtype_make_new(const mp_obj_type_t *type, size_t n_args, size_t
291199
if((_dtype != NDARRAY_BOOL) && (_dtype != NDARRAY_UINT8)
292200
&& (_dtype != NDARRAY_INT8) && (_dtype != NDARRAY_UINT16)
293201
&& (_dtype != NDARRAY_INT16) && (_dtype != NDARRAY_FLOAT)) {
294-
mp_raise_TypeError(translate("data type not understood"));
202+
mp_raise_TypeError(MP_ERROR_TEXT("data type not understood"));
295203
}
296204
} else {
297205
GET_STR_DATA_LEN(_args[0].u_obj, _dtype_, len);
@@ -312,7 +220,7 @@ mp_obj_t ndarray_dtype_make_new(const mp_obj_type_t *type, size_t n_args, size_t
312220
}
313221
#endif
314222
else {
315-
mp_raise_TypeError(translate("data type not understood"));
223+
mp_raise_TypeError(MP_ERROR_TEXT("data type not understood"));
316224
}
317225
}
318226
dtype->dtype = _dtype;
@@ -344,7 +252,7 @@ mp_obj_t ndarray_dtype(mp_obj_t self_in) {
344252
&& (*_dtype != NDARRAY_COMPLEX)
345253
#endif
346254
)) {
347-
mp_raise_TypeError(translate("data type not understood"));
255+
mp_raise_TypeError(MP_ERROR_TEXT("data type not understood"));
348256
}
349257
dtype = *_dtype;
350258
}
@@ -596,7 +504,7 @@ bool ndarray_is_dense(ndarray_obj_t *ndarray) {
596504
static size_t multiply_size(size_t a, size_t b) {
597505
size_t result;
598506
if (__builtin_mul_overflow(a, b, &result)) {
599-
mp_raise_ValueError(translate("array is too big"));
507+
mp_raise_ValueError(MP_ERROR_TEXT("array is too big"));
600508
}
601509
return result;
602510
}
@@ -623,7 +531,7 @@ ndarray_obj_t *ndarray_new_ndarray(uint8_t ndim, size_t *shape, int32_t *strides
623531
}
624532

625533
if (SIZE_MAX / ndarray->itemsize <= ndarray->len) {
626-
mp_raise_ValueError(translate("ndarray length overflows"));
534+
mp_raise_ValueError(MP_ERROR_TEXT("ndarray length overflows"));
627535
}
628536

629537
// if the length is 0, still allocate a single item, so that contractions can be handled
@@ -782,7 +690,7 @@ ndarray_obj_t *ndarray_copy_view_convert_type(ndarray_obj_t *source, uint8_t dty
782690
#if ULAB_SUPPORTS_COMPLEX
783691
if(source->dtype == NDARRAY_COMPLEX) {
784692
if(dtype != NDARRAY_COMPLEX) {
785-
mp_raise_TypeError(translate("cannot convert complex type"));
693+
mp_raise_TypeError(MP_ERROR_TEXT("cannot convert complex type"));
786694
} else {
787695
memcpy(array, sarray, complex_size);
788696
}
@@ -948,7 +856,7 @@ ndarray_obj_t *ndarray_from_iterable(mp_obj_t obj, uint8_t dtype) {
948856
break;
949857
}
950858
if(ndim == ULAB_MAX_DIMS) {
951-
mp_raise_ValueError(translate("too many dimensions"));
859+
mp_raise_ValueError(MP_ERROR_TEXT("too many dimensions"));
952860
}
953861
shape[ndim] = MP_OBJ_SMALL_INT_VALUE(mp_obj_len_maybe(item));
954862
if(shape[ndim] == 0) {
@@ -1138,13 +1046,13 @@ static mp_bound_slice_t generate_slice(mp_int_t n, mp_obj_t index) {
11381046
_index += n;
11391047
}
11401048
if((_index >= n) || (_index < 0)) {
1141-
mp_raise_msg(&mp_type_IndexError, translate("index is out of bounds"));
1049+
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("index is out of bounds"));
11421050
}
11431051
slice.start = _index;
11441052
slice.stop = _index + 1;
11451053
slice.step = 1;
11461054
} else {
1147-
mp_raise_msg(&mp_type_IndexError, translate("indices must be integers, slices, or Boolean lists"));
1055+
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("indices must be integers, slices, or Boolean lists"));
11481056
}
11491057
return slice;
11501058
}
@@ -1170,7 +1078,7 @@ static ndarray_obj_t *ndarray_view_from_slices(ndarray_obj_t *ndarray, mp_obj_tu
11701078
k += ndarray->shape[ULAB_MAX_DIMS - ndarray->ndim + i];
11711079
}
11721080
if((k >= (int32_t)ndarray->shape[ULAB_MAX_DIMS - ndarray->ndim + i]) || (k < 0)) {
1173-
mp_raise_msg(&mp_type_IndexError, translate("index is out of bounds"));
1081+
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("index is out of bounds"));
11741082
}
11751083
offset += ndarray->strides[ULAB_MAX_DIMS - ndarray->ndim + i] * k;
11761084
// ... and then we have to shift the shapes to the right
@@ -1197,7 +1105,7 @@ void ndarray_assign_view(ndarray_obj_t *view, ndarray_obj_t *values) {
11971105
int32_t *lstrides = m_new0(int32_t, ULAB_MAX_DIMS);
11981106
int32_t *rstrides = m_new0(int32_t, ULAB_MAX_DIMS);
11991107
if(!ndarray_can_broadcast(view, values, &ndim, shape, lstrides, rstrides)) {
1200-
mp_raise_ValueError(translate("operands could not be broadcast together"));
1108+
mp_raise_ValueError(MP_ERROR_TEXT("operands could not be broadcast together"));
12011109
} else {
12021110

12031111
ndarray_obj_t *ndarray = ndarray_copy_view_convert_type(values, view->dtype);
@@ -1263,7 +1171,7 @@ void ndarray_assign_view(ndarray_obj_t *view, ndarray_obj_t *values) {
12631171
static mp_obj_t ndarray_from_boolean_index(ndarray_obj_t *ndarray, ndarray_obj_t *index) {
12641172
// returns a 1D array, indexed by a Boolean array
12651173
if(ndarray->len != index->len) {
1266-
mp_raise_ValueError(translate("array and index length must be equal"));
1174+
mp_raise_ValueError(MP_ERROR_TEXT("array and index length must be equal"));
12671175
}
12681176
uint8_t *iarray = (uint8_t *)index->array;
12691177
// first we have to find out how many trues there are
@@ -1315,7 +1223,7 @@ static mp_obj_t ndarray_assign_from_boolean_index(ndarray_obj_t *ndarray, ndarra
13151223
#if ULAB_SUPPORTS_COMPLEX
13161224
if(values->dtype == NDARRAY_COMPLEX) {
13171225
if(ndarray->dtype != NDARRAY_COMPLEX) {
1318-
mp_raise_TypeError(translate("cannot convert complex to dtype"));
1226+
mp_raise_TypeError(MP_ERROR_TEXT("cannot convert complex to dtype"));
13191227
} else {
13201228
uint8_t *array = (uint8_t *)ndarray->array;
13211229
for(size_t i = 0; i < ndarray->len; i++) {
@@ -1406,7 +1314,7 @@ static mp_obj_t ndarray_get_slice(ndarray_obj_t *ndarray, mp_obj_t index, ndarra
14061314
if(mp_obj_is_type(index, &ulab_ndarray_type)) {
14071315
ndarray_obj_t *nindex = MP_OBJ_TO_PTR(index);
14081316
if((nindex->ndim > 1) || (nindex->boolean == false)) {
1409-
mp_raise_NotImplementedError(translate("operation is implemented for 1D Boolean arrays only"));
1317+
mp_raise_NotImplementedError(MP_ERROR_TEXT("operation is implemented for 1D Boolean arrays only"));
14101318
}
14111319
if(values == NULL) { // return value(s)
14121320
return ndarray_from_boolean_index(ndarray, nindex);
@@ -1419,7 +1327,7 @@ static mp_obj_t ndarray_get_slice(ndarray_obj_t *ndarray, mp_obj_t index, ndarra
14191327
if(mp_obj_is_type(index, &mp_type_tuple)) {
14201328
tuple = MP_OBJ_TO_PTR(index);
14211329
if(tuple->len > ndarray->ndim) {
1422-
mp_raise_msg(&mp_type_IndexError, translate("too many indices"));
1330+
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("too many indices"));
14231331
}
14241332
} else {
14251333
mp_obj_t *items = m_new(mp_obj_t, 1);
@@ -1443,7 +1351,7 @@ static mp_obj_t ndarray_get_slice(ndarray_obj_t *ndarray, mp_obj_t index, ndarra
14431351

14441352
mp_obj_t ndarray_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
14451353
if(value == MP_OBJ_NULL) {
1446-
mp_raise_ValueError(translate("cannot delete array elements"));
1354+
mp_raise_ValueError(MP_ERROR_TEXT("cannot delete array elements"));
14471355
}
14481356
ndarray_obj_t *self = MP_OBJ_TO_PTR(self_in);
14491357

@@ -1521,7 +1429,7 @@ mp_obj_t ndarray_flatten(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
15211429
ndarray_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
15221430
GET_STR_DATA_LEN(args[0].u_obj, order, len);
15231431
if((len != 1) || ((memcmp(order, "C", 1) != 0) && (memcmp(order, "F", 1) != 0))) {
1524-
mp_raise_ValueError(translate("flattening order must be either 'C', or 'F'"));
1432+
mp_raise_ValueError(MP_ERROR_TEXT("flattening order must be either 'C', or 'F'"));
15251433
}
15261434

15271435
uint8_t *sarray = (uint8_t *)self->array;
@@ -1659,7 +1567,7 @@ mp_obj_t ndarray_tobytes(mp_obj_t self_in) {
16591567
// Piping into a bytearray makes sense for dense arrays only,
16601568
// so bail out, if that is not the case
16611569
if(!ndarray_is_dense(self)) {
1662-
mp_raise_ValueError(translate("tobytes can be invoked for dense arrays only"));
1570+
mp_raise_ValueError(MP_ERROR_TEXT("tobytes can be invoked for dense arrays only"));
16631571
}
16641572
return mp_obj_new_bytearray_by_ref(self->itemsize * self->len, self->array);
16651573
}
@@ -1799,7 +1707,7 @@ mp_obj_t ndarray_binary_op(mp_binary_op_t _op, mp_obj_t lobj, mp_obj_t robj) {
17991707
broadcastable = ndarray_can_broadcast(lhs, rhs, &ndim, shape, lstrides, rstrides);
18001708
}
18011709
if(!broadcastable) {
1802-
mp_raise_ValueError(translate("operands could not be broadcast together"));
1710+
mp_raise_ValueError(MP_ERROR_TEXT("operands could not be broadcast together"));
18031711
m_del(size_t, shape, ULAB_MAX_DIMS);
18041712
m_del(int32_t, lstrides, ULAB_MAX_DIMS);
18051713
m_del(int32_t, rstrides, ULAB_MAX_DIMS);
@@ -2015,7 +1923,7 @@ mp_obj_t ndarray_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
20151923
#else
20161924
if(self->dtype == NDARRAY_FLOAT) {
20171925
#endif
2018-
mp_raise_ValueError(translate("operation is not supported for given type"));
1926+
mp_raise_ValueError(MP_ERROR_TEXT("operation is not supported for given type"));
20191927
}
20201928
// we can invert the content byte by byte, no need to distinguish between different dtypes
20211929
ndarray = ndarray_copy_view(self); // from this point, this is a dense copy
@@ -2104,7 +2012,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(ndarray_transpose_obj, ndarray_transpose);
21042012
mp_obj_t ndarray_reshape_core(mp_obj_t oin, mp_obj_t _shape, bool inplace) {
21052013
ndarray_obj_t *source = MP_OBJ_TO_PTR(oin);
21062014
if(!mp_obj_is_type(_shape, &mp_type_tuple) && !mp_obj_is_int(_shape)) {
2107-
mp_raise_TypeError(translate("shape must be integer or tuple of integers"));
2015+
mp_raise_TypeError(MP_ERROR_TEXT("shape must be integer or tuple of integers"));
21082016
}
21092017

21102018
mp_obj_tuple_t *shape;
@@ -2118,7 +2026,7 @@ mp_obj_t ndarray_reshape_core(mp_obj_t oin, mp_obj_t _shape, bool inplace) {
21182026
}
21192027

21202028
if(shape->len > ULAB_MAX_DIMS) {
2121-
mp_raise_ValueError(translate("maximum number of dimensions is " MP_STRINGIFY(ULAB_MAX_DIMS)));
2029+
mp_raise_ValueError(MP_ERROR_TEXT("maximum number of dimensions is " MP_STRINGIFY(ULAB_MAX_DIMS)));
21222030
}
21232031

21242032
size_t new_length = 1;
@@ -2138,14 +2046,14 @@ mp_obj_t ndarray_reshape_core(mp_obj_t oin, mp_obj_t _shape, bool inplace) {
21382046
}
21392047

21402048
if(unknown_dim > 1) {
2141-
mp_raise_ValueError(translate("can only specify one unknown dimension"));
2049+
mp_raise_ValueError(MP_ERROR_TEXT("can only specify one unknown dimension"));
21422050
} else if(unknown_dim == 1) {
21432051
new_shape[unknown_index] = source->len / new_length;
21442052
new_length = source->len;
21452053
}
21462054

21472055
if(source->len != new_length) {
2148-
mp_raise_ValueError(translate("cannot reshape array"));
2056+
mp_raise_ValueError(MP_ERROR_TEXT("cannot reshape array"));
21492057
}
21502058

21512059
ndarray_obj_t *ndarray;
@@ -2162,7 +2070,7 @@ mp_obj_t ndarray_reshape_core(mp_obj_t oin, mp_obj_t _shape, bool inplace) {
21622070
}
21632071
} else {
21642072
if(inplace) {
2165-
mp_raise_ValueError(translate("cannot assign new shape"));
2073+
mp_raise_ValueError(MP_ERROR_TEXT("cannot assign new shape"));
21662074
}
21672075
if(mp_obj_is_type(_shape, &mp_type_tuple)) {
21682076
ndarray = ndarray_new_ndarray_from_tuple(shape, source->dtype);
@@ -2185,7 +2093,7 @@ MP_DEFINE_CONST_FUN_OBJ_2(ndarray_reshape_obj, ndarray_reshape);
21852093
#if ULAB_NUMPY_HAS_NDINFO
21862094
mp_obj_t ndarray_info(mp_obj_t obj_in) {
21872095
if(!mp_obj_is_type(obj_in, &ulab_ndarray_type)) {
2188-
mp_raise_TypeError(translate("function is defined for ndarrays only"));
2096+
mp_raise_TypeError(MP_ERROR_TEXT("function is defined for ndarrays only"));
21892097
}
21902098
ndarray_obj_t *ndarray = MP_OBJ_TO_PTR(obj_in);
21912099
mp_printf(MP_PYTHON_PRINTER, "class: ndarray\n");

‎code/ndarray.h

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -111,13 +111,7 @@ typedef struct _mp_obj_slice_t {
111111
#endif
112112
#endif
113113

114-
#if !CIRCUITPY
115-
#define translate(x) MP_ERROR_TEXT(x)
116114
#define ndarray_set_value(a, b, c, d) mp_binary_set_val_array(a, b, c, d)
117-
#else
118-
void ndarray_set_value(char , void *, size_t , mp_obj_t );
119-
#endif
120-
121115
void ndarray_set_complex_value(void *, size_t , mp_obj_t );
122116

123117
#define NDARRAY_NUMERIC 0

‎code/ndarray_operators.c

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -863,19 +863,19 @@ mp_obj_t ndarray_binary_logical(ndarray_obj_t *lhs, ndarray_obj_t *rhs,
863863

864864
#if ULAB_SUPPORTS_COMPLEX
865865
if((lhs->dtype == NDARRAY_COMPLEX) || (rhs->dtype == NDARRAY_COMPLEX) || (lhs->dtype == NDARRAY_FLOAT) || (rhs->dtype == NDARRAY_FLOAT)) {
866-
mp_raise_TypeError(translate("operation not supported for the input types"));
866+
mp_raise_TypeError(MP_ERROR_TEXT("operation not supported for the input types"));
867867
}
868868
#else
869869
if((lhs->dtype == NDARRAY_FLOAT) || (rhs->dtype == NDARRAY_FLOAT)) {
870-
mp_raise_TypeError(translate("operation not supported for the input types"));
870+
mp_raise_TypeError(MP_ERROR_TEXT("operation not supported for the input types"));
871871
}
872872
#endif
873873

874874
// bail out, if both inputs are of 16-bit types, but differ in sign;
875875
// numpy promotes the result to int32
876876
if(((lhs->dtype == NDARRAY_INT16) && (rhs->dtype == NDARRAY_UINT16)) ||
877877
((lhs->dtype == NDARRAY_UINT16) && (rhs->dtype == NDARRAY_INT16))) {
878-
mp_raise_TypeError(translate("dtype of int32 is not supported"));
878+
mp_raise_TypeError(MP_ERROR_TEXT("dtype of int32 is not supported"));
879879
}
880880

881881
ndarray_obj_t *results = NULL;
@@ -1049,7 +1049,7 @@ mp_obj_t ndarray_binary_logical(ndarray_obj_t *lhs, ndarray_obj_t *rhs,
10491049
mp_obj_t ndarray_inplace_ams(ndarray_obj_t *lhs, ndarray_obj_t *rhs, int32_t *rstrides, uint8_t optype) {
10501050

10511051
if((lhs->dtype != NDARRAY_FLOAT) && (rhs->dtype == NDARRAY_FLOAT)) {
1052-
mp_raise_TypeError(translate("cannot cast output with casting rule"));
1052+
mp_raise_TypeError(MP_ERROR_TEXT("cannot cast output with casting rule"));
10531053
}
10541054
uint8_t *larray = (uint8_t *)lhs->array;
10551055
uint8_t *rarray = (uint8_t *)rhs->array;
@@ -1078,7 +1078,7 @@ mp_obj_t ndarray_inplace_ams(ndarray_obj_t *lhs, ndarray_obj_t *rhs, int32_t *rs
10781078
mp_obj_t ndarray_inplace_divide(ndarray_obj_t *lhs, ndarray_obj_t *rhs, int32_t *rstrides) {
10791079

10801080
if((lhs->dtype != NDARRAY_FLOAT)) {
1081-
mp_raise_TypeError(translate("results cannot be cast to specified type"));
1081+
mp_raise_TypeError(MP_ERROR_TEXT("results cannot be cast to specified type"));
10821082
}
10831083
uint8_t *larray = (uint8_t *)lhs->array;
10841084
uint8_t *rarray = (uint8_t *)rhs->array;
@@ -1102,7 +1102,7 @@ mp_obj_t ndarray_inplace_divide(ndarray_obj_t *lhs, ndarray_obj_t *rhs, int32_t
11021102
mp_obj_t ndarray_inplace_power(ndarray_obj_t *lhs, ndarray_obj_t *rhs, int32_t *rstrides) {
11031103

11041104
if((lhs->dtype != NDARRAY_FLOAT)) {
1105-
mp_raise_TypeError(translate("results cannot be cast to specified type"));
1105+
mp_raise_TypeError(MP_ERROR_TEXT("results cannot be cast to specified type"));
11061106
}
11071107
uint8_t *larray = (uint8_t *)lhs->array;
11081108
uint8_t *rarray = (uint8_t *)rhs->array;

0 commit comments

Comments
 (0)