Compare commits
No commits in common. "mp-flags-compat" and "2dim" have entirely different histories.
mp-flags-c
...
2dim
43 changed files with 6601 additions and 3904 deletions
4
.github/workflows/build.yml
vendored
4
.github/workflows/build.yml
vendored
|
|
@ -3,10 +3,6 @@ name: Build CI
|
|||
on:
|
||||
push:
|
||||
pull_request:
|
||||
paths:
|
||||
- 'code/'
|
||||
- 'tests/'
|
||||
- '.github/workflows/'
|
||||
release:
|
||||
types: [published]
|
||||
check_suite:
|
||||
|
|
|
|||
3
.gitignore
vendored
3
.gitignore
vendored
|
|
@ -1,3 +0,0 @@
|
|||
/micropython
|
||||
/*.exp
|
||||
/*.out
|
||||
43
README.md
43
README.md
|
|
@ -1,32 +1,25 @@
|
|||
# micropython-ulab
|
||||
|
||||
`ulab` is a `numpy`-like array manipulation library for `micropython` and `CircuitPython`.
|
||||
The module is written in C, defines compact containers for numerical
|
||||
data, and is fast. The library is a software-only standard `micropython` user module,
|
||||
i.e., it has no hardware dependencies, and can be compiled for any platform.
|
||||
The `float` implementation of `micropython` (`float`, or `double`) is automatically detected.
|
||||
ulab is a numpy-like array manipulation library for micropython.
|
||||
The module is written in C, defines compact containers for numerical
|
||||
data, and is fast.
|
||||
|
||||
Documentation can be found under https://micropython-ulab.readthedocs.io/en/latest/.
|
||||
Documentation can be found under https://micropython-ulab.readthedocs.io/en/latest/
|
||||
The source for the manual is in https://github.com/v923z/micropython-ulab/blob/master/docs/ulab-manual.ipynb,
|
||||
while developer help is in https://github.com/v923z/micropython-ulab/blob/master/docs/ulab.ipynb.
|
||||
|
||||
# Firmware
|
||||
|
||||
Firmware for pyboard.v.1.1, and PYBD_SF6 is released once in a while, and can be downloaded
|
||||
from https://github.com/v923z/micropython-ulab/releases. Since a number of features can be
|
||||
set in the firmware (threading, support for SD card, LEDs, user switch etc.), and it is
|
||||
impossible to create something that suits everyone, these releases should only be used for
|
||||
quick testing of `ulab`. Otherwise, compilation from the source is required with
|
||||
the appropriate settings, which are usually defined in the `mpconfigboard.h` file of the port
|
||||
in question.
|
||||
|
||||
`ulab` is also included in most development builds of `CircuitPython` for SAMD51 and nRF microcontrollers.
|
||||
Firmware for pyboard.v.1.1, and PYBD_SF6 is updated once in a while, and can be downloaded
|
||||
from https://github.com/v923z/micropython-ulab/releases.
|
||||
|
||||
## Compiling
|
||||
|
||||
If you want to try the latest version of `ulab` on micropython, or your hardware is
|
||||
If you want to try the latest version of `ulab`, or your hardware is
|
||||
different to pyboard.v.1.1, or PYBD_SF6, the firmware can be compiled
|
||||
from the source by following these steps:
|
||||
|
||||
First, you have to clone the `micropython` repository by running
|
||||
First, you have to clone the micropython repository by running
|
||||
|
||||
```
|
||||
git clone https://github.com/micropython/micropython.git
|
||||
|
|
@ -37,13 +30,18 @@ on the command line. This will create a new repository with the name `micropytho
|
|||
git clone https://github.com/v923z/micropython-ulab.git ulab
|
||||
```
|
||||
|
||||
If you don't have the cross-compiler installed, your might want to do that now, for instance on Linux by executing
|
||||
Then you have to include `ulab` in the compilation process by editing `mpconfigport.h` of the directory of the port for which you want to compile, so, still on the command line, navigate to `micropython/ports/unix`, or `micropython/ports/stm32`, or whichever port is your favourite, and edit the `mpconfigport.h` file there. All you have to do is add a single line at the end:
|
||||
|
||||
```
|
||||
#define MODULE_ULAB_ENABLED (1)
|
||||
```
|
||||
|
||||
This line will inform the compiler that you want `ulab` in the resulting firmware. If you don't have the cross-compiler installed, your might want to do that now, for instance on Linux by executing
|
||||
|
||||
```
|
||||
sudo apt-get install gcc-arm-none-eabi
|
||||
```
|
||||
|
||||
If this step was successful, you can try to run the `make` command in the port's directory as
|
||||
If that was successful, you can try to run the make command in the port's directory as
|
||||
```
|
||||
make BOARD=PYBV11 USER_C_MODULES=../../../ulab all
|
||||
```
|
||||
|
|
@ -51,9 +49,8 @@ which will prepare the firmware for pyboard.v.11. Similarly,
|
|||
```
|
||||
make BOARD=PYBD_SF6 USER_C_MODULES=../../../ulab all
|
||||
```
|
||||
will compile for the SF6 member of the PYBD series. If your target is `unix`, you don't need to specify the `BOARD` parameter.
|
||||
|
||||
Provided that you managed to compile the firmware, you would upload that by running either
|
||||
will compile for the SF6 member of the PYBD series. Provided that you managed to compile the firmware, you would upload that by running
|
||||
either
|
||||
```
|
||||
dfu-util --alt 0 -D firmware.dfu
|
||||
```
|
||||
|
|
|
|||
17
build.sh
17
build.sh
|
|
@ -1,17 +0,0 @@
|
|||
#!/bin/sh
|
||||
set -e
|
||||
HERE="$(dirname -- "$(readlink -f -- "${0}")" )"
|
||||
[ -e micropython/py/py.mk ] || git clone https://github.com/micropython/micropython
|
||||
[ -e micropython/lib/libffi/autogen.sh ] || (cd micropython && git submodule update --init lib/libffi )
|
||||
#git clone https://github.com/micropython/micropython
|
||||
make -C micropython/mpy-cross -j$(nproc)
|
||||
make -C micropython/ports/unix -j$(nproc) deplibs
|
||||
make -C micropython/ports/unix -j$(nproc) USER_C_MODULES="${HERE}" DEBUG=1 STRIP=:
|
||||
|
||||
if ! env MICROPY_MICROPYTHON=micropython/ports/unix/micropython micropython/tests/run-tests -d tests; then
|
||||
for exp in *.exp; do
|
||||
testbase=$(basename $exp .exp);
|
||||
echo -e "\nFAILURE $testbase";
|
||||
diff -u $testbase.exp $testbase.out;
|
||||
done
|
||||
fi
|
||||
155
code/create.c
155
code/create.c
|
|
@ -1,155 +0,0 @@
|
|||
/*
|
||||
* This file is part of the micropython-ulab project,
|
||||
*
|
||||
* https://github.com/v923z/micropython-ulab
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
|
||||
* 2019-2020 Zoltán Vörös
|
||||
*/
|
||||
|
||||
|
||||
#include "py/obj.h"
|
||||
#include "py/runtime.h"
|
||||
#include "create.h"
|
||||
|
||||
mp_obj_t create_zeros_ones(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args, uint8_t kind) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} } ,
|
||||
{ MP_QSTR_dtype, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = NDARRAY_FLOAT} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
uint8_t dtype = args[1].u_int;
|
||||
if(!MP_OBJ_IS_INT(args[0].u_obj) && !MP_OBJ_IS_TYPE(args[0].u_obj, &mp_type_tuple)) {
|
||||
mp_raise_TypeError(translate("input argument must be an integer or a 2-tuple"));
|
||||
}
|
||||
ndarray_obj_t *ndarray = NULL;
|
||||
if(MP_OBJ_IS_INT(args[0].u_obj)) {
|
||||
size_t n = mp_obj_get_int(args[0].u_obj);
|
||||
ndarray = create_new_ndarray(1, n, dtype);
|
||||
} else if(MP_OBJ_IS_TYPE(args[0].u_obj, &mp_type_tuple)) {
|
||||
mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(args[0].u_obj);
|
||||
if(tuple->len != 2) {
|
||||
mp_raise_TypeError(translate("input argument must be an integer or a 2-tuple"));
|
||||
}
|
||||
ndarray = create_new_ndarray(mp_obj_get_int(tuple->items[0]),
|
||||
mp_obj_get_int(tuple->items[1]), dtype);
|
||||
}
|
||||
if(kind == 1) {
|
||||
mp_obj_t one = mp_obj_new_int(1);
|
||||
for(size_t i=0; i < ndarray->array->len; i++) {
|
||||
mp_binary_set_val_array(dtype, ndarray->array->items, i, one);
|
||||
}
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(ndarray);
|
||||
}
|
||||
|
||||
mp_obj_t create_zeros(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
return create_zeros_ones(n_args, pos_args, kw_args, 0);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(create_zeros_obj, 0, create_zeros);
|
||||
|
||||
mp_obj_t create_ones(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
return create_zeros_ones(n_args, pos_args, kw_args, 1);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(create_ones_obj, 0, create_ones);
|
||||
|
||||
mp_obj_t create_eye(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
|
||||
{ MP_QSTR_M, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
{ MP_QSTR_k, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
|
||||
{ MP_QSTR_dtype, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = NDARRAY_FLOAT} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
size_t n = args[0].u_int, m;
|
||||
int16_t k = args[2].u_int;
|
||||
uint8_t dtype = args[3].u_int;
|
||||
if(args[1].u_rom_obj == mp_const_none) {
|
||||
m = n;
|
||||
} else {
|
||||
m = mp_obj_get_int(args[1].u_rom_obj);
|
||||
}
|
||||
|
||||
ndarray_obj_t *ndarray = create_new_ndarray(m, n, dtype);
|
||||
mp_obj_t one = mp_obj_new_int(1);
|
||||
size_t i = 0;
|
||||
if((k >= 0) && (k < n)) {
|
||||
while(k < n) {
|
||||
mp_binary_set_val_array(dtype, ndarray->array->items, i*n+k, one);
|
||||
k++;
|
||||
i++;
|
||||
}
|
||||
} else if((k < 0) && (-k < m)) {
|
||||
k = -k;
|
||||
i = 0;
|
||||
while(k < m) {
|
||||
mp_binary_set_val_array(dtype, ndarray->array->items, k*n+i, one);
|
||||
k++;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(ndarray);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(create_eye_obj, 0, create_eye);
|
||||
|
||||
mp_obj_t create_linspace(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
{ MP_QSTR_num, MP_ARG_INT, {.u_int = 50} },
|
||||
{ MP_QSTR_endpoint, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_true} },
|
||||
{ MP_QSTR_retstep, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_false} },
|
||||
{ MP_QSTR_dtype, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = NDARRAY_FLOAT} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(2, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
uint16_t len = args[2].u_int;
|
||||
if(len < 2) {
|
||||
mp_raise_ValueError(translate("number of points must be at least 2"));
|
||||
}
|
||||
mp_float_t value, step;
|
||||
value = mp_obj_get_float(args[0].u_obj);
|
||||
uint8_t typecode = args[5].u_int;
|
||||
if(args[3].u_obj == mp_const_true) step = (mp_obj_get_float(args[1].u_obj)-value)/(len-1);
|
||||
else step = (mp_obj_get_float(args[1].u_obj)-value)/len;
|
||||
ndarray_obj_t *ndarray = create_new_ndarray(1, len, typecode);
|
||||
if(typecode == NDARRAY_UINT8) {
|
||||
uint8_t *array = (uint8_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (uint8_t)value;
|
||||
} else if(typecode == NDARRAY_INT8) {
|
||||
int8_t *array = (int8_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (int8_t)value;
|
||||
} else if(typecode == NDARRAY_UINT16) {
|
||||
uint16_t *array = (uint16_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (uint16_t)value;
|
||||
} else if(typecode == NDARRAY_INT16) {
|
||||
int16_t *array = (int16_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (int16_t)value;
|
||||
} else {
|
||||
mp_float_t *array = (mp_float_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = value;
|
||||
}
|
||||
if(args[4].u_obj == mp_const_false) {
|
||||
return MP_OBJ_FROM_PTR(ndarray);
|
||||
} else {
|
||||
mp_obj_t tuple[2];
|
||||
tuple[0] = ndarray;
|
||||
tuple[1] = mp_obj_new_float(step);
|
||||
return mp_obj_new_tuple(2, tuple);
|
||||
}
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(create_linspace_obj, 2, create_linspace);
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
/*
|
||||
* This file is part of the micropython-ulab project,
|
||||
*
|
||||
* https://github.com/v923z/micropython-ulab
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
|
||||
* 2019-2020 Zoltán Vörös
|
||||
*/
|
||||
|
||||
#ifndef _CREATE_
|
||||
#define _CREATE_
|
||||
|
||||
#include "ulab.h"
|
||||
#include "ndarray.h"
|
||||
|
||||
/*
|
||||
mp_obj_t create_zeros(size_t , const mp_obj_t *, mp_map_t *);
|
||||
mp_obj_t create_ones(size_t , const mp_obj_t *, mp_map_t *);
|
||||
mp_obj_t create_eye(size_t , const mp_obj_t *, mp_map_t *);
|
||||
mp_obj_t create_linspace(size_t , const mp_obj_t *, mp_map_t *);
|
||||
*/
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(create_ones_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(create_zeros_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(create_eye_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(create_linspace_obj);
|
||||
|
||||
#endif
|
||||
|
|
@ -19,24 +19,13 @@
|
|||
|
||||
#if ULAB_EXTRAS_MODULE
|
||||
|
||||
mp_obj_t extras_spectrogram(size_t n_args, const mp_obj_t *args) {
|
||||
if(n_args == 2) {
|
||||
return fft_fft_ifft_spectrum(n_args, args[0], args[1], FFT_SPECTRUM);
|
||||
} else {
|
||||
return fft_fft_ifft_spectrum(n_args, args[0], mp_const_none, FFT_SPECTRUM);
|
||||
}
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(extras_spectrogram_obj, 1, 2, extras_spectrogram);
|
||||
|
||||
STATIC const mp_rom_map_elem_t ulab_extras_globals_table[] = {
|
||||
STATIC const mp_rom_map_elem_t ulab_filter_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_extras) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_spectrogram), (mp_obj_t)&extras_spectrogram_obj },
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(mp_module_ulab_extras_globals, ulab_extras_globals_table);
|
||||
|
||||
mp_obj_module_t ulab_extras_module = {
|
||||
mp_obj_module_t ulab_filter_module = {
|
||||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_extras_globals,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@
|
|||
|
||||
#include "ulab.h"
|
||||
#include "ndarray.h"
|
||||
#include "fft.h"
|
||||
|
||||
#if ULAB_EXTRAS_MODULE
|
||||
|
||||
|
|
|
|||
19
code/fft.c
19
code/fft.c
|
|
@ -23,6 +23,12 @@
|
|||
|
||||
#if ULAB_FFT_MODULE
|
||||
|
||||
enum FFT_TYPE {
|
||||
FFT_FFT,
|
||||
FFT_IFFT,
|
||||
FFT_SPECTRUM,
|
||||
};
|
||||
|
||||
void fft_kernel(mp_float_t *real, mp_float_t *imag, int n, int isign) {
|
||||
// This is basically a modification of four1 from Numerical Recipes
|
||||
// The main difference is that this function takes two arrays, one
|
||||
|
|
@ -166,10 +172,22 @@ mp_obj_t fft_ifft(size_t n_args, const mp_obj_t *args) {
|
|||
|
||||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fft_ifft_obj, 1, 2, fft_ifft);
|
||||
|
||||
mp_obj_t fft_spectrum(size_t n_args, const mp_obj_t *args) {
|
||||
if(n_args == 2) {
|
||||
return fft_fft_ifft_spectrum(n_args, args[0], args[1], FFT_SPECTRUM);
|
||||
} else {
|
||||
return fft_fft_ifft_spectrum(n_args, args[0], mp_const_none, FFT_SPECTRUM);
|
||||
}
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fft_spectrum_obj, 1, 2, fft_spectrum);
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_rom_map_elem_t ulab_fft_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_fft) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_fft), (mp_obj_t)&fft_fft_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_ifft), (mp_obj_t)&fft_ifft_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_spectrum), (mp_obj_t)&fft_spectrum_obj },
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(mp_module_ulab_fft_globals, ulab_fft_globals_table);
|
||||
|
|
@ -178,5 +196,6 @@ mp_obj_module_t ulab_fft_module = {
|
|||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_fft_globals,
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -19,12 +19,6 @@
|
|||
|
||||
#define SWAP(t, a, b) { t tmp = a; a = b; b = tmp; }
|
||||
|
||||
enum FFT_TYPE {
|
||||
FFT_FFT,
|
||||
FFT_IFFT,
|
||||
FFT_SPECTRUM,
|
||||
};
|
||||
|
||||
#if ULAB_FFT_MODULE
|
||||
|
||||
extern mp_obj_module_t ulab_fft_module;
|
||||
|
|
@ -33,7 +27,5 @@ MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(fft_fft_obj);
|
|||
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(fft_ifft_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(fft_spectrum_obj);
|
||||
|
||||
mp_obj_t fft_fft_ifft_spectrum(size_t , mp_obj_t , mp_obj_t , uint8_t );
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -84,6 +84,7 @@ mp_obj_t filter_convolve(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
|
|||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(filter_convolve_obj, 2, filter_convolve);
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_rom_map_elem_t ulab_filter_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_filter) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_convolve), (mp_obj_t)&filter_convolve_obj },
|
||||
|
|
@ -95,5 +96,6 @@ mp_obj_module_t ulab_filter_module = {
|
|||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_filter_globals,
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
215
code/linalg.c
215
code/linalg.c
|
|
@ -19,19 +19,6 @@
|
|||
|
||||
#if ULAB_LINALG_MODULE
|
||||
|
||||
ndarray_obj_t *linalg_object_is_square(mp_obj_t obj) {
|
||||
// Returns an ndarray, if the object is a square ndarray,
|
||||
// raises the appropriate exception otherwise
|
||||
if(!MP_OBJ_IS_TYPE(obj, &ulab_ndarray_type)) {
|
||||
mp_raise_TypeError(translate("size is defined for ndarrays only"));
|
||||
}
|
||||
ndarray_obj_t *ndarray = MP_OBJ_TO_PTR(obj);
|
||||
if(ndarray->m != ndarray->n) {
|
||||
mp_raise_ValueError(translate("input must be square matrix"));
|
||||
}
|
||||
return ndarray;
|
||||
}
|
||||
|
||||
mp_obj_t linalg_size(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
|
|
@ -115,7 +102,17 @@ bool linalg_invert_matrix(mp_float_t *data, size_t N) {
|
|||
}
|
||||
|
||||
mp_obj_t linalg_inv(mp_obj_t o_in) {
|
||||
ndarray_obj_t *o = linalg_object_is_square(o_in);
|
||||
// since inv is not a class method, we have to inspect the input argument first
|
||||
if(!MP_OBJ_IS_TYPE(o_in, &ulab_ndarray_type)) {
|
||||
mp_raise_TypeError(translate("only ndarrays can be inverted"));
|
||||
}
|
||||
ndarray_obj_t *o = MP_OBJ_TO_PTR(o_in);
|
||||
if(!MP_OBJ_IS_TYPE(o_in, &ulab_ndarray_type)) {
|
||||
mp_raise_TypeError(translate("only ndarray objects can be inverted"));
|
||||
}
|
||||
if(o->m != o->n) {
|
||||
mp_raise_ValueError(translate("only square matrices can be inverted"));
|
||||
}
|
||||
ndarray_obj_t *inverted = create_new_ndarray(o->m, o->n, NDARRAY_FLOAT);
|
||||
mp_float_t *data = (mp_float_t *)inverted->array->items;
|
||||
mp_obj_t elem;
|
||||
|
|
@ -170,8 +167,104 @@ mp_obj_t linalg_dot(mp_obj_t _m1, mp_obj_t _m2) {
|
|||
|
||||
MP_DEFINE_CONST_FUN_OBJ_2(linalg_dot_obj, linalg_dot);
|
||||
|
||||
mp_obj_t linalg_zeros_ones(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args, uint8_t kind) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} } ,
|
||||
{ MP_QSTR_dtype, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = NDARRAY_FLOAT} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
uint8_t dtype = args[1].u_int;
|
||||
if(!MP_OBJ_IS_INT(args[0].u_obj) && !MP_OBJ_IS_TYPE(args[0].u_obj, &mp_type_tuple)) {
|
||||
mp_raise_TypeError(translate("input argument must be an integer or a 2-tuple"));
|
||||
}
|
||||
ndarray_obj_t *ndarray = NULL;
|
||||
if(MP_OBJ_IS_INT(args[0].u_obj)) {
|
||||
size_t n = mp_obj_get_int(args[0].u_obj);
|
||||
ndarray = create_new_ndarray(1, n, dtype);
|
||||
} else if(MP_OBJ_IS_TYPE(args[0].u_obj, &mp_type_tuple)) {
|
||||
mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(args[0].u_obj);
|
||||
if(tuple->len != 2) {
|
||||
mp_raise_TypeError(translate("input argument must be an integer or a 2-tuple"));
|
||||
}
|
||||
ndarray = create_new_ndarray(mp_obj_get_int(tuple->items[0]),
|
||||
mp_obj_get_int(tuple->items[1]), dtype);
|
||||
}
|
||||
if(kind == 1) {
|
||||
mp_obj_t one = mp_obj_new_int(1);
|
||||
for(size_t i=0; i < ndarray->array->len; i++) {
|
||||
mp_binary_set_val_array(dtype, ndarray->array->items, i, one);
|
||||
}
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(ndarray);
|
||||
}
|
||||
|
||||
mp_obj_t linalg_zeros(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
return linalg_zeros_ones(n_args, pos_args, kw_args, 0);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(linalg_zeros_obj, 0, linalg_zeros);
|
||||
|
||||
mp_obj_t linalg_ones(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
return linalg_zeros_ones(n_args, pos_args, kw_args, 1);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(linalg_ones_obj, 0, linalg_ones);
|
||||
|
||||
mp_obj_t linalg_eye(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
|
||||
{ MP_QSTR_M, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
{ MP_QSTR_k, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
|
||||
{ MP_QSTR_dtype, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = NDARRAY_FLOAT} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
size_t n = args[0].u_int, m;
|
||||
int16_t k = args[2].u_int;
|
||||
uint8_t dtype = args[3].u_int;
|
||||
if(args[1].u_rom_obj == mp_const_none) {
|
||||
m = n;
|
||||
} else {
|
||||
m = mp_obj_get_int(args[1].u_rom_obj);
|
||||
}
|
||||
|
||||
ndarray_obj_t *ndarray = create_new_ndarray(m, n, dtype);
|
||||
mp_obj_t one = mp_obj_new_int(1);
|
||||
size_t i = 0;
|
||||
if((k >= 0) && (k < n)) {
|
||||
while(k < n) {
|
||||
mp_binary_set_val_array(dtype, ndarray->array->items, i*n+k, one);
|
||||
k++;
|
||||
i++;
|
||||
}
|
||||
} else if((k < 0) && (-k < m)) {
|
||||
k = -k;
|
||||
i = 0;
|
||||
while(k < m) {
|
||||
mp_binary_set_val_array(dtype, ndarray->array->items, k*n+i, one);
|
||||
k++;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(ndarray);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(linalg_eye_obj, 0, linalg_eye);
|
||||
|
||||
mp_obj_t linalg_det(mp_obj_t oin) {
|
||||
ndarray_obj_t *in = linalg_object_is_square(oin);
|
||||
if(!MP_OBJ_IS_TYPE(oin, &ulab_ndarray_type)) {
|
||||
mp_raise_TypeError(translate("function defined for ndarrays only"));
|
||||
}
|
||||
ndarray_obj_t *in = MP_OBJ_TO_PTR(oin);
|
||||
if(in->m != in->n) {
|
||||
mp_raise_ValueError(translate("input must be square matrix"));
|
||||
}
|
||||
|
||||
mp_float_t *tmp = m_new(mp_float_t, in->n*in->n);
|
||||
for(size_t i=0; i < in->array->len; i++){
|
||||
tmp[i] = ndarray_get_float_value(in->array->items, in->array->typecode, i);
|
||||
|
|
@ -203,7 +296,13 @@ mp_obj_t linalg_det(mp_obj_t oin) {
|
|||
MP_DEFINE_CONST_FUN_OBJ_1(linalg_det_obj, linalg_det);
|
||||
|
||||
mp_obj_t linalg_eig(mp_obj_t oin) {
|
||||
ndarray_obj_t *in = linalg_object_is_square(oin);
|
||||
if(!MP_OBJ_IS_TYPE(oin, &ulab_ndarray_type)) {
|
||||
mp_raise_TypeError(translate("function defined for ndarrays only"));
|
||||
}
|
||||
ndarray_obj_t *in = MP_OBJ_TO_PTR(oin);
|
||||
if(in->m != in->n) {
|
||||
mp_raise_ValueError(translate("input must be square matrix"));
|
||||
}
|
||||
mp_float_t *array = m_new(mp_float_t, in->array->len);
|
||||
for(size_t i=0; i < in->array->len; i++) {
|
||||
array[i] = ndarray_get_float_value(in->array->items, in->array->typecode, i);
|
||||
|
|
@ -325,80 +424,17 @@ mp_obj_t linalg_eig(mp_obj_t oin) {
|
|||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(linalg_eig_obj, linalg_eig);
|
||||
|
||||
mp_obj_t linalg_cholesky(mp_obj_t oin) {
|
||||
ndarray_obj_t *in = MP_OBJ_TO_PTR(oin);
|
||||
ndarray_obj_t *L = create_new_ndarray(in->n, in->n, NDARRAY_FLOAT);
|
||||
mp_float_t *array = (mp_float_t *)L->array->items;
|
||||
|
||||
size_t pos = 0;
|
||||
for(size_t m=0; m < in->m; m++) { // rows
|
||||
for(size_t n=0; n < in->n; n++) { // columns
|
||||
array[m*in->m+n] = ndarray_get_float_value(in->array->items, in->array->typecode, pos++);
|
||||
}
|
||||
}
|
||||
|
||||
// make sure the matrix is symmetric
|
||||
for(size_t m=0; m < in->m; m++) { // rows
|
||||
for(size_t n=m+1; n < in->n; n++) { // columns
|
||||
// compare entry (m, n) to (n, m)
|
||||
if(epsilon < MICROPY_FLOAT_C_FUN(fabs)(array[m*in->n + n] - array[n*in->n + m])) {
|
||||
mp_raise_ValueError(translate("input matrix is asymmetric"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// this is actually not needed, but Cholesky in numpy returns the lower triangular matrix
|
||||
for(size_t i=0; i < in->m; i++) { // rows
|
||||
for(size_t j=i+1; j < in->n; j++) { // columns
|
||||
array[i*in->m + j] = 0.0;
|
||||
}
|
||||
}
|
||||
mp_float_t sum = 0.0;
|
||||
for(size_t i=0; i < in->m; i++) { // rows
|
||||
for(size_t j=0; j <= i; j++) { // columns
|
||||
sum = array[i*in->m + j];
|
||||
for(size_t k=0; k < j; k++) {
|
||||
sum -= array[i*in->n + k] * array[j*in->n + k];
|
||||
}
|
||||
if(i == j) {
|
||||
if(sum <= 0.0) {
|
||||
mp_raise_ValueError(translate("matrix is not positive definite"));
|
||||
} else {
|
||||
array[i*in->m+i] = MICROPY_FLOAT_C_FUN(sqrt)(sum);
|
||||
}
|
||||
} else {
|
||||
array[i*in->m + j] = sum / array[j*in->m+j];
|
||||
}
|
||||
}
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(L);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(linalg_cholesky_obj, linalg_cholesky);
|
||||
|
||||
mp_obj_t linalg_trace(mp_obj_t oin) {
|
||||
ndarray_obj_t *ndarray = linalg_object_is_square(oin);
|
||||
mp_float_t trace = 0.0;
|
||||
for(size_t pos=0; pos < ndarray->array->len; pos+=(ndarray->m+1)) {
|
||||
trace += ndarray_get_float_value(ndarray->array->items, ndarray->array->typecode, pos);
|
||||
}
|
||||
if(ndarray->array->typecode == NDARRAY_FLOAT) {
|
||||
return mp_obj_new_float(trace);
|
||||
}
|
||||
return mp_obj_new_int(trace);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(linalg_trace_obj, linalg_trace);
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_rom_map_elem_t ulab_linalg_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_linalg) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_size), (mp_obj_t)&linalg_size_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_inv), (mp_obj_t)&linalg_inv_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_dot), (mp_obj_t)&linalg_dot_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_det), (mp_obj_t)&linalg_det_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_eig), (mp_obj_t)&linalg_eig_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_cholesky), (mp_obj_t)&linalg_cholesky_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_trace), (mp_obj_t)&linalg_trace_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_linalg) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_size), (mp_obj_t)&linalg_size_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_inv), (mp_obj_t)&linalg_inv_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_dot), (mp_obj_t)&linalg_dot_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_zeros), (mp_obj_t)&linalg_zeros_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_ones), (mp_obj_t)&linalg_ones_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_eye), (mp_obj_t)&linalg_eye_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_det), (mp_obj_t)&linalg_det_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_eig), (mp_obj_t)&linalg_eig_obj },
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(mp_module_ulab_linalg_globals, ulab_linalg_globals_table);
|
||||
|
|
@ -407,5 +443,6 @@ mp_obj_module_t ulab_linalg_module = {
|
|||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_linalg_globals,
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -31,11 +31,5 @@ bool linalg_invert_matrix(mp_float_t *, size_t );
|
|||
|
||||
extern mp_obj_module_t ulab_linalg_module;
|
||||
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(linalg_size_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_1(linalg_inv_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_2(linalg_dot_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_1(linalg_det_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_1(linalg_eig_obj);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ USERMODULES_DIR := $(USERMOD_DIR)
|
|||
|
||||
# Add all C files to SRC_USERMOD.
|
||||
SRC_USERMOD += $(USERMODULES_DIR)/ndarray.c
|
||||
SRC_USERMOD += $(USERMODULES_DIR)/create.c
|
||||
SRC_USERMOD += $(USERMODULES_DIR)/linalg.c
|
||||
SRC_USERMOD += $(USERMODULES_DIR)/vectorise.c
|
||||
SRC_USERMOD += $(USERMODULES_DIR)/poly.c
|
||||
|
|
|
|||
352
code/ndarray.c
352
code/ndarray.c
|
|
@ -9,7 +9,6 @@
|
|||
* Copyright (c) 2019-2020 Zoltán Vörös
|
||||
*/
|
||||
|
||||
#include <unistd.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
|
@ -168,30 +167,8 @@ STATIC uint8_t ndarray_init_helper(size_t n_args, const mp_obj_t *pos_args, mp_m
|
|||
|
||||
STATIC mp_obj_t ndarray_make_new_core(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args, mp_map_t *kw_args) {
|
||||
uint8_t dtype = ndarray_init_helper(n_args, args, kw_args);
|
||||
|
||||
if(MP_OBJ_IS_TYPE(args[0], &ulab_ndarray_type)) {
|
||||
ndarray_obj_t *ndarray = MP_OBJ_TO_PTR(args[0]);
|
||||
if(dtype == ndarray->array->typecode) {
|
||||
return ndarray_copy(args[0]);
|
||||
}
|
||||
ndarray_obj_t *ndarray_new = create_new_ndarray(ndarray->m, ndarray->n, dtype);
|
||||
mp_obj_t item;
|
||||
if((ndarray->array->typecode == NDARRAY_FLOAT) &&(dtype != NDARRAY_FLOAT)) {
|
||||
for(size_t i=0; i < ndarray->array->len; i++) {
|
||||
mp_float_t f = ndarray_get_float_value(ndarray->array->items, ndarray->array->typecode, i);
|
||||
item = mp_obj_new_int((int32_t)MICROPY_FLOAT_C_FUN(floor)(f));
|
||||
mp_binary_set_val_array(dtype, ndarray_new->array->items, i, item);
|
||||
}
|
||||
} else {
|
||||
for(size_t i=0; i < ndarray->array->len; i++) {
|
||||
item = mp_binary_get_val_array(ndarray->array->typecode, ndarray->array->items, i);
|
||||
mp_binary_set_val_array(dtype, ndarray_new->array->items, i, item);
|
||||
}
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(ndarray_new);
|
||||
}
|
||||
|
||||
size_t len1, len2 = 0, i = 0;
|
||||
size_t len1, len2=0, i=0;
|
||||
mp_obj_t len_in = mp_obj_len_maybe(args[0]);
|
||||
if (len_in == MP_OBJ_NULL) {
|
||||
mp_raise_ValueError(translate("first argument must be an iterable"));
|
||||
|
|
@ -255,9 +232,9 @@ mp_obj_t ndarray_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
|
|||
#endif
|
||||
|
||||
size_t slice_length(mp_bound_slice_t slice) {
|
||||
ssize_t len, correction = 1;
|
||||
int32_t len, correction = 1;
|
||||
if(slice.step > 0) correction = -1;
|
||||
len = (ssize_t)(slice.stop - slice.start + (slice.step + correction)) / slice.step;
|
||||
len = (slice.stop - slice.start + (slice.step + correction)) / slice.step;
|
||||
if(len < 0) return 0;
|
||||
return (size_t)len;
|
||||
}
|
||||
|
|
@ -269,10 +246,10 @@ size_t true_length(mp_obj_t bool_list) {
|
|||
mp_obj_t item, iterable = mp_getiter(bool_list, &iter_buf);
|
||||
size_t trues = 0;
|
||||
while((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
|
||||
if(!mp_obj_is_bool(item)) {
|
||||
// numpy seems to be a little bit inconsistent in when an index is considered
|
||||
// to be True/False. Bail out immediately, if the items are not True/False
|
||||
mp_raise_TypeError(translate("wrong index type"));
|
||||
if(!MP_OBJ_IS_TYPE(item, &mp_type_bool)) {
|
||||
// numpy seems to be a little bit inconsistent in when an index is considered
|
||||
// to be True/False. Bail out immediately, if the items are not True/False
|
||||
return 0;
|
||||
}
|
||||
if(mp_obj_is_true(item)) {
|
||||
trues++;
|
||||
|
|
@ -285,7 +262,7 @@ mp_bound_slice_t generate_slice(mp_uint_t n, mp_obj_t index) {
|
|||
// micropython seems to have difficulties with negative steps
|
||||
mp_bound_slice_t slice;
|
||||
if(MP_OBJ_IS_TYPE(index, &mp_type_slice)) {
|
||||
mp_obj_slice_indices(index, n, &slice);
|
||||
mp_seq_get_fast_slice_indexes(n, index, &slice);
|
||||
} else if(MP_OBJ_IS_INT(index)) {
|
||||
int32_t _index = mp_obj_get_int(index);
|
||||
if(_index < 0) {
|
||||
|
|
@ -414,6 +391,10 @@ mp_obj_t iterate_slice_list(ndarray_obj_t *ndarray, size_t m, size_t n,
|
|||
mp_bound_slice_t row, mp_bound_slice_t column,
|
||||
mp_obj_t row_list, mp_obj_t column_list,
|
||||
ndarray_obj_t *values) {
|
||||
if((m == 0) || (n == 0)) {
|
||||
mp_raise_msg(&mp_type_IndexError, translate("empty index range"));
|
||||
}
|
||||
|
||||
if(values != NULL) {
|
||||
return insert_slice_list(ndarray, m, n, row, column, row_list, column_list, values);
|
||||
}
|
||||
|
|
@ -705,176 +686,155 @@ mp_obj_t ndarray_flatten(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
|
|||
}
|
||||
|
||||
// Binary operations
|
||||
ndarray_obj_t *ndarray_from_mp_obj(mp_obj_t obj) {
|
||||
// creates an ndarray from an micropython int or float
|
||||
// if the input is an ndarray, it is returned
|
||||
ndarray_obj_t *ndarray;
|
||||
if(MP_OBJ_IS_INT(obj)) {
|
||||
int32_t ivalue = mp_obj_get_int(obj);
|
||||
if((ivalue > 0) && (ivalue < 256)) {
|
||||
CREATE_SINGLE_ITEM(ndarray, uint8_t, NDARRAY_UINT8, ivalue);
|
||||
} else if((ivalue > 255) && (ivalue < 65535)) {
|
||||
CREATE_SINGLE_ITEM(ndarray, uint16_t, NDARRAY_UINT16, ivalue);
|
||||
} else if((ivalue < 0) && (ivalue > -128)) {
|
||||
CREATE_SINGLE_ITEM(ndarray, int8_t, NDARRAY_INT8, ivalue);
|
||||
} else if((ivalue < -127) && (ivalue > -32767)) {
|
||||
CREATE_SINGLE_ITEM(ndarray, int16_t, NDARRAY_INT16, ivalue);
|
||||
} else { // the integer value clearly does not fit the ulab types, so move on to float
|
||||
CREATE_SINGLE_ITEM(ndarray, mp_float_t, NDARRAY_FLOAT, ivalue);
|
||||
}
|
||||
} else if(mp_obj_is_float(obj)) {
|
||||
mp_float_t fvalue = mp_obj_get_float(obj);
|
||||
CREATE_SINGLE_ITEM(ndarray, mp_float_t, NDARRAY_FLOAT, fvalue);
|
||||
} else if(MP_OBJ_IS_TYPE(obj, &ulab_ndarray_type)){
|
||||
ndarray = MP_OBJ_TO_PTR(obj);
|
||||
} else {
|
||||
mp_raise_TypeError(translate("wrong operand type"));
|
||||
}
|
||||
return ndarray;
|
||||
}
|
||||
|
||||
mp_obj_t ndarray_binary_op(mp_binary_op_t _op, mp_obj_t lhs, mp_obj_t rhs) {
|
||||
// if the ndarray stands on the right hand side of the expression, simply swap the operands
|
||||
ndarray_obj_t *ol, *or;
|
||||
mp_binary_op_t op = _op;
|
||||
if((op == MP_BINARY_OP_REVERSE_ADD) || (op == MP_BINARY_OP_REVERSE_MULTIPLY) ||
|
||||
(op == MP_BINARY_OP_REVERSE_POWER) || (op == MP_BINARY_OP_REVERSE_SUBTRACT) ||
|
||||
(op == MP_BINARY_OP_REVERSE_TRUE_DIVIDE)) {
|
||||
ol = ndarray_from_mp_obj(rhs);
|
||||
or = ndarray_from_mp_obj(lhs);
|
||||
} else {
|
||||
ol = ndarray_from_mp_obj(lhs);
|
||||
or = ndarray_from_mp_obj(rhs);
|
||||
}
|
||||
if(op == MP_BINARY_OP_REVERSE_ADD) {
|
||||
op = MP_BINARY_OP_ADD;
|
||||
} else if(op == MP_BINARY_OP_REVERSE_MULTIPLY) {
|
||||
op = MP_BINARY_OP_MULTIPLY;
|
||||
} else if(op == MP_BINARY_OP_REVERSE_POWER) {
|
||||
op = MP_BINARY_OP_POWER;
|
||||
} else if(op == MP_BINARY_OP_REVERSE_SUBTRACT) {
|
||||
op = MP_BINARY_OP_SUBTRACT;
|
||||
} else if(op == MP_BINARY_OP_REVERSE_TRUE_DIVIDE) {
|
||||
op = MP_BINARY_OP_TRUE_DIVIDE;
|
||||
}
|
||||
mp_obj_t ndarray_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
|
||||
// if(op == MP_BINARY_OP_REVERSE_ADD) {
|
||||
// return ndarray_binary_op(MP_BINARY_OP_ADD, rhs, lhs);
|
||||
// }
|
||||
// One of the operands is a scalar
|
||||
// TODO: conform to numpy with the upcasting
|
||||
// TODO: implement in-place operators
|
||||
// these are partial broadcasting rules: either the two arrays
|
||||
// are of the same shape, or one of them is of length 1
|
||||
if(((ol->m != or->m) || (ol->n != or->n))) {
|
||||
if((ol->array->len != 1) && (or->array->len != 1)) {
|
||||
if(op == MP_BINARY_OP_EQUAL) {
|
||||
return mp_const_false;
|
||||
} else if(op == MP_BINARY_OP_NOT_EQUAL) {
|
||||
return mp_const_true;
|
||||
}
|
||||
mp_obj_t RHS = MP_OBJ_NULL;
|
||||
bool rhs_is_scalar = true;
|
||||
if(MP_OBJ_IS_INT(rhs)) {
|
||||
int32_t ivalue = mp_obj_get_int(rhs);
|
||||
if((ivalue > 0) && (ivalue < 256)) {
|
||||
CREATE_SINGLE_ITEM(RHS, uint8_t, NDARRAY_UINT8, ivalue);
|
||||
} else if((ivalue > 255) && (ivalue < 65535)) {
|
||||
CREATE_SINGLE_ITEM(RHS, uint16_t, NDARRAY_UINT16, ivalue);
|
||||
} else if((ivalue < 0) && (ivalue > -128)) {
|
||||
CREATE_SINGLE_ITEM(RHS, int8_t, NDARRAY_INT8, ivalue);
|
||||
} else if((ivalue < -127) && (ivalue > -32767)) {
|
||||
CREATE_SINGLE_ITEM(RHS, int16_t, NDARRAY_INT16, ivalue);
|
||||
} else { // the integer value clearly does not fit the ulab types, so move on to float
|
||||
CREATE_SINGLE_ITEM(RHS, mp_float_t, NDARRAY_FLOAT, ivalue);
|
||||
}
|
||||
} else if(mp_obj_is_float(rhs)) {
|
||||
mp_float_t fvalue = mp_obj_get_float(rhs);
|
||||
CREATE_SINGLE_ITEM(RHS, mp_float_t, NDARRAY_FLOAT, fvalue);
|
||||
} else {
|
||||
RHS = rhs;
|
||||
rhs_is_scalar = false;
|
||||
}
|
||||
//else
|
||||
if(MP_OBJ_IS_TYPE(lhs, &ulab_ndarray_type) && MP_OBJ_IS_TYPE(RHS, &ulab_ndarray_type)) {
|
||||
// next, the ndarray stuff
|
||||
ndarray_obj_t *ol = MP_OBJ_TO_PTR(lhs);
|
||||
ndarray_obj_t *or = MP_OBJ_TO_PTR(RHS);
|
||||
if(!rhs_is_scalar && ((ol->m != or->m) || (ol->n != or->n))) {
|
||||
mp_raise_ValueError(translate("operands could not be broadcast together"));
|
||||
}
|
||||
}
|
||||
uint8_t linc = ol->array->len == 1 ? 0 : 1;
|
||||
uint8_t rinc = or->array->len == 1 ? 0 : 1;
|
||||
// do the partial broadcasting here
|
||||
size_t m = MAX(ol->m, or->m);
|
||||
size_t n = MAX(ol->n, or->n);
|
||||
size_t len = MAX(ol->array->len, or->array->len);
|
||||
if((ol->array->len == 0) || (or->array->len == 0)) {
|
||||
len = 0;
|
||||
}
|
||||
switch(op) {
|
||||
case MP_BINARY_OP_EQUAL:
|
||||
case MP_BINARY_OP_NOT_EQUAL:
|
||||
case MP_BINARY_OP_LESS:
|
||||
case MP_BINARY_OP_LESS_EQUAL:
|
||||
case MP_BINARY_OP_MORE:
|
||||
case MP_BINARY_OP_MORE_EQUAL:
|
||||
case MP_BINARY_OP_ADD:
|
||||
case MP_BINARY_OP_SUBTRACT:
|
||||
case MP_BINARY_OP_TRUE_DIVIDE:
|
||||
case MP_BINARY_OP_MULTIPLY:
|
||||
case MP_BINARY_OP_POWER:
|
||||
// TODO: I believe, this part can be made significantly smaller (compiled size)
|
||||
// by doing only the typecasting in the large ifs, and moving the loops outside
|
||||
// These are the upcasting rules
|
||||
// float always becomes float
|
||||
// operation on identical types preserves type
|
||||
// uint8 + int8 => int16
|
||||
// uint8 + int16 => int16
|
||||
// uint8 + uint16 => uint16
|
||||
// int8 + int16 => int16
|
||||
// int8 + uint16 => uint16
|
||||
// uint16 + int16 => float
|
||||
// The parameters of RUN_BINARY_LOOP are
|
||||
// typecode of result, type_out, type_left, type_right, lhs operand, rhs operand, operator
|
||||
if(ol->array->typecode == NDARRAY_UINT8) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT8, uint8_t, uint8_t, uint8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, uint8_t, int8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint8_t, uint16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, uint8_t, int16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint8_t, mp_float_t, ol, or, op, m, n, len, linc, rinc);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_INT8) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int8_t, uint8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT8, int8_t, int8_t, int8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int8_t, uint16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int8_t, int16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, int8_t, mp_float_t, ol, or, op, m, n, len, linc, rinc);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_UINT16) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint16_t, uint8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint16_t, int8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint16_t, uint16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint16_t, int16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint8_t, mp_float_t, ol, or, op, m, n, len, linc, rinc);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_INT16) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int16_t, uint8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int16_t, int8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, int16_t, uint16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int16_t, int16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint16_t, mp_float_t, ol, or, op, m, n, len, linc, rinc);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_FLOAT) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, uint8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, int8_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, uint16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, int16_t, ol, or, op, m, n, len, linc, rinc);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, mp_float_t, ol, or, op, m, n, len, linc, rinc);
|
||||
}
|
||||
}
|
||||
// this instruction should never be reached, but we have to make the compiler happy
|
||||
return MP_OBJ_NULL;
|
||||
break;
|
||||
default:
|
||||
return MP_OBJ_NULL; // op not supported
|
||||
break;
|
||||
}
|
||||
return MP_OBJ_NULL;
|
||||
}
|
||||
// At this point, the operands should have the same shape
|
||||
switch(op) {
|
||||
case MP_BINARY_OP_EQUAL:
|
||||
// Two arrays are equal, if their shape, typecode, and elements are equal
|
||||
if((ol->m != or->m) || (ol->n != or->n) || (ol->array->typecode != or->array->typecode)) {
|
||||
return mp_const_false;
|
||||
} else {
|
||||
size_t i = ol->bytes;
|
||||
uint8_t *l = (uint8_t *)ol->array->items;
|
||||
uint8_t *r = (uint8_t *)or->array->items;
|
||||
while(i) { // At this point, we can simply compare the bytes, the type is irrelevant
|
||||
if(*l++ != *r++) {
|
||||
return mp_const_false;
|
||||
}
|
||||
i--;
|
||||
}
|
||||
return mp_const_true;
|
||||
}
|
||||
break;
|
||||
case MP_BINARY_OP_LESS:
|
||||
case MP_BINARY_OP_LESS_EQUAL:
|
||||
case MP_BINARY_OP_MORE:
|
||||
case MP_BINARY_OP_MORE_EQUAL:
|
||||
case MP_BINARY_OP_ADD:
|
||||
case MP_BINARY_OP_SUBTRACT:
|
||||
case MP_BINARY_OP_TRUE_DIVIDE:
|
||||
case MP_BINARY_OP_MULTIPLY:
|
||||
// TODO: I believe, this part can be made significantly smaller (compiled size)
|
||||
// by doing only the typecasting in the large ifs, and moving the loops outside
|
||||
// These are the upcasting rules
|
||||
// float always becomes float
|
||||
// operation on identical types preserves type
|
||||
// uint8 + int8 => int16
|
||||
// uint8 + int16 => int16
|
||||
// uint8 + uint16 => uint16
|
||||
// int8 + int16 => int16
|
||||
// int8 + uint16 => uint16
|
||||
// uint16 + int16 => float
|
||||
// The parameters of RUN_BINARY_LOOP are
|
||||
// typecode of result, type_out, type_left, type_right, lhs operand, rhs operand, operator
|
||||
if(ol->array->typecode == NDARRAY_UINT8) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT8, uint8_t, uint8_t, uint8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, uint8_t, int8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint8_t, uint16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, uint8_t, int16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint8_t, mp_float_t, ol, or, op);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_INT8) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int8_t, uint8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT8, int8_t, int8_t, int8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int8_t, uint16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int8_t, int16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, int8_t, mp_float_t, ol, or, op);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_UINT16) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint16_t, uint8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint16_t, int8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_UINT16, uint16_t, uint16_t, uint16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint16_t, int16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint8_t, mp_float_t, ol, or, op);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_INT16) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int16_t, uint8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int16_t, int8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, int16_t, uint16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_INT16, int16_t, int16_t, int16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, uint16_t, mp_float_t, ol, or, op);
|
||||
}
|
||||
} else if(ol->array->typecode == NDARRAY_FLOAT) {
|
||||
if(or->array->typecode == NDARRAY_UINT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, uint8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT8) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, int8_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_UINT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, uint16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_INT16) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, int16_t, ol, or, op);
|
||||
} else if(or->array->typecode == NDARRAY_FLOAT) {
|
||||
RUN_BINARY_LOOP(NDARRAY_FLOAT, mp_float_t, mp_float_t, mp_float_t, ol, or, op);
|
||||
}
|
||||
} else { // this should never happen
|
||||
mp_raise_TypeError(translate("wrong input type"));
|
||||
}
|
||||
// this instruction should never be reached, but we have to make the compiler happy
|
||||
return MP_OBJ_NULL;
|
||||
default:
|
||||
return MP_OBJ_NULL; // op not supported
|
||||
}
|
||||
} else {
|
||||
mp_raise_TypeError(translate("wrong operand type on the right hand side"));
|
||||
}
|
||||
}
|
||||
|
||||
mp_obj_t ndarray_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
|
||||
|
|
|
|||
|
|
@ -25,9 +25,7 @@
|
|||
#define FLOAT_TYPECODE 'd'
|
||||
#endif
|
||||
|
||||
#if CIRCUITPY
|
||||
#define mp_obj_is_bool(o) (MP_OBJ_IS_TYPE((o), &mp_type_bool))
|
||||
#else
|
||||
#if !CIRCUITPY
|
||||
#define translate(x) x
|
||||
#endif
|
||||
|
||||
|
|
@ -101,38 +99,45 @@ mp_int_t ndarray_get_buffer(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t f
|
|||
should work outside the loop, but it doesn't. Go figure!
|
||||
*/
|
||||
|
||||
#define RUN_BINARY_LOOP(typecode, type_out, type_left, type_right, ol, or, op, m, n, len, linc, rinc) do {\
|
||||
#define RUN_BINARY_LOOP(typecode, type_out, type_left, type_right, ol, or, op) do {\
|
||||
type_left *left = (type_left *)(ol)->array->items;\
|
||||
type_right *right = (type_right *)(or)->array->items;\
|
||||
if(((op) == MP_BINARY_OP_ADD) || ((op) == MP_BINARY_OP_SUBTRACT) || ((op) == MP_BINARY_OP_MULTIPLY) || ((op) == MP_BINARY_OP_POWER)) {\
|
||||
ndarray_obj_t *out = create_new_ndarray((m), (n), (typecode));\
|
||||
uint8_t inc = 0;\
|
||||
if((or)->array->len > 1) inc = 1;\
|
||||
if(((op) == MP_BINARY_OP_ADD) || ((op) == MP_BINARY_OP_SUBTRACT) || ((op) == MP_BINARY_OP_MULTIPLY)) {\
|
||||
ndarray_obj_t *out = create_new_ndarray(ol->m, ol->n, typecode);\
|
||||
type_out *(odata) = (type_out *)out->array->items;\
|
||||
if((op) == MP_BINARY_OP_ADD) { for(size_t i=0; i < (len); i++, left+=linc, right+=rinc) *odata++ = *left + *right; }\
|
||||
else if((op) == MP_BINARY_OP_MULTIPLY) { for(size_t i=0; i < (len); i++, left+=linc, right+=rinc) *odata++ = *left * *right; }\
|
||||
else if((op) == MP_BINARY_OP_POWER) { for(size_t i=0; i < (len); i++, left+=linc, right+=rinc) *odata++ = MICROPY_FLOAT_C_FUN(pow)(*left, *right); }\
|
||||
else if((op) == MP_BINARY_OP_SUBTRACT) { for(size_t i=0; i < (len); i++, left+=linc, right+=rinc) *odata++ = *left - *right; }\
|
||||
if((op) == MP_BINARY_OP_ADD) { for(size_t i=0, j=0; i < (ol)->array->len; i++, j+=inc) odata[i] = left[i] + right[j];}\
|
||||
if((op) == MP_BINARY_OP_SUBTRACT) { for(size_t i=0, j=0; i < (ol)->array->len; i++, j+=inc) odata[i] = left[i] - right[j];}\
|
||||
if((op) == MP_BINARY_OP_MULTIPLY) { for(size_t i=0, j=0; i < (ol)->array->len; i++, j+=inc) odata[i] = left[i] * right[j];}\
|
||||
return MP_OBJ_FROM_PTR(out);\
|
||||
} else if((op) == MP_BINARY_OP_TRUE_DIVIDE) {\
|
||||
ndarray_obj_t *out = create_new_ndarray((m), (n), NDARRAY_FLOAT);\
|
||||
} else if((op) == MP_BINARY_OP_TRUE_DIVIDE) {\
|
||||
ndarray_obj_t *out = create_new_ndarray(ol->m, ol->n, NDARRAY_FLOAT);\
|
||||
mp_float_t *odata = (mp_float_t *)out->array->items;\
|
||||
for(size_t i=0; i < (len); i++, left+=linc, right+=rinc) {*odata++ = (mp_float_t)(*left)/(mp_float_t)(*right);}\
|
||||
for(size_t i=0, j=0; i < (ol)->array->len; i++, j+=inc) odata[i] = (mp_float_t)left[i]/(mp_float_t)right[j];\
|
||||
return MP_OBJ_FROM_PTR(out);\
|
||||
} else if(((op) == MP_BINARY_OP_LESS) || ((op) == MP_BINARY_OP_LESS_EQUAL) || \
|
||||
((op) == MP_BINARY_OP_MORE) || ((op) == MP_BINARY_OP_MORE_EQUAL) || \
|
||||
((op) == MP_BINARY_OP_EQUAL) || ((op) == MP_BINARY_OP_NOT_EQUAL)) {\
|
||||
} else if(((op) == MP_BINARY_OP_LESS) || ((op) == MP_BINARY_OP_LESS_EQUAL) || \
|
||||
((op) == MP_BINARY_OP_MORE) || ((op) == MP_BINARY_OP_MORE_EQUAL)) {\
|
||||
mp_obj_t out_list = mp_obj_new_list(0, NULL);\
|
||||
for(size_t i=0; i < m; i++) {\
|
||||
size_t m = (ol)->m, n = (ol)->n;\
|
||||
for(size_t i=0, r=0; i < m; i++, r+=inc) {\
|
||||
mp_obj_t row = mp_obj_new_list(n, NULL);\
|
||||
mp_obj_list_t *row_ptr = MP_OBJ_TO_PTR(row);\
|
||||
if((op) == MP_BINARY_OP_LESS) { for(size_t j=0; j < n; j++, left+=linc, right+=rinc) row_ptr->items[j] = *left < *right ? mp_const_true : mp_const_false; }\
|
||||
else if((op) == MP_BINARY_OP_LESS_EQUAL) { for(size_t j=0; j < n; j++, left+=linc, right+=rinc) row_ptr->items[j] = *left <= *right ? mp_const_true : mp_const_false; }\
|
||||
else if((op) == MP_BINARY_OP_MORE) { for(size_t j=0; j < n; j++, left+=linc, right+=rinc) row_ptr->items[j] = *left > *right ? mp_const_true : mp_const_false; }\
|
||||
else if((op) == MP_BINARY_OP_MORE_EQUAL) { for(size_t j=0; j < n; j++, left+=linc, right+=rinc) row_ptr->items[j] = *left >= *right ? mp_const_true : mp_const_false; }\
|
||||
else if((op) == MP_BINARY_OP_EQUAL) { for(size_t j=0; j < n; j++, left+=linc, right+=rinc) row_ptr->items[j] = *left == *right ? mp_const_true : mp_const_false; }\
|
||||
else if((op) == MP_BINARY_OP_NOT_EQUAL) { for(size_t j=0; j < n; j++, left+=linc, right+=rinc) row_ptr->items[j] = *left != *right ? mp_const_true : mp_const_false; }\
|
||||
for(size_t j=0, s=0; j < n; j++, s+=inc) {\
|
||||
row_ptr->items[j] = mp_const_false;\
|
||||
if((op) == MP_BINARY_OP_LESS) {\
|
||||
if(left[i*n+j] < right[r*n+s]) row_ptr->items[j] = mp_const_true;\
|
||||
} else if((op) == MP_BINARY_OP_LESS_EQUAL) {\
|
||||
if(left[i*n+j] <= right[r*n+s]) row_ptr->items[j] = mp_const_true;\
|
||||
} else if((op) == MP_BINARY_OP_MORE) {\
|
||||
if(left[i*n+j] > right[r*n+s]) row_ptr->items[j] = mp_const_true;\
|
||||
} else if((op) == MP_BINARY_OP_MORE_EQUAL) {\
|
||||
if(left[i*n+j] >= right[r*n+s]) row_ptr->items[j] = mp_const_true;\
|
||||
}\
|
||||
}\
|
||||
if(m == 1) return row;\
|
||||
mp_obj_list_append(out_list, row);\
|
||||
}\
|
||||
}\
|
||||
return out_list;\
|
||||
}\
|
||||
} while(0)
|
||||
|
|
|
|||
|
|
@ -20,42 +20,43 @@
|
|||
|
||||
#include "ndarray.h"
|
||||
|
||||
#if CIRCUITPY
|
||||
typedef struct _mp_obj_property_t {
|
||||
mp_obj_base_t base;
|
||||
mp_obj_t proxy[3]; // getter, setter, deleter
|
||||
} mp_obj_property_t;
|
||||
|
||||
/* v923z: it is not at all clear to me, why this must be declared; it should already be in obj.h */
|
||||
typedef struct _mp_obj_none_t {
|
||||
mp_obj_base_t base;
|
||||
} mp_obj_none_t;
|
||||
|
||||
const mp_obj_type_t mp_type_NoneType;
|
||||
const mp_obj_none_t mp_const_none_obj = {{&mp_type_NoneType}};
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(ndarray_get_shape_obj, ndarray_shape);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(ndarray_get_size_obj, ndarray_size);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(ndarray_get_itemsize_obj, ndarray_itemsize);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(ndarray_flatten_obj, 1, ndarray_flatten);
|
||||
|
||||
STATIC const mp_obj_property_t ndarray_shape_obj = {
|
||||
.base.type = &mp_type_property,
|
||||
.proxy = {(mp_obj_t)&ndarray_get_shape_obj,
|
||||
mp_const_none,
|
||||
mp_const_none },
|
||||
(mp_obj_t)&mp_const_none_obj,
|
||||
(mp_obj_t)&mp_const_none_obj},
|
||||
};
|
||||
|
||||
STATIC const mp_obj_property_t ndarray_size_obj = {
|
||||
.base.type = &mp_type_property,
|
||||
.proxy = {(mp_obj_t)&ndarray_get_size_obj,
|
||||
mp_const_none,
|
||||
mp_const_none },
|
||||
(mp_obj_t)&mp_const_none_obj,
|
||||
(mp_obj_t)&mp_const_none_obj},
|
||||
};
|
||||
|
||||
STATIC const mp_obj_property_t ndarray_itemsize_obj = {
|
||||
.base.type = &mp_type_property,
|
||||
.proxy = {(mp_obj_t)&ndarray_get_itemsize_obj,
|
||||
mp_const_none,
|
||||
mp_const_none },
|
||||
(mp_obj_t)&mp_const_none_obj,
|
||||
(mp_obj_t)&mp_const_none_obj},
|
||||
};
|
||||
#else
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(ndarray_size_obj, ndarray_size);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(ndarray_itemsize_obj, ndarray_itemsize);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(ndarray_shape_obj, ndarray_shape);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -31,6 +31,57 @@ enum NUMERICAL_FUNCTION_TYPE {
|
|||
NUMERICAL_STD,
|
||||
};
|
||||
|
||||
mp_obj_t numerical_linspace(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
||||
{ MP_QSTR_num, MP_ARG_INT, {.u_int = 50} },
|
||||
{ MP_QSTR_endpoint, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_true} },
|
||||
{ MP_QSTR_retstep, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_false} },
|
||||
{ MP_QSTR_dtype, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = NDARRAY_FLOAT} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(2, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
uint16_t len = args[2].u_int;
|
||||
if(len < 2) {
|
||||
mp_raise_ValueError(translate("number of points must be at least 2"));
|
||||
}
|
||||
mp_float_t value, step;
|
||||
value = mp_obj_get_float(args[0].u_obj);
|
||||
uint8_t typecode = args[5].u_int;
|
||||
if(args[3].u_obj == mp_const_true) step = (mp_obj_get_float(args[1].u_obj)-value)/(len-1);
|
||||
else step = (mp_obj_get_float(args[1].u_obj)-value)/len;
|
||||
ndarray_obj_t *ndarray = create_new_ndarray(1, len, typecode);
|
||||
if(typecode == NDARRAY_UINT8) {
|
||||
uint8_t *array = (uint8_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (uint8_t)value;
|
||||
} else if(typecode == NDARRAY_INT8) {
|
||||
int8_t *array = (int8_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (int8_t)value;
|
||||
} else if(typecode == NDARRAY_UINT16) {
|
||||
uint16_t *array = (uint16_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (uint16_t)value;
|
||||
} else if(typecode == NDARRAY_INT16) {
|
||||
int16_t *array = (int16_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = (int16_t)value;
|
||||
} else {
|
||||
mp_float_t *array = (mp_float_t *)ndarray->array->items;
|
||||
for(size_t i=0; i < len; i++, value += step) array[i] = value;
|
||||
}
|
||||
if(args[4].u_obj == mp_const_false) {
|
||||
return MP_OBJ_FROM_PTR(ndarray);
|
||||
} else {
|
||||
mp_obj_t tuple[2];
|
||||
tuple[0] = ndarray;
|
||||
tuple[1] = mp_obj_new_float(step);
|
||||
return mp_obj_new_tuple(2, tuple);
|
||||
}
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(numerical_linspace_obj, 2, numerical_linspace);
|
||||
|
||||
void axis_sorter(ndarray_obj_t *ndarray, mp_obj_t axis, size_t *m, size_t *n, size_t *N,
|
||||
size_t *increment, size_t *len, size_t *start_inc) {
|
||||
if(axis == mp_const_none) { // flatten the array
|
||||
|
|
@ -201,9 +252,6 @@ mp_obj_t numerical_argmin_argmax_ndarray(ndarray_obj_t *ndarray, mp_obj_t axis,
|
|||
}
|
||||
}
|
||||
}
|
||||
if(results->array->len == 1) {
|
||||
return mp_binary_get_val_array(results->array->typecode, results->array->items, 0);
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(results);
|
||||
}
|
||||
|
||||
|
|
@ -554,7 +602,7 @@ mp_obj_t numerical_sort_helper(mp_obj_t oin, mp_obj_t axis, uint8_t inplace) {
|
|||
} else if(mp_obj_get_int(axis) == 0) { // sort along vertical axis
|
||||
increment = ndarray->n;
|
||||
start_inc = 1;
|
||||
end = ndarray->n;
|
||||
end = ndarray->m;
|
||||
N = ndarray->m;
|
||||
} else {
|
||||
mp_raise_ValueError(translate("axis must be -1, 0, None, or 1"));
|
||||
|
|
@ -563,7 +611,7 @@ mp_obj_t numerical_sort_helper(mp_obj_t oin, mp_obj_t axis, uint8_t inplace) {
|
|||
size_t q, k, p, c;
|
||||
|
||||
for(size_t start=0; start < end; start+=start_inc) {
|
||||
q = N;
|
||||
q = N;
|
||||
k = (q >> 1);
|
||||
if((ndarray->array->typecode == NDARRAY_UINT8) || (ndarray->array->typecode == NDARRAY_INT8)) {
|
||||
HEAPSORT(uint8_t, ndarray);
|
||||
|
|
@ -645,7 +693,7 @@ mp_obj_t numerical_argsort(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw
|
|||
n = ndarray->n;
|
||||
increment = n;
|
||||
start_inc = 1;
|
||||
end = n;
|
||||
end = m;
|
||||
N = m;
|
||||
} else {
|
||||
mp_raise_ValueError(translate("axis must be -1, 0, None, or 1"));
|
||||
|
|
@ -682,8 +730,9 @@ mp_obj_t numerical_argsort(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw
|
|||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(numerical_argsort_obj, 1, numerical_argsort);
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_rom_map_elem_t ulab_numerical_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_numerical) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_linspace), (mp_obj_t)&numerical_linspace_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_sum), (mp_obj_t)&numerical_sum_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_mean), (mp_obj_t)&numerical_mean_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_std), (mp_obj_t)&numerical_std_obj },
|
||||
|
|
@ -704,5 +753,6 @@ mp_obj_module_t ulab_numerical_module = {
|
|||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_numerical_globals,
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -79,34 +79,33 @@ extern mp_obj_module_t ulab_numerical_module;
|
|||
|
||||
#define HEAPSORT(type, ndarray) do {\
|
||||
type *array = (type *)(ndarray)->array->items;\
|
||||
array += start;\
|
||||
type tmp;\
|
||||
for (;;) {\
|
||||
if (k > 0) {\
|
||||
tmp = array[(--k)*increment];\
|
||||
tmp = array[start+(--k)*increment];\
|
||||
} else {\
|
||||
q--;\
|
||||
if(q == 0) {\
|
||||
break;\
|
||||
}\
|
||||
tmp = array[q*increment];\
|
||||
array[q*increment] = array[0];\
|
||||
tmp = array[start+q*increment];\
|
||||
array[start+q*increment] = array[start];\
|
||||
}\
|
||||
p = k;\
|
||||
c = k + k + 1;\
|
||||
while (c < q) {\
|
||||
if((c + 1 < q) && (array[(c+1)*increment] > array[c*increment])) {\
|
||||
if((c + 1 < q) && (array[start+(c+1)*increment] > array[start+c*increment])) {\
|
||||
c++;\
|
||||
}\
|
||||
if(array[c*increment] > tmp) {\
|
||||
array[p*increment] = array[c*increment];\
|
||||
if(array[start+c*increment] > tmp) {\
|
||||
array[start+p*increment] = array[start+c*increment];\
|
||||
p = c;\
|
||||
c = p + p + 1;\
|
||||
} else {\
|
||||
break;\
|
||||
}\
|
||||
}\
|
||||
array[p*increment] = tmp;\
|
||||
array[start+p*increment] = tmp;\
|
||||
}\
|
||||
} while(0)
|
||||
|
||||
|
|
@ -149,6 +148,7 @@ extern mp_obj_module_t ulab_numerical_module;
|
|||
}\
|
||||
} while(0)
|
||||
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(numerical_linspace_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(numerical_min_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(numerical_max_obj);
|
||||
MP_DECLARE_CONST_FUN_OBJ_KW(numerical_argmin_obj);
|
||||
|
|
|
|||
|
|
@ -197,6 +197,7 @@ mp_obj_t poly_polyfit(size_t n_args, const mp_obj_t *args) {
|
|||
|
||||
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(poly_polyfit_obj, 2, 3, poly_polyfit);
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_rom_map_elem_t ulab_poly_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_poly) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_polyval), (mp_obj_t)&poly_polyval_obj },
|
||||
|
|
@ -209,5 +210,6 @@ mp_obj_module_t ulab_poly_module = {
|
|||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_poly_globals,
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
20
code/ulab.c
20
code/ulab.c
|
|
@ -21,7 +21,6 @@
|
|||
#include "ulab.h"
|
||||
#include "ndarray.h"
|
||||
#include "ndarray_properties.h"
|
||||
#include "create.h"
|
||||
#include "linalg.h"
|
||||
#include "vectorise.h"
|
||||
#include "poly.h"
|
||||
|
|
@ -30,29 +29,22 @@
|
|||
#include "numerical.h"
|
||||
#include "extras.h"
|
||||
|
||||
STATIC MP_DEFINE_STR_OBJ(ulab_version_obj, "0.41.0");
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(ndarray_flatten_obj, 1, ndarray_flatten);
|
||||
STATIC MP_DEFINE_STR_OBJ(ulab_version_obj, "0.34.0");
|
||||
|
||||
STATIC const mp_rom_map_elem_t ulab_ndarray_locals_dict_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR_flatten), MP_ROM_PTR(&ndarray_flatten_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_reshape), MP_ROM_PTR(&ndarray_reshape_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_transpose), MP_ROM_PTR(&ndarray_transpose_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_flatten), MP_ROM_PTR(&ndarray_flatten_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_shape), MP_ROM_PTR(&ndarray_shape_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_size), MP_ROM_PTR(&ndarray_size_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_itemsize), MP_ROM_PTR(&ndarray_itemsize_obj) },
|
||||
#if CIRCUITPY
|
||||
{ MP_ROM_QSTR(MP_QSTR_sort), MP_ROM_PTR(&numerical_sort_inplace_obj) },
|
||||
#endif
|
||||
// { MP_ROM_QSTR(MP_QSTR_sort), MP_ROM_PTR(&numerical_sort_inplace_obj) },
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(ulab_ndarray_locals_dict, ulab_ndarray_locals_dict_table);
|
||||
|
||||
const mp_obj_type_t ulab_ndarray_type = {
|
||||
{ &mp_type_type },
|
||||
#if defined(MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE) && defined(MP_TYPE_FLAG_EQ_HAS_NEQ_TEST)
|
||||
.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE | MP_TYPE_FLAG_EQ_HAS_NEQ_TEST,
|
||||
#endif
|
||||
.name = MP_QSTR_ndarray,
|
||||
.print = ndarray_print,
|
||||
.make_new = ndarray_make_new,
|
||||
|
|
@ -64,14 +56,11 @@ const mp_obj_type_t ulab_ndarray_type = {
|
|||
.locals_dict = (mp_obj_dict_t*)&ulab_ndarray_locals_dict,
|
||||
};
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_map_elem_t ulab_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_ulab) },
|
||||
{ MP_ROM_QSTR(MP_QSTR___version__), MP_ROM_PTR(&ulab_version_obj) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_array), (mp_obj_t)&ulab_ndarray_type },
|
||||
{ MP_ROM_QSTR(MP_QSTR_zeros), (mp_obj_t)&create_zeros_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_ones), (mp_obj_t)&create_ones_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_eye), (mp_obj_t)&create_eye_obj },
|
||||
{ MP_ROM_QSTR(MP_QSTR_linspace), (mp_obj_t)&create_linspace_obj },
|
||||
#if ULAB_LINALG_MODULE
|
||||
{ MP_ROM_QSTR(MP_QSTR_linalg), MP_ROM_PTR(&ulab_linalg_module) },
|
||||
#endif
|
||||
|
|
@ -112,3 +101,4 @@ mp_obj_module_t ulab_user_cmodule = {
|
|||
};
|
||||
|
||||
MP_REGISTER_MODULE(MP_QSTR_ulab, ulab_user_cmodule, MODULE_ULAB_ENABLED);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -12,9 +12,6 @@
|
|||
#ifndef __ULAB__
|
||||
#define __ULAB__
|
||||
|
||||
// create
|
||||
#define ULAB_CREATE_MODULE (1)
|
||||
|
||||
// vectorise (all functions) takes approx. 3 kB of flash space
|
||||
#define ULAB_VECTORISE_MODULE (1)
|
||||
|
||||
|
|
@ -34,6 +31,6 @@
|
|||
#define ULAB_FILTER_MODULE (1)
|
||||
|
||||
// user-defined modules
|
||||
#define ULAB_EXTRAS_MODULE (1)
|
||||
#define ULAB_EXTRAS_MODULE (0)
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -135,90 +135,11 @@ MP_DEFINE_CONST_FUN_OBJ_1(vectorise_tan_obj, vectorise_tan);
|
|||
MATH_FUN_1(tanh, tanh);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(vectorise_tanh_obj, vectorise_tanh);
|
||||
|
||||
mp_obj_t vectorise_around(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
|
||||
{ MP_QSTR_decimals, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0 } }
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
if(!MP_OBJ_IS_TYPE(args[0].u_obj, &ulab_ndarray_type)) {
|
||||
mp_raise_TypeError(translate("first argument must be an ndarray"));
|
||||
}
|
||||
int8_t n = args[1].u_int;
|
||||
mp_float_t mul = MICROPY_FLOAT_C_FUN(pow)(10.0, n);
|
||||
ndarray_obj_t *ndarray = MP_OBJ_TO_PTR(args[0].u_obj);
|
||||
ndarray_obj_t *result = create_new_ndarray(ndarray->m, ndarray->n, NDARRAY_FLOAT);
|
||||
mp_float_t *array = (mp_float_t *)result->array->items;
|
||||
for(size_t i=0; i < ndarray->array->len; i++) {
|
||||
mp_float_t f = ndarray_get_float_value(ndarray->array->items, ndarray->array->typecode, i);
|
||||
*array++ = MICROPY_FLOAT_C_FUN(round)(f * mul) / mul;
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(result);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(vectorise_around_obj, 1, vectorise_around);
|
||||
|
||||
mp_obj_t vectorise_arctan2(mp_obj_t x, mp_obj_t y) {
|
||||
// the function is implemented for scalars and ndarrays only, with partial
|
||||
// broadcasting: arguments must be either scalars, or ndarrays of equal size/shape
|
||||
if(!(MP_OBJ_IS_INT(x) || mp_obj_is_float(x) || MP_OBJ_IS_TYPE(x, &ulab_ndarray_type)) &&
|
||||
!(MP_OBJ_IS_INT(y) || mp_obj_is_float(y) || MP_OBJ_IS_TYPE(y, &ulab_ndarray_type))) {
|
||||
mp_raise_TypeError(translate("arctan2 is implemented for scalars and ndarrays only"));
|
||||
}
|
||||
ndarray_obj_t *ndarray_x, *ndarray_y;
|
||||
if(MP_OBJ_IS_INT(x) || mp_obj_is_float(x)) {
|
||||
ndarray_x = create_new_ndarray(1, 1, NDARRAY_FLOAT);
|
||||
mp_float_t *array_x = (mp_float_t *)ndarray_x->array->items;
|
||||
*array_x = mp_obj_get_float(x);
|
||||
} else {
|
||||
ndarray_x = MP_OBJ_TO_PTR(x);
|
||||
}
|
||||
if(MP_OBJ_IS_INT(y) || mp_obj_is_float(y)) {
|
||||
ndarray_y = create_new_ndarray(1, 1, NDARRAY_FLOAT);
|
||||
mp_float_t *array_y = (mp_float_t *)ndarray_y->array->items;
|
||||
*array_y = mp_obj_get_float(y);
|
||||
} else {
|
||||
ndarray_y = MP_OBJ_TO_PTR(y);
|
||||
}
|
||||
// check, whether partial broadcasting is possible here
|
||||
if((ndarray_x->m != ndarray_y->m) || (ndarray_x->n != ndarray_y->n)) {
|
||||
if((ndarray_x->array->len != 1) && (ndarray_y->array->len != 1)) {
|
||||
mp_raise_ValueError(translate("operands could not be broadcast together"));
|
||||
}
|
||||
}
|
||||
size_t xinc = 0, yinc = 0;
|
||||
size_t m = MAX(ndarray_x->m, ndarray_y->m);
|
||||
size_t n = MAX(ndarray_x->n, ndarray_y->n);
|
||||
size_t len = MAX(ndarray_x->array->len, ndarray_y->array->len);
|
||||
if(ndarray_x->array->len != 1) {
|
||||
xinc = 1;
|
||||
}
|
||||
if(ndarray_y->array->len != 1) {
|
||||
yinc = 1;
|
||||
}
|
||||
size_t posx = 0, posy = 0;
|
||||
ndarray_obj_t *result = create_new_ndarray(m, n, NDARRAY_FLOAT);
|
||||
mp_float_t *array_r = (mp_float_t *)result->array->items;
|
||||
for(size_t i=0; i < len; i++) {
|
||||
mp_float_t value_x = ndarray_get_float_value(ndarray_x->array->items, ndarray_x->array->typecode, posx);
|
||||
mp_float_t value_y = ndarray_get_float_value(ndarray_y->array->items, ndarray_y->array->typecode, posy);
|
||||
*array_r++ = MICROPY_FLOAT_C_FUN(atan2)(value_x, value_y);
|
||||
posx += xinc;
|
||||
posy += yinc;
|
||||
}
|
||||
return MP_OBJ_FROM_PTR(result);
|
||||
}
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_2(vectorise_arctan2_obj, vectorise_arctan2);
|
||||
|
||||
#if !CIRCUITPY
|
||||
STATIC const mp_rom_map_elem_t ulab_vectorise_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_vector) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_acos), (mp_obj_t)&vectorise_acos_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_acosh), (mp_obj_t)&vectorise_acosh_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_arctan2), (mp_obj_t)&vectorise_arctan2_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_around), (mp_obj_t)&vectorise_around_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_asin), (mp_obj_t)&vectorise_asin_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_asinh), (mp_obj_t)&vectorise_asinh_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_atan), (mp_obj_t)&vectorise_atan_obj },
|
||||
|
|
@ -248,5 +169,6 @@ mp_obj_module_t ulab_vectorise_module = {
|
|||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_ulab_vectorise_globals,
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -18,11 +18,11 @@
|
|||
# -- Project information -----------------------------------------------------
|
||||
|
||||
project = 'micropython-ulab'
|
||||
copyright = '2019-2020, Zoltán Vörös'
|
||||
copyright = '2019, Zoltán Vörös'
|
||||
author = 'Zoltán Vörös'
|
||||
|
||||
# The full version, including alpha/beta/rc tags
|
||||
release = '0.41.0'
|
||||
release = '0.32'
|
||||
|
||||
|
||||
# -- General configuration ---------------------------------------------------
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,50 +1,3 @@
|
|||
Sat, 4 Apr 2020
|
||||
|
||||
version 0.41.0
|
||||
|
||||
implemented == and != binary operators
|
||||
|
||||
Fri, 3 Apr 2020
|
||||
|
||||
version 0.40.0
|
||||
|
||||
added trace to linalg
|
||||
|
||||
Thu, 2 Apr 2020
|
||||
|
||||
version 0.39.0
|
||||
|
||||
added the ** operator, and operand swapping in binary operators
|
||||
|
||||
Thu, 2 Apr 2020
|
||||
|
||||
version 0.38.1
|
||||
|
||||
added fast option, when initialising from ndarray_properties
|
||||
|
||||
Thu, 12 Mar 2020
|
||||
|
||||
version 0.38.0
|
||||
|
||||
added initialisation from ndarray, and the around function
|
||||
|
||||
Tue, 10 Mar 2020
|
||||
|
||||
version 0.37.0
|
||||
|
||||
added Cholesky decomposition to linalg.c
|
||||
|
||||
Thu, 27 Feb 2020
|
||||
|
||||
version 0.36.0
|
||||
|
||||
moved zeros, ones, eye and linspace into separate module (they are still bound at the top level)
|
||||
|
||||
Thu, 27 Feb 2020
|
||||
|
||||
version 0.35.0
|
||||
|
||||
Move zeros, ones back into top level ulab module
|
||||
|
||||
Tue, 18 Feb 2020
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
5125
docs/ulab.ipynb
Normal file
5125
docs/ulab.ipynb
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -1,2 +1,2 @@
|
|||
import ulab
|
||||
print(ulab.eye(3))
|
||||
from ulab import linalg
|
||||
print(linalg.eye(3))
|
||||
|
|
|
|||
|
|
@ -1,17 +0,0 @@
|
|||
import ulab
|
||||
from ulab import linalg
|
||||
|
||||
a = ulab.array([[1, 2], [2, 5]])
|
||||
print(linalg.cholesky(a))
|
||||
|
||||
b = a = ulab.array([[25, 15, -5], [15, 18, 0], [-5, 0, 11]])
|
||||
print(linalg.cholesky(b))
|
||||
|
||||
c = ulab.array([[18, 22, 54, 42], [22, 70, 86, 62], [54, 86, 174, 134], [42, 62, 134, 106]])
|
||||
print(linalg.cholesky(c))
|
||||
|
||||
# this throw a ValueError exception
|
||||
d = ulab.array([[25, 15, -5], [15, 18, 0], [-5, 0, 1]])
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
array([[1.0, 0.0],
|
||||
[2.0, 1.0]], dtype=float)
|
||||
array([[5.0, 0.0, 0.0],
|
||||
[3.0, 3.0, 0.0],
|
||||
[-1.0, 1.0, 3.0]], dtype=float)
|
||||
array([[4.242640687119285, 0.0, 0.0, 0.0],
|
||||
[5.185449728701349, 6.565905201197403, 0.0, 0.0],
|
||||
[12.72792206135786, 3.046038495400855, 1.649742247909068, 0.0],
|
||||
[9.899494936611665, 1.624553864213789, 1.849711005231386, 1.392621247645583]], dtype=float)
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
from ulab import linalg
|
||||
import ulab
|
||||
print(ulab.ones(3))
|
||||
print(ulab.ones((2,3)))
|
||||
print(ulab.zeros(3))
|
||||
print(ulab.zeros((2,3)))
|
||||
print(ulab.eye(3))
|
||||
print(ulab.ones(1, dtype=ulab.int8))
|
||||
print(ulab.ones(2, dtype=ulab.uint8))
|
||||
print(ulab.ones(3, dtype=ulab.int16))
|
||||
print(ulab.ones(4, dtype=ulab.uint16))
|
||||
print(ulab.ones(5, dtype=ulab.float))
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
array([1.0, 1.0, 1.0], dtype=float)
|
||||
array([[1.0, 1.0, 1.0],
|
||||
[1.0, 1.0, 1.0]], dtype=float)
|
||||
array([0.0, 0.0, 0.0], dtype=float)
|
||||
array([[0.0, 0.0, 0.0],
|
||||
[0.0, 0.0, 0.0]], dtype=float)
|
||||
array([[1.0, 0.0, 0.0],
|
||||
[0.0, 1.0, 0.0],
|
||||
[0.0, 0.0, 1.0]], dtype=float)
|
||||
array([1], dtype=int8)
|
||||
array([1, 1], dtype=uint8)
|
||||
array([1, 1, 1], dtype=int16)
|
||||
array([1, 1, 1, 1], dtype=uint16)
|
||||
array([1.0, 1.0, 1.0, 1.0, 1.0], dtype=float)
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
import ulab
|
||||
from ulab import linalg
|
||||
|
||||
a = ulab.array([[1, 2], [3, 4]])
|
||||
print(linalg.inv(a))
|
||||
|
||||
b = ulab.array([[1, 2, 3], [4, 5, 6], [7, 8, 7]])
|
||||
print(linalg.inv(b))
|
||||
|
||||
c = ulab.array([[1, 2, 0, 0], [0, 6, 7, 0], [0, 0, 8, 9], [0, 0, 15, 13]])
|
||||
print(linalg.inv(c))
|
||||
|
||||
print(linalg.det(a))
|
||||
print(linalg.det(b))
|
||||
print(linalg.det(c))
|
||||
|
||||
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
array([[-2.0, 1.0],
|
||||
[1.5, -0.5]], dtype=float)
|
||||
array([[-2.166666666666667, 1.666666666666667, -0.5],
|
||||
[2.333333333333333, -2.333333333333333, 1.0],
|
||||
[-0.5, 1.0, -0.5]], dtype=float)
|
||||
array([[1.0, -0.3333333333333333, -0.9784946236559136, 0.6774193548387095],
|
||||
[0.0, 0.1666666666666667, 0.489247311827957, -0.3387096774193548],
|
||||
[0.0, 0.0, -0.4193548387096775, 0.2903225806451613],
|
||||
[-0.0, -0.0, 0.4838709677419355, -0.2580645161290323]], dtype=float)
|
||||
-2.0
|
||||
6.0
|
||||
-186.0
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
import ulab
|
||||
a = ulab.ones(3)
|
||||
print(a+a)
|
||||
print(a-a)
|
||||
print(a*a)
|
||||
print(a/a)
|
||||
print(a+2)
|
||||
print(a-2)
|
||||
print(a*2)
|
||||
print(a/2)
|
||||
print(a<1)
|
||||
print(a<2)
|
||||
print(a<=0)
|
||||
print(a<=1)
|
||||
print(a>1)
|
||||
print(a>2)
|
||||
print(a>=0)
|
||||
print(a>=1)
|
||||
#print(a==0) # These print just true or false. Is it right? is it a micropython limitation?
|
||||
#print(a==1)
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
array([2.0, 2.0, 2.0], dtype=float)
|
||||
array([0.0, 0.0, 0.0], dtype=float)
|
||||
array([1.0, 1.0, 1.0], dtype=float)
|
||||
array([1.0, 1.0, 1.0], dtype=float)
|
||||
array([3.0, 3.0, 3.0], dtype=float)
|
||||
array([-1.0, -1.0, -1.0], dtype=float)
|
||||
array([2.0, 2.0, 2.0], dtype=float)
|
||||
array([0.5, 0.5, 0.5], dtype=float)
|
||||
[False, False, False]
|
||||
[True, True, True]
|
||||
[False, False, False]
|
||||
[True, True, True]
|
||||
[False, False, False]
|
||||
[False, False, False]
|
||||
[True, True, True]
|
||||
[True, True, True]
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
import ulab
|
||||
from ulab import poly
|
||||
from ulab import vector
|
||||
|
||||
# polynom evaluation
|
||||
x = ulab.linspace(0, 10, num=9)
|
||||
p = [1, 2, 3]
|
||||
y = poly.polyval(p, x)
|
||||
print(y)
|
||||
|
||||
# linear fit
|
||||
x = ulab.linspace(-5, 5, num=11)
|
||||
y = x + vector.sin(x)
|
||||
p = poly.polyfit(x, y, 1)
|
||||
print(p)
|
||||
|
||||
# quadratic fit
|
||||
x = ulab.linspace(-5, 5, num=11)
|
||||
y = x*x + vector.sin(x)*3.0
|
||||
p = poly.polyfit(x, y, 2)
|
||||
print(p)
|
||||
|
||||
# cubic fit
|
||||
x = ulab.linspace(-5, 5, num=11)
|
||||
y = x*x*x + vector.sin(x)*10.0
|
||||
p = poly.polyfit(x, y, 3)
|
||||
print(p)
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
array([3.0, 7.0625, 14.25, 24.5625, 38.0, 54.56250000000001, 74.25000000000001, 97.06250000000001, 123.0], dtype=float)
|
||||
array([0.9138471728743898, -8.074349270001139e-17], dtype=float)
|
||||
array([1.0, -0.2584584813768293, 3.552713678800501e-15], dtype=float)
|
||||
array([0.766798803225857, 0.0, 3.289453031323674, 0.0], dtype=float)
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
try:
|
||||
import ulab as np
|
||||
except:
|
||||
import numpy as np
|
||||
|
||||
for num in range(1,4):
|
||||
for start in range(-num, num+1):
|
||||
for end in range(-num, num+1):
|
||||
for stride in (-3, -2, -1, 1, 2, 3):
|
||||
l = list(range(num))
|
||||
a = np.array(l, dtype=np.int8)
|
||||
sl = l[start:end:stride]
|
||||
ll = len(sl)
|
||||
try:
|
||||
sa = list(a[start:end:stride])
|
||||
la = len(sa)
|
||||
except IndexError as e:
|
||||
sa = str(e)
|
||||
la = -1
|
||||
print("%2d [% d:% d:% d] %-24r %-24r%s" % (
|
||||
num, start, end, stride, sl, sa, " ***" if sa != sl else ""))
|
||||
|
||||
a[start:end:stride] = np.ones(len(sl)) * -1
|
||||
print("%2d [% d:% d:% d] %r" % (
|
||||
num, start, end, stride, list(a)))
|
||||
|
|
@ -1,996 +0,0 @@
|
|||
1 [-1:-1:-3] [] []
|
||||
1 [-1:-1:-3] [0]
|
||||
1 [-1:-1:-2] [] []
|
||||
1 [-1:-1:-2] [0]
|
||||
1 [-1:-1:-1] [] []
|
||||
1 [-1:-1:-1] [0]
|
||||
1 [-1:-1: 1] [] []
|
||||
1 [-1:-1: 1] [0]
|
||||
1 [-1:-1: 2] [] []
|
||||
1 [-1:-1: 2] [0]
|
||||
1 [-1:-1: 3] [] []
|
||||
1 [-1:-1: 3] [0]
|
||||
1 [-1: 0:-3] [] []
|
||||
1 [-1: 0:-3] [0]
|
||||
1 [-1: 0:-2] [] []
|
||||
1 [-1: 0:-2] [0]
|
||||
1 [-1: 0:-1] [] []
|
||||
1 [-1: 0:-1] [0]
|
||||
1 [-1: 0: 1] [] []
|
||||
1 [-1: 0: 1] [0]
|
||||
1 [-1: 0: 2] [] []
|
||||
1 [-1: 0: 2] [0]
|
||||
1 [-1: 0: 3] [] []
|
||||
1 [-1: 0: 3] [0]
|
||||
1 [-1: 1:-3] [] []
|
||||
1 [-1: 1:-3] [0]
|
||||
1 [-1: 1:-2] [] []
|
||||
1 [-1: 1:-2] [0]
|
||||
1 [-1: 1:-1] [] []
|
||||
1 [-1: 1:-1] [0]
|
||||
1 [-1: 1: 1] [0] [0]
|
||||
1 [-1: 1: 1] [-1]
|
||||
1 [-1: 1: 2] [0] [0]
|
||||
1 [-1: 1: 2] [-1]
|
||||
1 [-1: 1: 3] [0] [0]
|
||||
1 [-1: 1: 3] [-1]
|
||||
1 [ 0:-1:-3] [] []
|
||||
1 [ 0:-1:-3] [0]
|
||||
1 [ 0:-1:-2] [] []
|
||||
1 [ 0:-1:-2] [0]
|
||||
1 [ 0:-1:-1] [] []
|
||||
1 [ 0:-1:-1] [0]
|
||||
1 [ 0:-1: 1] [] []
|
||||
1 [ 0:-1: 1] [0]
|
||||
1 [ 0:-1: 2] [] []
|
||||
1 [ 0:-1: 2] [0]
|
||||
1 [ 0:-1: 3] [] []
|
||||
1 [ 0:-1: 3] [0]
|
||||
1 [ 0: 0:-3] [] []
|
||||
1 [ 0: 0:-3] [0]
|
||||
1 [ 0: 0:-2] [] []
|
||||
1 [ 0: 0:-2] [0]
|
||||
1 [ 0: 0:-1] [] []
|
||||
1 [ 0: 0:-1] [0]
|
||||
1 [ 0: 0: 1] [] []
|
||||
1 [ 0: 0: 1] [0]
|
||||
1 [ 0: 0: 2] [] []
|
||||
1 [ 0: 0: 2] [0]
|
||||
1 [ 0: 0: 3] [] []
|
||||
1 [ 0: 0: 3] [0]
|
||||
1 [ 0: 1:-3] [] []
|
||||
1 [ 0: 1:-3] [0]
|
||||
1 [ 0: 1:-2] [] []
|
||||
1 [ 0: 1:-2] [0]
|
||||
1 [ 0: 1:-1] [] []
|
||||
1 [ 0: 1:-1] [0]
|
||||
1 [ 0: 1: 1] [0] [0]
|
||||
1 [ 0: 1: 1] [-1]
|
||||
1 [ 0: 1: 2] [0] [0]
|
||||
1 [ 0: 1: 2] [-1]
|
||||
1 [ 0: 1: 3] [0] [0]
|
||||
1 [ 0: 1: 3] [-1]
|
||||
1 [ 1:-1:-3] [] []
|
||||
1 [ 1:-1:-3] [0]
|
||||
1 [ 1:-1:-2] [] []
|
||||
1 [ 1:-1:-2] [0]
|
||||
1 [ 1:-1:-1] [] []
|
||||
1 [ 1:-1:-1] [0]
|
||||
1 [ 1:-1: 1] [] []
|
||||
1 [ 1:-1: 1] [0]
|
||||
1 [ 1:-1: 2] [] []
|
||||
1 [ 1:-1: 2] [0]
|
||||
1 [ 1:-1: 3] [] []
|
||||
1 [ 1:-1: 3] [0]
|
||||
1 [ 1: 0:-3] [] []
|
||||
1 [ 1: 0:-3] [0]
|
||||
1 [ 1: 0:-2] [] []
|
||||
1 [ 1: 0:-2] [0]
|
||||
1 [ 1: 0:-1] [] []
|
||||
1 [ 1: 0:-1] [0]
|
||||
1 [ 1: 0: 1] [] []
|
||||
1 [ 1: 0: 1] [0]
|
||||
1 [ 1: 0: 2] [] []
|
||||
1 [ 1: 0: 2] [0]
|
||||
1 [ 1: 0: 3] [] []
|
||||
1 [ 1: 0: 3] [0]
|
||||
1 [ 1: 1:-3] [] []
|
||||
1 [ 1: 1:-3] [0]
|
||||
1 [ 1: 1:-2] [] []
|
||||
1 [ 1: 1:-2] [0]
|
||||
1 [ 1: 1:-1] [] []
|
||||
1 [ 1: 1:-1] [0]
|
||||
1 [ 1: 1: 1] [] []
|
||||
1 [ 1: 1: 1] [0]
|
||||
1 [ 1: 1: 2] [] []
|
||||
1 [ 1: 1: 2] [0]
|
||||
1 [ 1: 1: 3] [] []
|
||||
1 [ 1: 1: 3] [0]
|
||||
2 [-2:-2:-3] [] []
|
||||
2 [-2:-2:-3] [0, 1]
|
||||
2 [-2:-2:-2] [] []
|
||||
2 [-2:-2:-2] [0, 1]
|
||||
2 [-2:-2:-1] [] []
|
||||
2 [-2:-2:-1] [0, 1]
|
||||
2 [-2:-2: 1] [] []
|
||||
2 [-2:-2: 1] [0, 1]
|
||||
2 [-2:-2: 2] [] []
|
||||
2 [-2:-2: 2] [0, 1]
|
||||
2 [-2:-2: 3] [] []
|
||||
2 [-2:-2: 3] [0, 1]
|
||||
2 [-2:-1:-3] [] []
|
||||
2 [-2:-1:-3] [0, 1]
|
||||
2 [-2:-1:-2] [] []
|
||||
2 [-2:-1:-2] [0, 1]
|
||||
2 [-2:-1:-1] [] []
|
||||
2 [-2:-1:-1] [0, 1]
|
||||
2 [-2:-1: 1] [0] [0]
|
||||
2 [-2:-1: 1] [-1, 1]
|
||||
2 [-2:-1: 2] [0] [0]
|
||||
2 [-2:-1: 2] [-1, 1]
|
||||
2 [-2:-1: 3] [0] [0]
|
||||
2 [-2:-1: 3] [-1, 1]
|
||||
2 [-2: 0:-3] [] []
|
||||
2 [-2: 0:-3] [0, 1]
|
||||
2 [-2: 0:-2] [] []
|
||||
2 [-2: 0:-2] [0, 1]
|
||||
2 [-2: 0:-1] [] []
|
||||
2 [-2: 0:-1] [0, 1]
|
||||
2 [-2: 0: 1] [] []
|
||||
2 [-2: 0: 1] [0, 1]
|
||||
2 [-2: 0: 2] [] []
|
||||
2 [-2: 0: 2] [0, 1]
|
||||
2 [-2: 0: 3] [] []
|
||||
2 [-2: 0: 3] [0, 1]
|
||||
2 [-2: 1:-3] [] []
|
||||
2 [-2: 1:-3] [0, 1]
|
||||
2 [-2: 1:-2] [] []
|
||||
2 [-2: 1:-2] [0, 1]
|
||||
2 [-2: 1:-1] [] []
|
||||
2 [-2: 1:-1] [0, 1]
|
||||
2 [-2: 1: 1] [0] [0]
|
||||
2 [-2: 1: 1] [-1, 1]
|
||||
2 [-2: 1: 2] [0] [0]
|
||||
2 [-2: 1: 2] [-1, 1]
|
||||
2 [-2: 1: 3] [0] [0]
|
||||
2 [-2: 1: 3] [-1, 1]
|
||||
2 [-2: 2:-3] [] []
|
||||
2 [-2: 2:-3] [0, 1]
|
||||
2 [-2: 2:-2] [] []
|
||||
2 [-2: 2:-2] [0, 1]
|
||||
2 [-2: 2:-1] [] []
|
||||
2 [-2: 2:-1] [0, 1]
|
||||
2 [-2: 2: 1] [0, 1] [0, 1]
|
||||
2 [-2: 2: 1] [-1, -1]
|
||||
2 [-2: 2: 2] [0] [0]
|
||||
2 [-2: 2: 2] [-1, 1]
|
||||
2 [-2: 2: 3] [0] [0]
|
||||
2 [-2: 2: 3] [-1, 1]
|
||||
2 [-1:-2:-3] [1] [1]
|
||||
2 [-1:-2:-3] [0, -1]
|
||||
2 [-1:-2:-2] [1] [1]
|
||||
2 [-1:-2:-2] [0, -1]
|
||||
2 [-1:-2:-1] [1] [1]
|
||||
2 [-1:-2:-1] [0, -1]
|
||||
2 [-1:-2: 1] [] []
|
||||
2 [-1:-2: 1] [0, 1]
|
||||
2 [-1:-2: 2] [] []
|
||||
2 [-1:-2: 2] [0, 1]
|
||||
2 [-1:-2: 3] [] []
|
||||
2 [-1:-2: 3] [0, 1]
|
||||
2 [-1:-1:-3] [] []
|
||||
2 [-1:-1:-3] [0, 1]
|
||||
2 [-1:-1:-2] [] []
|
||||
2 [-1:-1:-2] [0, 1]
|
||||
2 [-1:-1:-1] [] []
|
||||
2 [-1:-1:-1] [0, 1]
|
||||
2 [-1:-1: 1] [] []
|
||||
2 [-1:-1: 1] [0, 1]
|
||||
2 [-1:-1: 2] [] []
|
||||
2 [-1:-1: 2] [0, 1]
|
||||
2 [-1:-1: 3] [] []
|
||||
2 [-1:-1: 3] [0, 1]
|
||||
2 [-1: 0:-3] [1] [1]
|
||||
2 [-1: 0:-3] [0, -1]
|
||||
2 [-1: 0:-2] [1] [1]
|
||||
2 [-1: 0:-2] [0, -1]
|
||||
2 [-1: 0:-1] [1] [1]
|
||||
2 [-1: 0:-1] [0, -1]
|
||||
2 [-1: 0: 1] [] []
|
||||
2 [-1: 0: 1] [0, 1]
|
||||
2 [-1: 0: 2] [] []
|
||||
2 [-1: 0: 2] [0, 1]
|
||||
2 [-1: 0: 3] [] []
|
||||
2 [-1: 0: 3] [0, 1]
|
||||
2 [-1: 1:-3] [] []
|
||||
2 [-1: 1:-3] [0, 1]
|
||||
2 [-1: 1:-2] [] []
|
||||
2 [-1: 1:-2] [0, 1]
|
||||
2 [-1: 1:-1] [] []
|
||||
2 [-1: 1:-1] [0, 1]
|
||||
2 [-1: 1: 1] [] []
|
||||
2 [-1: 1: 1] [0, 1]
|
||||
2 [-1: 1: 2] [] []
|
||||
2 [-1: 1: 2] [0, 1]
|
||||
2 [-1: 1: 3] [] []
|
||||
2 [-1: 1: 3] [0, 1]
|
||||
2 [-1: 2:-3] [] []
|
||||
2 [-1: 2:-3] [0, 1]
|
||||
2 [-1: 2:-2] [] []
|
||||
2 [-1: 2:-2] [0, 1]
|
||||
2 [-1: 2:-1] [] []
|
||||
2 [-1: 2:-1] [0, 1]
|
||||
2 [-1: 2: 1] [1] [1]
|
||||
2 [-1: 2: 1] [0, -1]
|
||||
2 [-1: 2: 2] [1] [1]
|
||||
2 [-1: 2: 2] [0, -1]
|
||||
2 [-1: 2: 3] [1] [1]
|
||||
2 [-1: 2: 3] [0, -1]
|
||||
2 [ 0:-2:-3] [] []
|
||||
2 [ 0:-2:-3] [0, 1]
|
||||
2 [ 0:-2:-2] [] []
|
||||
2 [ 0:-2:-2] [0, 1]
|
||||
2 [ 0:-2:-1] [] []
|
||||
2 [ 0:-2:-1] [0, 1]
|
||||
2 [ 0:-2: 1] [] []
|
||||
2 [ 0:-2: 1] [0, 1]
|
||||
2 [ 0:-2: 2] [] []
|
||||
2 [ 0:-2: 2] [0, 1]
|
||||
2 [ 0:-2: 3] [] []
|
||||
2 [ 0:-2: 3] [0, 1]
|
||||
2 [ 0:-1:-3] [] []
|
||||
2 [ 0:-1:-3] [0, 1]
|
||||
2 [ 0:-1:-2] [] []
|
||||
2 [ 0:-1:-2] [0, 1]
|
||||
2 [ 0:-1:-1] [] []
|
||||
2 [ 0:-1:-1] [0, 1]
|
||||
2 [ 0:-1: 1] [0] [0]
|
||||
2 [ 0:-1: 1] [-1, 1]
|
||||
2 [ 0:-1: 2] [0] [0]
|
||||
2 [ 0:-1: 2] [-1, 1]
|
||||
2 [ 0:-1: 3] [0] [0]
|
||||
2 [ 0:-1: 3] [-1, 1]
|
||||
2 [ 0: 0:-3] [] []
|
||||
2 [ 0: 0:-3] [0, 1]
|
||||
2 [ 0: 0:-2] [] []
|
||||
2 [ 0: 0:-2] [0, 1]
|
||||
2 [ 0: 0:-1] [] []
|
||||
2 [ 0: 0:-1] [0, 1]
|
||||
2 [ 0: 0: 1] [] []
|
||||
2 [ 0: 0: 1] [0, 1]
|
||||
2 [ 0: 0: 2] [] []
|
||||
2 [ 0: 0: 2] [0, 1]
|
||||
2 [ 0: 0: 3] [] []
|
||||
2 [ 0: 0: 3] [0, 1]
|
||||
2 [ 0: 1:-3] [] []
|
||||
2 [ 0: 1:-3] [0, 1]
|
||||
2 [ 0: 1:-2] [] []
|
||||
2 [ 0: 1:-2] [0, 1]
|
||||
2 [ 0: 1:-1] [] []
|
||||
2 [ 0: 1:-1] [0, 1]
|
||||
2 [ 0: 1: 1] [0] [0]
|
||||
2 [ 0: 1: 1] [-1, 1]
|
||||
2 [ 0: 1: 2] [0] [0]
|
||||
2 [ 0: 1: 2] [-1, 1]
|
||||
2 [ 0: 1: 3] [0] [0]
|
||||
2 [ 0: 1: 3] [-1, 1]
|
||||
2 [ 0: 2:-3] [] []
|
||||
2 [ 0: 2:-3] [0, 1]
|
||||
2 [ 0: 2:-2] [] []
|
||||
2 [ 0: 2:-2] [0, 1]
|
||||
2 [ 0: 2:-1] [] []
|
||||
2 [ 0: 2:-1] [0, 1]
|
||||
2 [ 0: 2: 1] [0, 1] [0, 1]
|
||||
2 [ 0: 2: 1] [-1, -1]
|
||||
2 [ 0: 2: 2] [0] [0]
|
||||
2 [ 0: 2: 2] [-1, 1]
|
||||
2 [ 0: 2: 3] [0] [0]
|
||||
2 [ 0: 2: 3] [-1, 1]
|
||||
2 [ 1:-2:-3] [1] [1]
|
||||
2 [ 1:-2:-3] [0, -1]
|
||||
2 [ 1:-2:-2] [1] [1]
|
||||
2 [ 1:-2:-2] [0, -1]
|
||||
2 [ 1:-2:-1] [1] [1]
|
||||
2 [ 1:-2:-1] [0, -1]
|
||||
2 [ 1:-2: 1] [] []
|
||||
2 [ 1:-2: 1] [0, 1]
|
||||
2 [ 1:-2: 2] [] []
|
||||
2 [ 1:-2: 2] [0, 1]
|
||||
2 [ 1:-2: 3] [] []
|
||||
2 [ 1:-2: 3] [0, 1]
|
||||
2 [ 1:-1:-3] [] []
|
||||
2 [ 1:-1:-3] [0, 1]
|
||||
2 [ 1:-1:-2] [] []
|
||||
2 [ 1:-1:-2] [0, 1]
|
||||
2 [ 1:-1:-1] [] []
|
||||
2 [ 1:-1:-1] [0, 1]
|
||||
2 [ 1:-1: 1] [] []
|
||||
2 [ 1:-1: 1] [0, 1]
|
||||
2 [ 1:-1: 2] [] []
|
||||
2 [ 1:-1: 2] [0, 1]
|
||||
2 [ 1:-1: 3] [] []
|
||||
2 [ 1:-1: 3] [0, 1]
|
||||
2 [ 1: 0:-3] [1] [1]
|
||||
2 [ 1: 0:-3] [0, -1]
|
||||
2 [ 1: 0:-2] [1] [1]
|
||||
2 [ 1: 0:-2] [0, -1]
|
||||
2 [ 1: 0:-1] [1] [1]
|
||||
2 [ 1: 0:-1] [0, -1]
|
||||
2 [ 1: 0: 1] [] []
|
||||
2 [ 1: 0: 1] [0, 1]
|
||||
2 [ 1: 0: 2] [] []
|
||||
2 [ 1: 0: 2] [0, 1]
|
||||
2 [ 1: 0: 3] [] []
|
||||
2 [ 1: 0: 3] [0, 1]
|
||||
2 [ 1: 1:-3] [] []
|
||||
2 [ 1: 1:-3] [0, 1]
|
||||
2 [ 1: 1:-2] [] []
|
||||
2 [ 1: 1:-2] [0, 1]
|
||||
2 [ 1: 1:-1] [] []
|
||||
2 [ 1: 1:-1] [0, 1]
|
||||
2 [ 1: 1: 1] [] []
|
||||
2 [ 1: 1: 1] [0, 1]
|
||||
2 [ 1: 1: 2] [] []
|
||||
2 [ 1: 1: 2] [0, 1]
|
||||
2 [ 1: 1: 3] [] []
|
||||
2 [ 1: 1: 3] [0, 1]
|
||||
2 [ 1: 2:-3] [] []
|
||||
2 [ 1: 2:-3] [0, 1]
|
||||
2 [ 1: 2:-2] [] []
|
||||
2 [ 1: 2:-2] [0, 1]
|
||||
2 [ 1: 2:-1] [] []
|
||||
2 [ 1: 2:-1] [0, 1]
|
||||
2 [ 1: 2: 1] [1] [1]
|
||||
2 [ 1: 2: 1] [0, -1]
|
||||
2 [ 1: 2: 2] [1] [1]
|
||||
2 [ 1: 2: 2] [0, -1]
|
||||
2 [ 1: 2: 3] [1] [1]
|
||||
2 [ 1: 2: 3] [0, -1]
|
||||
2 [ 2:-2:-3] [1] [1]
|
||||
2 [ 2:-2:-3] [0, -1]
|
||||
2 [ 2:-2:-2] [1] [1]
|
||||
2 [ 2:-2:-2] [0, -1]
|
||||
2 [ 2:-2:-1] [1] [1]
|
||||
2 [ 2:-2:-1] [0, -1]
|
||||
2 [ 2:-2: 1] [] []
|
||||
2 [ 2:-2: 1] [0, 1]
|
||||
2 [ 2:-2: 2] [] []
|
||||
2 [ 2:-2: 2] [0, 1]
|
||||
2 [ 2:-2: 3] [] []
|
||||
2 [ 2:-2: 3] [0, 1]
|
||||
2 [ 2:-1:-3] [] []
|
||||
2 [ 2:-1:-3] [0, 1]
|
||||
2 [ 2:-1:-2] [] []
|
||||
2 [ 2:-1:-2] [0, 1]
|
||||
2 [ 2:-1:-1] [] []
|
||||
2 [ 2:-1:-1] [0, 1]
|
||||
2 [ 2:-1: 1] [] []
|
||||
2 [ 2:-1: 1] [0, 1]
|
||||
2 [ 2:-1: 2] [] []
|
||||
2 [ 2:-1: 2] [0, 1]
|
||||
2 [ 2:-1: 3] [] []
|
||||
2 [ 2:-1: 3] [0, 1]
|
||||
2 [ 2: 0:-3] [1] [1]
|
||||
2 [ 2: 0:-3] [0, -1]
|
||||
2 [ 2: 0:-2] [1] [1]
|
||||
2 [ 2: 0:-2] [0, -1]
|
||||
2 [ 2: 0:-1] [1] [1]
|
||||
2 [ 2: 0:-1] [0, -1]
|
||||
2 [ 2: 0: 1] [] []
|
||||
2 [ 2: 0: 1] [0, 1]
|
||||
2 [ 2: 0: 2] [] []
|
||||
2 [ 2: 0: 2] [0, 1]
|
||||
2 [ 2: 0: 3] [] []
|
||||
2 [ 2: 0: 3] [0, 1]
|
||||
2 [ 2: 1:-3] [] []
|
||||
2 [ 2: 1:-3] [0, 1]
|
||||
2 [ 2: 1:-2] [] []
|
||||
2 [ 2: 1:-2] [0, 1]
|
||||
2 [ 2: 1:-1] [] []
|
||||
2 [ 2: 1:-1] [0, 1]
|
||||
2 [ 2: 1: 1] [] []
|
||||
2 [ 2: 1: 1] [0, 1]
|
||||
2 [ 2: 1: 2] [] []
|
||||
2 [ 2: 1: 2] [0, 1]
|
||||
2 [ 2: 1: 3] [] []
|
||||
2 [ 2: 1: 3] [0, 1]
|
||||
2 [ 2: 2:-3] [] []
|
||||
2 [ 2: 2:-3] [0, 1]
|
||||
2 [ 2: 2:-2] [] []
|
||||
2 [ 2: 2:-2] [0, 1]
|
||||
2 [ 2: 2:-1] [] []
|
||||
2 [ 2: 2:-1] [0, 1]
|
||||
2 [ 2: 2: 1] [] []
|
||||
2 [ 2: 2: 1] [0, 1]
|
||||
2 [ 2: 2: 2] [] []
|
||||
2 [ 2: 2: 2] [0, 1]
|
||||
2 [ 2: 2: 3] [] []
|
||||
2 [ 2: 2: 3] [0, 1]
|
||||
3 [-3:-3:-3] [] []
|
||||
3 [-3:-3:-3] [0, 1, 2]
|
||||
3 [-3:-3:-2] [] []
|
||||
3 [-3:-3:-2] [0, 1, 2]
|
||||
3 [-3:-3:-1] [] []
|
||||
3 [-3:-3:-1] [0, 1, 2]
|
||||
3 [-3:-3: 1] [] []
|
||||
3 [-3:-3: 1] [0, 1, 2]
|
||||
3 [-3:-3: 2] [] []
|
||||
3 [-3:-3: 2] [0, 1, 2]
|
||||
3 [-3:-3: 3] [] []
|
||||
3 [-3:-3: 3] [0, 1, 2]
|
||||
3 [-3:-2:-3] [] []
|
||||
3 [-3:-2:-3] [0, 1, 2]
|
||||
3 [-3:-2:-2] [] []
|
||||
3 [-3:-2:-2] [0, 1, 2]
|
||||
3 [-3:-2:-1] [] []
|
||||
3 [-3:-2:-1] [0, 1, 2]
|
||||
3 [-3:-2: 1] [0] [0]
|
||||
3 [-3:-2: 1] [-1, 1, 2]
|
||||
3 [-3:-2: 2] [0] [0]
|
||||
3 [-3:-2: 2] [-1, 1, 2]
|
||||
3 [-3:-2: 3] [0] [0]
|
||||
3 [-3:-2: 3] [-1, 1, 2]
|
||||
3 [-3:-1:-3] [] []
|
||||
3 [-3:-1:-3] [0, 1, 2]
|
||||
3 [-3:-1:-2] [] []
|
||||
3 [-3:-1:-2] [0, 1, 2]
|
||||
3 [-3:-1:-1] [] []
|
||||
3 [-3:-1:-1] [0, 1, 2]
|
||||
3 [-3:-1: 1] [0, 1] [0, 1]
|
||||
3 [-3:-1: 1] [-1, -1, 2]
|
||||
3 [-3:-1: 2] [0] [0]
|
||||
3 [-3:-1: 2] [-1, 1, 2]
|
||||
3 [-3:-1: 3] [0] [0]
|
||||
3 [-3:-1: 3] [-1, 1, 2]
|
||||
3 [-3: 0:-3] [] []
|
||||
3 [-3: 0:-3] [0, 1, 2]
|
||||
3 [-3: 0:-2] [] []
|
||||
3 [-3: 0:-2] [0, 1, 2]
|
||||
3 [-3: 0:-1] [] []
|
||||
3 [-3: 0:-1] [0, 1, 2]
|
||||
3 [-3: 0: 1] [] []
|
||||
3 [-3: 0: 1] [0, 1, 2]
|
||||
3 [-3: 0: 2] [] []
|
||||
3 [-3: 0: 2] [0, 1, 2]
|
||||
3 [-3: 0: 3] [] []
|
||||
3 [-3: 0: 3] [0, 1, 2]
|
||||
3 [-3: 1:-3] [] []
|
||||
3 [-3: 1:-3] [0, 1, 2]
|
||||
3 [-3: 1:-2] [] []
|
||||
3 [-3: 1:-2] [0, 1, 2]
|
||||
3 [-3: 1:-1] [] []
|
||||
3 [-3: 1:-1] [0, 1, 2]
|
||||
3 [-3: 1: 1] [0] [0]
|
||||
3 [-3: 1: 1] [-1, 1, 2]
|
||||
3 [-3: 1: 2] [0] [0]
|
||||
3 [-3: 1: 2] [-1, 1, 2]
|
||||
3 [-3: 1: 3] [0] [0]
|
||||
3 [-3: 1: 3] [-1, 1, 2]
|
||||
3 [-3: 2:-3] [] []
|
||||
3 [-3: 2:-3] [0, 1, 2]
|
||||
3 [-3: 2:-2] [] []
|
||||
3 [-3: 2:-2] [0, 1, 2]
|
||||
3 [-3: 2:-1] [] []
|
||||
3 [-3: 2:-1] [0, 1, 2]
|
||||
3 [-3: 2: 1] [0, 1] [0, 1]
|
||||
3 [-3: 2: 1] [-1, -1, 2]
|
||||
3 [-3: 2: 2] [0] [0]
|
||||
3 [-3: 2: 2] [-1, 1, 2]
|
||||
3 [-3: 2: 3] [0] [0]
|
||||
3 [-3: 2: 3] [-1, 1, 2]
|
||||
3 [-3: 3:-3] [] []
|
||||
3 [-3: 3:-3] [0, 1, 2]
|
||||
3 [-3: 3:-2] [] []
|
||||
3 [-3: 3:-2] [0, 1, 2]
|
||||
3 [-3: 3:-1] [] []
|
||||
3 [-3: 3:-1] [0, 1, 2]
|
||||
3 [-3: 3: 1] [0, 1, 2] [0, 1, 2]
|
||||
3 [-3: 3: 1] [-1, -1, -1]
|
||||
3 [-3: 3: 2] [0, 2] [0, 2]
|
||||
3 [-3: 3: 2] [-1, 1, -1]
|
||||
3 [-3: 3: 3] [0] [0]
|
||||
3 [-3: 3: 3] [-1, 1, 2]
|
||||
3 [-2:-3:-3] [1] [1]
|
||||
3 [-2:-3:-3] [0, -1, 2]
|
||||
3 [-2:-3:-2] [1] [1]
|
||||
3 [-2:-3:-2] [0, -1, 2]
|
||||
3 [-2:-3:-1] [1] [1]
|
||||
3 [-2:-3:-1] [0, -1, 2]
|
||||
3 [-2:-3: 1] [] []
|
||||
3 [-2:-3: 1] [0, 1, 2]
|
||||
3 [-2:-3: 2] [] []
|
||||
3 [-2:-3: 2] [0, 1, 2]
|
||||
3 [-2:-3: 3] [] []
|
||||
3 [-2:-3: 3] [0, 1, 2]
|
||||
3 [-2:-2:-3] [] []
|
||||
3 [-2:-2:-3] [0, 1, 2]
|
||||
3 [-2:-2:-2] [] []
|
||||
3 [-2:-2:-2] [0, 1, 2]
|
||||
3 [-2:-2:-1] [] []
|
||||
3 [-2:-2:-1] [0, 1, 2]
|
||||
3 [-2:-2: 1] [] []
|
||||
3 [-2:-2: 1] [0, 1, 2]
|
||||
3 [-2:-2: 2] [] []
|
||||
3 [-2:-2: 2] [0, 1, 2]
|
||||
3 [-2:-2: 3] [] []
|
||||
3 [-2:-2: 3] [0, 1, 2]
|
||||
3 [-2:-1:-3] [] []
|
||||
3 [-2:-1:-3] [0, 1, 2]
|
||||
3 [-2:-1:-2] [] []
|
||||
3 [-2:-1:-2] [0, 1, 2]
|
||||
3 [-2:-1:-1] [] []
|
||||
3 [-2:-1:-1] [0, 1, 2]
|
||||
3 [-2:-1: 1] [1] [1]
|
||||
3 [-2:-1: 1] [0, -1, 2]
|
||||
3 [-2:-1: 2] [1] [1]
|
||||
3 [-2:-1: 2] [0, -1, 2]
|
||||
3 [-2:-1: 3] [1] [1]
|
||||
3 [-2:-1: 3] [0, -1, 2]
|
||||
3 [-2: 0:-3] [1] [1]
|
||||
3 [-2: 0:-3] [0, -1, 2]
|
||||
3 [-2: 0:-2] [1] [1]
|
||||
3 [-2: 0:-2] [0, -1, 2]
|
||||
3 [-2: 0:-1] [1] [1]
|
||||
3 [-2: 0:-1] [0, -1, 2]
|
||||
3 [-2: 0: 1] [] []
|
||||
3 [-2: 0: 1] [0, 1, 2]
|
||||
3 [-2: 0: 2] [] []
|
||||
3 [-2: 0: 2] [0, 1, 2]
|
||||
3 [-2: 0: 3] [] []
|
||||
3 [-2: 0: 3] [0, 1, 2]
|
||||
3 [-2: 1:-3] [] []
|
||||
3 [-2: 1:-3] [0, 1, 2]
|
||||
3 [-2: 1:-2] [] []
|
||||
3 [-2: 1:-2] [0, 1, 2]
|
||||
3 [-2: 1:-1] [] []
|
||||
3 [-2: 1:-1] [0, 1, 2]
|
||||
3 [-2: 1: 1] [] []
|
||||
3 [-2: 1: 1] [0, 1, 2]
|
||||
3 [-2: 1: 2] [] []
|
||||
3 [-2: 1: 2] [0, 1, 2]
|
||||
3 [-2: 1: 3] [] []
|
||||
3 [-2: 1: 3] [0, 1, 2]
|
||||
3 [-2: 2:-3] [] []
|
||||
3 [-2: 2:-3] [0, 1, 2]
|
||||
3 [-2: 2:-2] [] []
|
||||
3 [-2: 2:-2] [0, 1, 2]
|
||||
3 [-2: 2:-1] [] []
|
||||
3 [-2: 2:-1] [0, 1, 2]
|
||||
3 [-2: 2: 1] [1] [1]
|
||||
3 [-2: 2: 1] [0, -1, 2]
|
||||
3 [-2: 2: 2] [1] [1]
|
||||
3 [-2: 2: 2] [0, -1, 2]
|
||||
3 [-2: 2: 3] [1] [1]
|
||||
3 [-2: 2: 3] [0, -1, 2]
|
||||
3 [-2: 3:-3] [] []
|
||||
3 [-2: 3:-3] [0, 1, 2]
|
||||
3 [-2: 3:-2] [] []
|
||||
3 [-2: 3:-2] [0, 1, 2]
|
||||
3 [-2: 3:-1] [] []
|
||||
3 [-2: 3:-1] [0, 1, 2]
|
||||
3 [-2: 3: 1] [1, 2] [1, 2]
|
||||
3 [-2: 3: 1] [0, -1, -1]
|
||||
3 [-2: 3: 2] [1] [1]
|
||||
3 [-2: 3: 2] [0, -1, 2]
|
||||
3 [-2: 3: 3] [1] [1]
|
||||
3 [-2: 3: 3] [0, -1, 2]
|
||||
3 [-1:-3:-3] [2] [2]
|
||||
3 [-1:-3:-3] [0, 1, -1]
|
||||
3 [-1:-3:-2] [2] [2]
|
||||
3 [-1:-3:-2] [0, 1, -1]
|
||||
3 [-1:-3:-1] [2, 1] [2, 1]
|
||||
3 [-1:-3:-1] [0, -1, -1]
|
||||
3 [-1:-3: 1] [] []
|
||||
3 [-1:-3: 1] [0, 1, 2]
|
||||
3 [-1:-3: 2] [] []
|
||||
3 [-1:-3: 2] [0, 1, 2]
|
||||
3 [-1:-3: 3] [] []
|
||||
3 [-1:-3: 3] [0, 1, 2]
|
||||
3 [-1:-2:-3] [2] [2]
|
||||
3 [-1:-2:-3] [0, 1, -1]
|
||||
3 [-1:-2:-2] [2] [2]
|
||||
3 [-1:-2:-2] [0, 1, -1]
|
||||
3 [-1:-2:-1] [2] [2]
|
||||
3 [-1:-2:-1] [0, 1, -1]
|
||||
3 [-1:-2: 1] [] []
|
||||
3 [-1:-2: 1] [0, 1, 2]
|
||||
3 [-1:-2: 2] [] []
|
||||
3 [-1:-2: 2] [0, 1, 2]
|
||||
3 [-1:-2: 3] [] []
|
||||
3 [-1:-2: 3] [0, 1, 2]
|
||||
3 [-1:-1:-3] [] []
|
||||
3 [-1:-1:-3] [0, 1, 2]
|
||||
3 [-1:-1:-2] [] []
|
||||
3 [-1:-1:-2] [0, 1, 2]
|
||||
3 [-1:-1:-1] [] []
|
||||
3 [-1:-1:-1] [0, 1, 2]
|
||||
3 [-1:-1: 1] [] []
|
||||
3 [-1:-1: 1] [0, 1, 2]
|
||||
3 [-1:-1: 2] [] []
|
||||
3 [-1:-1: 2] [0, 1, 2]
|
||||
3 [-1:-1: 3] [] []
|
||||
3 [-1:-1: 3] [0, 1, 2]
|
||||
3 [-1: 0:-3] [2] [2]
|
||||
3 [-1: 0:-3] [0, 1, -1]
|
||||
3 [-1: 0:-2] [2] [2]
|
||||
3 [-1: 0:-2] [0, 1, -1]
|
||||
3 [-1: 0:-1] [2, 1] [2, 1]
|
||||
3 [-1: 0:-1] [0, -1, -1]
|
||||
3 [-1: 0: 1] [] []
|
||||
3 [-1: 0: 1] [0, 1, 2]
|
||||
3 [-1: 0: 2] [] []
|
||||
3 [-1: 0: 2] [0, 1, 2]
|
||||
3 [-1: 0: 3] [] []
|
||||
3 [-1: 0: 3] [0, 1, 2]
|
||||
3 [-1: 1:-3] [2] [2]
|
||||
3 [-1: 1:-3] [0, 1, -1]
|
||||
3 [-1: 1:-2] [2] [2]
|
||||
3 [-1: 1:-2] [0, 1, -1]
|
||||
3 [-1: 1:-1] [2] [2]
|
||||
3 [-1: 1:-1] [0, 1, -1]
|
||||
3 [-1: 1: 1] [] []
|
||||
3 [-1: 1: 1] [0, 1, 2]
|
||||
3 [-1: 1: 2] [] []
|
||||
3 [-1: 1: 2] [0, 1, 2]
|
||||
3 [-1: 1: 3] [] []
|
||||
3 [-1: 1: 3] [0, 1, 2]
|
||||
3 [-1: 2:-3] [] []
|
||||
3 [-1: 2:-3] [0, 1, 2]
|
||||
3 [-1: 2:-2] [] []
|
||||
3 [-1: 2:-2] [0, 1, 2]
|
||||
3 [-1: 2:-1] [] []
|
||||
3 [-1: 2:-1] [0, 1, 2]
|
||||
3 [-1: 2: 1] [] []
|
||||
3 [-1: 2: 1] [0, 1, 2]
|
||||
3 [-1: 2: 2] [] []
|
||||
3 [-1: 2: 2] [0, 1, 2]
|
||||
3 [-1: 2: 3] [] []
|
||||
3 [-1: 2: 3] [0, 1, 2]
|
||||
3 [-1: 3:-3] [] []
|
||||
3 [-1: 3:-3] [0, 1, 2]
|
||||
3 [-1: 3:-2] [] []
|
||||
3 [-1: 3:-2] [0, 1, 2]
|
||||
3 [-1: 3:-1] [] []
|
||||
3 [-1: 3:-1] [0, 1, 2]
|
||||
3 [-1: 3: 1] [2] [2]
|
||||
3 [-1: 3: 1] [0, 1, -1]
|
||||
3 [-1: 3: 2] [2] [2]
|
||||
3 [-1: 3: 2] [0, 1, -1]
|
||||
3 [-1: 3: 3] [2] [2]
|
||||
3 [-1: 3: 3] [0, 1, -1]
|
||||
3 [ 0:-3:-3] [] []
|
||||
3 [ 0:-3:-3] [0, 1, 2]
|
||||
3 [ 0:-3:-2] [] []
|
||||
3 [ 0:-3:-2] [0, 1, 2]
|
||||
3 [ 0:-3:-1] [] []
|
||||
3 [ 0:-3:-1] [0, 1, 2]
|
||||
3 [ 0:-3: 1] [] []
|
||||
3 [ 0:-3: 1] [0, 1, 2]
|
||||
3 [ 0:-3: 2] [] []
|
||||
3 [ 0:-3: 2] [0, 1, 2]
|
||||
3 [ 0:-3: 3] [] []
|
||||
3 [ 0:-3: 3] [0, 1, 2]
|
||||
3 [ 0:-2:-3] [] []
|
||||
3 [ 0:-2:-3] [0, 1, 2]
|
||||
3 [ 0:-2:-2] [] []
|
||||
3 [ 0:-2:-2] [0, 1, 2]
|
||||
3 [ 0:-2:-1] [] []
|
||||
3 [ 0:-2:-1] [0, 1, 2]
|
||||
3 [ 0:-2: 1] [0] [0]
|
||||
3 [ 0:-2: 1] [-1, 1, 2]
|
||||
3 [ 0:-2: 2] [0] [0]
|
||||
3 [ 0:-2: 2] [-1, 1, 2]
|
||||
3 [ 0:-2: 3] [0] [0]
|
||||
3 [ 0:-2: 3] [-1, 1, 2]
|
||||
3 [ 0:-1:-3] [] []
|
||||
3 [ 0:-1:-3] [0, 1, 2]
|
||||
3 [ 0:-1:-2] [] []
|
||||
3 [ 0:-1:-2] [0, 1, 2]
|
||||
3 [ 0:-1:-1] [] []
|
||||
3 [ 0:-1:-1] [0, 1, 2]
|
||||
3 [ 0:-1: 1] [0, 1] [0, 1]
|
||||
3 [ 0:-1: 1] [-1, -1, 2]
|
||||
3 [ 0:-1: 2] [0] [0]
|
||||
3 [ 0:-1: 2] [-1, 1, 2]
|
||||
3 [ 0:-1: 3] [0] [0]
|
||||
3 [ 0:-1: 3] [-1, 1, 2]
|
||||
3 [ 0: 0:-3] [] []
|
||||
3 [ 0: 0:-3] [0, 1, 2]
|
||||
3 [ 0: 0:-2] [] []
|
||||
3 [ 0: 0:-2] [0, 1, 2]
|
||||
3 [ 0: 0:-1] [] []
|
||||
3 [ 0: 0:-1] [0, 1, 2]
|
||||
3 [ 0: 0: 1] [] []
|
||||
3 [ 0: 0: 1] [0, 1, 2]
|
||||
3 [ 0: 0: 2] [] []
|
||||
3 [ 0: 0: 2] [0, 1, 2]
|
||||
3 [ 0: 0: 3] [] []
|
||||
3 [ 0: 0: 3] [0, 1, 2]
|
||||
3 [ 0: 1:-3] [] []
|
||||
3 [ 0: 1:-3] [0, 1, 2]
|
||||
3 [ 0: 1:-2] [] []
|
||||
3 [ 0: 1:-2] [0, 1, 2]
|
||||
3 [ 0: 1:-1] [] []
|
||||
3 [ 0: 1:-1] [0, 1, 2]
|
||||
3 [ 0: 1: 1] [0] [0]
|
||||
3 [ 0: 1: 1] [-1, 1, 2]
|
||||
3 [ 0: 1: 2] [0] [0]
|
||||
3 [ 0: 1: 2] [-1, 1, 2]
|
||||
3 [ 0: 1: 3] [0] [0]
|
||||
3 [ 0: 1: 3] [-1, 1, 2]
|
||||
3 [ 0: 2:-3] [] []
|
||||
3 [ 0: 2:-3] [0, 1, 2]
|
||||
3 [ 0: 2:-2] [] []
|
||||
3 [ 0: 2:-2] [0, 1, 2]
|
||||
3 [ 0: 2:-1] [] []
|
||||
3 [ 0: 2:-1] [0, 1, 2]
|
||||
3 [ 0: 2: 1] [0, 1] [0, 1]
|
||||
3 [ 0: 2: 1] [-1, -1, 2]
|
||||
3 [ 0: 2: 2] [0] [0]
|
||||
3 [ 0: 2: 2] [-1, 1, 2]
|
||||
3 [ 0: 2: 3] [0] [0]
|
||||
3 [ 0: 2: 3] [-1, 1, 2]
|
||||
3 [ 0: 3:-3] [] []
|
||||
3 [ 0: 3:-3] [0, 1, 2]
|
||||
3 [ 0: 3:-2] [] []
|
||||
3 [ 0: 3:-2] [0, 1, 2]
|
||||
3 [ 0: 3:-1] [] []
|
||||
3 [ 0: 3:-1] [0, 1, 2]
|
||||
3 [ 0: 3: 1] [0, 1, 2] [0, 1, 2]
|
||||
3 [ 0: 3: 1] [-1, -1, -1]
|
||||
3 [ 0: 3: 2] [0, 2] [0, 2]
|
||||
3 [ 0: 3: 2] [-1, 1, -1]
|
||||
3 [ 0: 3: 3] [0] [0]
|
||||
3 [ 0: 3: 3] [-1, 1, 2]
|
||||
3 [ 1:-3:-3] [1] [1]
|
||||
3 [ 1:-3:-3] [0, -1, 2]
|
||||
3 [ 1:-3:-2] [1] [1]
|
||||
3 [ 1:-3:-2] [0, -1, 2]
|
||||
3 [ 1:-3:-1] [1] [1]
|
||||
3 [ 1:-3:-1] [0, -1, 2]
|
||||
3 [ 1:-3: 1] [] []
|
||||
3 [ 1:-3: 1] [0, 1, 2]
|
||||
3 [ 1:-3: 2] [] []
|
||||
3 [ 1:-3: 2] [0, 1, 2]
|
||||
3 [ 1:-3: 3] [] []
|
||||
3 [ 1:-3: 3] [0, 1, 2]
|
||||
3 [ 1:-2:-3] [] []
|
||||
3 [ 1:-2:-3] [0, 1, 2]
|
||||
3 [ 1:-2:-2] [] []
|
||||
3 [ 1:-2:-2] [0, 1, 2]
|
||||
3 [ 1:-2:-1] [] []
|
||||
3 [ 1:-2:-1] [0, 1, 2]
|
||||
3 [ 1:-2: 1] [] []
|
||||
3 [ 1:-2: 1] [0, 1, 2]
|
||||
3 [ 1:-2: 2] [] []
|
||||
3 [ 1:-2: 2] [0, 1, 2]
|
||||
3 [ 1:-2: 3] [] []
|
||||
3 [ 1:-2: 3] [0, 1, 2]
|
||||
3 [ 1:-1:-3] [] []
|
||||
3 [ 1:-1:-3] [0, 1, 2]
|
||||
3 [ 1:-1:-2] [] []
|
||||
3 [ 1:-1:-2] [0, 1, 2]
|
||||
3 [ 1:-1:-1] [] []
|
||||
3 [ 1:-1:-1] [0, 1, 2]
|
||||
3 [ 1:-1: 1] [1] [1]
|
||||
3 [ 1:-1: 1] [0, -1, 2]
|
||||
3 [ 1:-1: 2] [1] [1]
|
||||
3 [ 1:-1: 2] [0, -1, 2]
|
||||
3 [ 1:-1: 3] [1] [1]
|
||||
3 [ 1:-1: 3] [0, -1, 2]
|
||||
3 [ 1: 0:-3] [1] [1]
|
||||
3 [ 1: 0:-3] [0, -1, 2]
|
||||
3 [ 1: 0:-2] [1] [1]
|
||||
3 [ 1: 0:-2] [0, -1, 2]
|
||||
3 [ 1: 0:-1] [1] [1]
|
||||
3 [ 1: 0:-1] [0, -1, 2]
|
||||
3 [ 1: 0: 1] [] []
|
||||
3 [ 1: 0: 1] [0, 1, 2]
|
||||
3 [ 1: 0: 2] [] []
|
||||
3 [ 1: 0: 2] [0, 1, 2]
|
||||
3 [ 1: 0: 3] [] []
|
||||
3 [ 1: 0: 3] [0, 1, 2]
|
||||
3 [ 1: 1:-3] [] []
|
||||
3 [ 1: 1:-3] [0, 1, 2]
|
||||
3 [ 1: 1:-2] [] []
|
||||
3 [ 1: 1:-2] [0, 1, 2]
|
||||
3 [ 1: 1:-1] [] []
|
||||
3 [ 1: 1:-1] [0, 1, 2]
|
||||
3 [ 1: 1: 1] [] []
|
||||
3 [ 1: 1: 1] [0, 1, 2]
|
||||
3 [ 1: 1: 2] [] []
|
||||
3 [ 1: 1: 2] [0, 1, 2]
|
||||
3 [ 1: 1: 3] [] []
|
||||
3 [ 1: 1: 3] [0, 1, 2]
|
||||
3 [ 1: 2:-3] [] []
|
||||
3 [ 1: 2:-3] [0, 1, 2]
|
||||
3 [ 1: 2:-2] [] []
|
||||
3 [ 1: 2:-2] [0, 1, 2]
|
||||
3 [ 1: 2:-1] [] []
|
||||
3 [ 1: 2:-1] [0, 1, 2]
|
||||
3 [ 1: 2: 1] [1] [1]
|
||||
3 [ 1: 2: 1] [0, -1, 2]
|
||||
3 [ 1: 2: 2] [1] [1]
|
||||
3 [ 1: 2: 2] [0, -1, 2]
|
||||
3 [ 1: 2: 3] [1] [1]
|
||||
3 [ 1: 2: 3] [0, -1, 2]
|
||||
3 [ 1: 3:-3] [] []
|
||||
3 [ 1: 3:-3] [0, 1, 2]
|
||||
3 [ 1: 3:-2] [] []
|
||||
3 [ 1: 3:-2] [0, 1, 2]
|
||||
3 [ 1: 3:-1] [] []
|
||||
3 [ 1: 3:-1] [0, 1, 2]
|
||||
3 [ 1: 3: 1] [1, 2] [1, 2]
|
||||
3 [ 1: 3: 1] [0, -1, -1]
|
||||
3 [ 1: 3: 2] [1] [1]
|
||||
3 [ 1: 3: 2] [0, -1, 2]
|
||||
3 [ 1: 3: 3] [1] [1]
|
||||
3 [ 1: 3: 3] [0, -1, 2]
|
||||
3 [ 2:-3:-3] [2] [2]
|
||||
3 [ 2:-3:-3] [0, 1, -1]
|
||||
3 [ 2:-3:-2] [2] [2]
|
||||
3 [ 2:-3:-2] [0, 1, -1]
|
||||
3 [ 2:-3:-1] [2, 1] [2, 1]
|
||||
3 [ 2:-3:-1] [0, -1, -1]
|
||||
3 [ 2:-3: 1] [] []
|
||||
3 [ 2:-3: 1] [0, 1, 2]
|
||||
3 [ 2:-3: 2] [] []
|
||||
3 [ 2:-3: 2] [0, 1, 2]
|
||||
3 [ 2:-3: 3] [] []
|
||||
3 [ 2:-3: 3] [0, 1, 2]
|
||||
3 [ 2:-2:-3] [2] [2]
|
||||
3 [ 2:-2:-3] [0, 1, -1]
|
||||
3 [ 2:-2:-2] [2] [2]
|
||||
3 [ 2:-2:-2] [0, 1, -1]
|
||||
3 [ 2:-2:-1] [2] [2]
|
||||
3 [ 2:-2:-1] [0, 1, -1]
|
||||
3 [ 2:-2: 1] [] []
|
||||
3 [ 2:-2: 1] [0, 1, 2]
|
||||
3 [ 2:-2: 2] [] []
|
||||
3 [ 2:-2: 2] [0, 1, 2]
|
||||
3 [ 2:-2: 3] [] []
|
||||
3 [ 2:-2: 3] [0, 1, 2]
|
||||
3 [ 2:-1:-3] [] []
|
||||
3 [ 2:-1:-3] [0, 1, 2]
|
||||
3 [ 2:-1:-2] [] []
|
||||
3 [ 2:-1:-2] [0, 1, 2]
|
||||
3 [ 2:-1:-1] [] []
|
||||
3 [ 2:-1:-1] [0, 1, 2]
|
||||
3 [ 2:-1: 1] [] []
|
||||
3 [ 2:-1: 1] [0, 1, 2]
|
||||
3 [ 2:-1: 2] [] []
|
||||
3 [ 2:-1: 2] [0, 1, 2]
|
||||
3 [ 2:-1: 3] [] []
|
||||
3 [ 2:-1: 3] [0, 1, 2]
|
||||
3 [ 2: 0:-3] [2] [2]
|
||||
3 [ 2: 0:-3] [0, 1, -1]
|
||||
3 [ 2: 0:-2] [2] [2]
|
||||
3 [ 2: 0:-2] [0, 1, -1]
|
||||
3 [ 2: 0:-1] [2, 1] [2, 1]
|
||||
3 [ 2: 0:-1] [0, -1, -1]
|
||||
3 [ 2: 0: 1] [] []
|
||||
3 [ 2: 0: 1] [0, 1, 2]
|
||||
3 [ 2: 0: 2] [] []
|
||||
3 [ 2: 0: 2] [0, 1, 2]
|
||||
3 [ 2: 0: 3] [] []
|
||||
3 [ 2: 0: 3] [0, 1, 2]
|
||||
3 [ 2: 1:-3] [2] [2]
|
||||
3 [ 2: 1:-3] [0, 1, -1]
|
||||
3 [ 2: 1:-2] [2] [2]
|
||||
3 [ 2: 1:-2] [0, 1, -1]
|
||||
3 [ 2: 1:-1] [2] [2]
|
||||
3 [ 2: 1:-1] [0, 1, -1]
|
||||
3 [ 2: 1: 1] [] []
|
||||
3 [ 2: 1: 1] [0, 1, 2]
|
||||
3 [ 2: 1: 2] [] []
|
||||
3 [ 2: 1: 2] [0, 1, 2]
|
||||
3 [ 2: 1: 3] [] []
|
||||
3 [ 2: 1: 3] [0, 1, 2]
|
||||
3 [ 2: 2:-3] [] []
|
||||
3 [ 2: 2:-3] [0, 1, 2]
|
||||
3 [ 2: 2:-2] [] []
|
||||
3 [ 2: 2:-2] [0, 1, 2]
|
||||
3 [ 2: 2:-1] [] []
|
||||
3 [ 2: 2:-1] [0, 1, 2]
|
||||
3 [ 2: 2: 1] [] []
|
||||
3 [ 2: 2: 1] [0, 1, 2]
|
||||
3 [ 2: 2: 2] [] []
|
||||
3 [ 2: 2: 2] [0, 1, 2]
|
||||
3 [ 2: 2: 3] [] []
|
||||
3 [ 2: 2: 3] [0, 1, 2]
|
||||
3 [ 2: 3:-3] [] []
|
||||
3 [ 2: 3:-3] [0, 1, 2]
|
||||
3 [ 2: 3:-2] [] []
|
||||
3 [ 2: 3:-2] [0, 1, 2]
|
||||
3 [ 2: 3:-1] [] []
|
||||
3 [ 2: 3:-1] [0, 1, 2]
|
||||
3 [ 2: 3: 1] [2] [2]
|
||||
3 [ 2: 3: 1] [0, 1, -1]
|
||||
3 [ 2: 3: 2] [2] [2]
|
||||
3 [ 2: 3: 2] [0, 1, -1]
|
||||
3 [ 2: 3: 3] [2] [2]
|
||||
3 [ 2: 3: 3] [0, 1, -1]
|
||||
3 [ 3:-3:-3] [2] [2]
|
||||
3 [ 3:-3:-3] [0, 1, -1]
|
||||
3 [ 3:-3:-2] [2] [2]
|
||||
3 [ 3:-3:-2] [0, 1, -1]
|
||||
3 [ 3:-3:-1] [2, 1] [2, 1]
|
||||
3 [ 3:-3:-1] [0, -1, -1]
|
||||
3 [ 3:-3: 1] [] []
|
||||
3 [ 3:-3: 1] [0, 1, 2]
|
||||
3 [ 3:-3: 2] [] []
|
||||
3 [ 3:-3: 2] [0, 1, 2]
|
||||
3 [ 3:-3: 3] [] []
|
||||
3 [ 3:-3: 3] [0, 1, 2]
|
||||
3 [ 3:-2:-3] [2] [2]
|
||||
3 [ 3:-2:-3] [0, 1, -1]
|
||||
3 [ 3:-2:-2] [2] [2]
|
||||
3 [ 3:-2:-2] [0, 1, -1]
|
||||
3 [ 3:-2:-1] [2] [2]
|
||||
3 [ 3:-2:-1] [0, 1, -1]
|
||||
3 [ 3:-2: 1] [] []
|
||||
3 [ 3:-2: 1] [0, 1, 2]
|
||||
3 [ 3:-2: 2] [] []
|
||||
3 [ 3:-2: 2] [0, 1, 2]
|
||||
3 [ 3:-2: 3] [] []
|
||||
3 [ 3:-2: 3] [0, 1, 2]
|
||||
3 [ 3:-1:-3] [] []
|
||||
3 [ 3:-1:-3] [0, 1, 2]
|
||||
3 [ 3:-1:-2] [] []
|
||||
3 [ 3:-1:-2] [0, 1, 2]
|
||||
3 [ 3:-1:-1] [] []
|
||||
3 [ 3:-1:-1] [0, 1, 2]
|
||||
3 [ 3:-1: 1] [] []
|
||||
3 [ 3:-1: 1] [0, 1, 2]
|
||||
3 [ 3:-1: 2] [] []
|
||||
3 [ 3:-1: 2] [0, 1, 2]
|
||||
3 [ 3:-1: 3] [] []
|
||||
3 [ 3:-1: 3] [0, 1, 2]
|
||||
3 [ 3: 0:-3] [2] [2]
|
||||
3 [ 3: 0:-3] [0, 1, -1]
|
||||
3 [ 3: 0:-2] [2] [2]
|
||||
3 [ 3: 0:-2] [0, 1, -1]
|
||||
3 [ 3: 0:-1] [2, 1] [2, 1]
|
||||
3 [ 3: 0:-1] [0, -1, -1]
|
||||
3 [ 3: 0: 1] [] []
|
||||
3 [ 3: 0: 1] [0, 1, 2]
|
||||
3 [ 3: 0: 2] [] []
|
||||
3 [ 3: 0: 2] [0, 1, 2]
|
||||
3 [ 3: 0: 3] [] []
|
||||
3 [ 3: 0: 3] [0, 1, 2]
|
||||
3 [ 3: 1:-3] [2] [2]
|
||||
3 [ 3: 1:-3] [0, 1, -1]
|
||||
3 [ 3: 1:-2] [2] [2]
|
||||
3 [ 3: 1:-2] [0, 1, -1]
|
||||
3 [ 3: 1:-1] [2] [2]
|
||||
3 [ 3: 1:-1] [0, 1, -1]
|
||||
3 [ 3: 1: 1] [] []
|
||||
3 [ 3: 1: 1] [0, 1, 2]
|
||||
3 [ 3: 1: 2] [] []
|
||||
3 [ 3: 1: 2] [0, 1, 2]
|
||||
3 [ 3: 1: 3] [] []
|
||||
3 [ 3: 1: 3] [0, 1, 2]
|
||||
3 [ 3: 2:-3] [] []
|
||||
3 [ 3: 2:-3] [0, 1, 2]
|
||||
3 [ 3: 2:-2] [] []
|
||||
3 [ 3: 2:-2] [0, 1, 2]
|
||||
3 [ 3: 2:-1] [] []
|
||||
3 [ 3: 2:-1] [0, 1, 2]
|
||||
3 [ 3: 2: 1] [] []
|
||||
3 [ 3: 2: 1] [0, 1, 2]
|
||||
3 [ 3: 2: 2] [] []
|
||||
3 [ 3: 2: 2] [0, 1, 2]
|
||||
3 [ 3: 2: 3] [] []
|
||||
3 [ 3: 2: 3] [0, 1, 2]
|
||||
3 [ 3: 3:-3] [] []
|
||||
3 [ 3: 3:-3] [0, 1, 2]
|
||||
3 [ 3: 3:-2] [] []
|
||||
3 [ 3: 3:-2] [0, 1, 2]
|
||||
3 [ 3: 3:-1] [] []
|
||||
3 [ 3: 3:-1] [0, 1, 2]
|
||||
3 [ 3: 3: 1] [] []
|
||||
3 [ 3: 3: 1] [0, 1, 2]
|
||||
3 [ 3: 3: 2] [] []
|
||||
3 [ 3: 3: 2] [0, 1, 2]
|
||||
3 [ 3: 3: 3] [] []
|
||||
3 [ 3: 3: 3] [0, 1, 2]
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
try:
|
||||
import ulab as np
|
||||
except:
|
||||
import numpy as np
|
||||
|
||||
a = np.array(range(9), dtype=np.float)
|
||||
print("a:\t", list(a))
|
||||
print("a < 5:\t", list(a[a < 5]))
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
a: [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
|
||||
a < 5: [0.0, 1.0, 2.0, 3.0, 4.0]
|
||||
Loading…
Reference in a new issue