396 lines
16 KiB
C
396 lines
16 KiB
C
/*
|
|
* This file is part of the micropython-ulab project,
|
|
*
|
|
* https://github.com/v923z/micropython-ulab
|
|
*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2020 Zoltán Vörös
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "py/obj.h"
|
|
#include "py/runtime.h"
|
|
#include "py/misc.h"
|
|
#include "linalg.h"
|
|
#include "approx.h"
|
|
|
|
#if ULAB_APPROX_MODULE
|
|
|
|
const mp_obj_float_t xtolerance = {{&mp_type_float}, 2.4e-7};
|
|
const mp_obj_float_t rtolerance = {{&mp_type_float}, 0.0};
|
|
|
|
mp_float_t approx_python_call(const mp_obj_type_t *type, mp_obj_t fun, mp_float_t x, mp_obj_t *fargs, uint8_t nparams) {
|
|
// Helper function for calculating the value of f(x, a, b, c, ...),
|
|
// where f is defined in python. Takes a float, returns a float.
|
|
// The array of mp_obj_t type must be supplied, as must the number of parameters (a, b, c...) in nparams
|
|
fargs[0] = mp_obj_new_float(x);
|
|
return mp_obj_get_float(type->call(fun, nparams+1, 0, fargs));
|
|
}
|
|
|
|
mp_obj_t approx_bisect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
|
// Simple bisection routine
|
|
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_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
|
|
{ MP_QSTR_xtol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&xtolerance)} },
|
|
{ MP_QSTR_maxiter, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 100} },
|
|
};
|
|
|
|
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);
|
|
|
|
mp_obj_t fun = args[0].u_obj;
|
|
const mp_obj_type_t *type = mp_obj_get_type(fun);
|
|
if(type->call == NULL) {
|
|
mp_raise_TypeError(translate("first argument must be a function"));
|
|
}
|
|
mp_float_t xtol = mp_obj_get_float(args[3].u_obj);
|
|
mp_obj_t *fargs = m_new(mp_obj_t, 1);
|
|
mp_float_t left, right;
|
|
mp_float_t x_mid;
|
|
mp_float_t a = mp_obj_get_float(args[1].u_obj);
|
|
mp_float_t b = mp_obj_get_float(args[2].u_obj);
|
|
left = approx_python_call(type, fun, a, fargs, 0);
|
|
right = approx_python_call(type, fun, b, fargs, 0);
|
|
if(left * right > 0) {
|
|
mp_raise_ValueError(translate("function has the same sign at the ends of interval"));
|
|
}
|
|
mp_float_t rtb = left < 0.0 ? a : b;
|
|
mp_float_t dx = left < 0.0 ? b - a : a - b;
|
|
|
|
for(uint16_t i=0; i < args[4].u_int; i++) {
|
|
dx *= 0.5;
|
|
x_mid = rtb + dx;
|
|
if(approx_python_call(type, fun, x_mid, fargs, 0) < 0.0) {
|
|
rtb = x_mid;
|
|
}
|
|
if(MICROPY_FLOAT_C_FUN(fabs)(dx) < xtol) break;
|
|
}
|
|
return mp_obj_new_float(rtb);
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(approx_bisect_obj, 3, approx_bisect);
|
|
|
|
mp_obj_t approx_newton(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
|
// this is actually the secant method, as the first derivative of the function
|
|
// is not accepted as an argument. The function whose root we want to solve for
|
|
// must depend on a single variable without parameters, i.e., f(x)
|
|
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_tol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&xtolerance)} },
|
|
{ MP_QSTR_rtol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&rtolerance)} },
|
|
{ MP_QSTR_maxiter, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 50} },
|
|
};
|
|
|
|
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);
|
|
|
|
mp_obj_t fun = args[0].u_obj;
|
|
const mp_obj_type_t *type = mp_obj_get_type(fun);
|
|
if(type->call == NULL) {
|
|
mp_raise_TypeError(translate("first argument must be a function"));
|
|
}
|
|
mp_float_t x = mp_obj_get_float(args[1].u_obj);
|
|
mp_float_t tol = mp_obj_get_float(args[2].u_obj);
|
|
mp_float_t rtol = mp_obj_get_float(args[3].u_obj);
|
|
mp_float_t dx, df, fx;
|
|
dx = x > 0.0 ? APPROX_EPS * x : -APPROX_EPS * x;
|
|
mp_obj_t *fargs = m_new(mp_obj_t, 1);
|
|
for(uint16_t i=0; i < args[4].u_int; i++) {
|
|
fx = approx_python_call(type, fun, x, fargs, 0);
|
|
df = (approx_python_call(type, fun, x + dx, fargs, 0) - fx) / dx;
|
|
dx = fx / df;
|
|
x -= dx;
|
|
if(MICROPY_FLOAT_C_FUN(fabs)(dx) < (tol + rtol * MICROPY_FLOAT_C_FUN(fabs)(x))) break;
|
|
}
|
|
return mp_obj_new_float(x);
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(approx_newton_obj, 2, approx_newton);
|
|
|
|
mp_obj_t approx_fmin(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
|
// downhill simplex method in 1D
|
|
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_xatol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&xtolerance)} },
|
|
{ MP_QSTR_fatol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&xtolerance)} },
|
|
{ MP_QSTR_maxiter, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
|
|
};
|
|
|
|
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);
|
|
|
|
mp_obj_t fun = args[0].u_obj;
|
|
const mp_obj_type_t *type = mp_obj_get_type(fun);
|
|
if(type->call == NULL) {
|
|
mp_raise_TypeError(translate("first argument must be a function"));
|
|
}
|
|
|
|
// parameters controlling convergence conditions
|
|
mp_float_t xatol = mp_obj_get_float(args[2].u_obj);
|
|
mp_float_t fatol = mp_obj_get_float(args[3].u_obj);
|
|
uint16_t maxiter = args[4].u_obj == mp_const_none ? 200 : mp_obj_get_int(args[4].u_obj);
|
|
|
|
mp_float_t x0 = mp_obj_get_float(args[1].u_obj);
|
|
mp_float_t x1 = x0 != 0.0 ? (1.0 + APPROX_NONZDELTA) * x0 : APPROX_ZDELTA;
|
|
mp_obj_t *fargs = m_new(mp_obj_t, 1);
|
|
mp_float_t f0 = approx_python_call(type, fun, x0, fargs, 0);
|
|
mp_float_t f1 = approx_python_call(type, fun, x1, fargs, 0);
|
|
if(f1 < f0) {
|
|
SWAP(mp_float_t, x0, x1);
|
|
SWAP(mp_float_t, f0, f1);
|
|
}
|
|
for(uint16_t i=0; i < maxiter; i++) {
|
|
uint8_t shrink = 0;
|
|
f0 = approx_python_call(type, fun, x0, fargs, 0);
|
|
f1 = approx_python_call(type, fun, x1, fargs, 0);
|
|
|
|
// reflection
|
|
mp_float_t xr = (1.0 + APPROX_ALPHA) * x0 - APPROX_ALPHA * x1;
|
|
mp_float_t fr = approx_python_call(type, fun, xr, fargs, 0);
|
|
if(fr < f0) { // expansion
|
|
mp_float_t xe = (1 + APPROX_ALPHA * APPROX_BETA) * x0 - APPROX_ALPHA * APPROX_BETA * x1;
|
|
mp_float_t fe = approx_python_call(type, fun, xe, fargs, 0);
|
|
if(fe < fr) {
|
|
x1 = xe;
|
|
f1 = fe;
|
|
} else {
|
|
x1 = xr;
|
|
f1 = fr;
|
|
}
|
|
} else {
|
|
if(fr < f1) { // contraction
|
|
mp_float_t xc = (1 + APPROX_GAMMA * APPROX_ALPHA) * x0 - APPROX_GAMMA * APPROX_ALPHA * x1;
|
|
mp_float_t fc = approx_python_call(type, fun, xc, fargs, 0);
|
|
if(fc < fr) {
|
|
x1 = xc;
|
|
f1 = fc;
|
|
} else {
|
|
shrink = 1;
|
|
}
|
|
} else { // inside contraction
|
|
mp_float_t xc = (1.0 - APPROX_GAMMA) * x0 + APPROX_GAMMA * x1;
|
|
mp_float_t fc = approx_python_call(type, fun, xc, fargs, 0);
|
|
if(fc < f1) {
|
|
x1 = xc;
|
|
f1 = fc;
|
|
} else {
|
|
shrink = 1;
|
|
}
|
|
}
|
|
if(shrink == 1) {
|
|
x1 = x0 + APPROX_DELTA * (x1 - x0);
|
|
f1 = approx_python_call(type, fun, x1, fargs, 0);
|
|
}
|
|
if((MICROPY_FLOAT_C_FUN(fabs)(f1 - f0) < fatol) ||
|
|
(MICROPY_FLOAT_C_FUN(fabs)(x1 - x0) < xatol)) {
|
|
break;
|
|
}
|
|
if(f1 < f0) {
|
|
SWAP(mp_float_t, x0, x1);
|
|
SWAP(mp_float_t, f0, f1);
|
|
}
|
|
}
|
|
}
|
|
return mp_obj_new_float(x0);
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(approx_fmin_obj, 2, approx_fmin);
|
|
|
|
#if 0
|
|
static void approx_jacobi(const mp_obj_type_t *type, mp_obj_t fun, mp_float_t *x, mp_float_t *y, uint16_t len, mp_float_t *params, uint8_t nparams, mp_float_t *jacobi, mp_float_t *grad) {
|
|
/* Calculates the Jacobian and the gradient of the cost function
|
|
*
|
|
* The entries in the Jacobian are
|
|
* J(m, n) = de_m/da_n,
|
|
*
|
|
* where
|
|
*
|
|
* e_m = (f(x_m, a1, a2, ...) - y_m)/sigma_m is the error at x_m,
|
|
*
|
|
* and
|
|
*
|
|
* a1, a2, ..., a_n are the free parameters
|
|
*/
|
|
mp_obj_t *fargs0 = m_new(mp_obj_t, lenp+1);
|
|
mp_obj_t *fargs1 = m_new(mp_obj_t, lenp+1);
|
|
for(uint8_t p=0; p < nparams; p++) {
|
|
fargs0[p+1] = mp_obj_new_float(params[p]);
|
|
fargs1[p+1] = mp_obj_new_float(params[p]);
|
|
}
|
|
for(uint8_t p=0; p < nparams; p++) {
|
|
mp_float_t da = params[p] != 0.0 ? (1.0 + APPROX_NONZDELTA) * params[p] : APPROX_ZDELTA;
|
|
fargs1[p+1] = mp_obj_new_float(params[p] + da);
|
|
grad[p] = 0.0;
|
|
for(uint16_t i=0; i < len; i++) {
|
|
mp_float_t f0 = approx_python_call(type, fun, x[i], fargs0, nparams);
|
|
mp_float_t f1 = approx_python_call(type, fun, x[i], fargs1, nparams);
|
|
jacobi[i*nparamp+p] = (f1 - f0) / da;
|
|
grad[p] += (f0 - y[i]) * jacobi[i*nparamp+p];
|
|
}
|
|
fargs1[p+1] = fargs0[p+1]; // set back to the original value
|
|
}
|
|
}
|
|
|
|
static void approx_delta(mp_float_t *jacobi, mp_float_t *grad, uint16_t len, uint8_t nparams, mp_float_t lambda) {
|
|
//
|
|
}
|
|
|
|
mp_obj_t approx_curve_fit(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
|
// Levenberg-Marquardt non-linear fit
|
|
// The implementation follows the introductory discussion in Mark Tanstrum's paper, https://arxiv.org/abs/1201.5885
|
|
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_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
|
{ MP_QSTR_p0, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
|
{ MP_QSTR_xatol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&xtolerance)} },
|
|
{ MP_QSTR_fatol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&xtolerance)} },
|
|
{ MP_QSTR_maxiter, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
|
|
};
|
|
|
|
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);
|
|
|
|
mp_obj_t fun = args[0].u_obj;
|
|
const mp_obj_type_t *type = mp_obj_get_type(fun);
|
|
if(type->call == NULL) {
|
|
mp_raise_TypeError(translate("first argument must be a function"));
|
|
}
|
|
|
|
mp_obj_t x_obj = args[1].u_obj;
|
|
mp_obj_t y_obj = args[2].u_obj;
|
|
mp_obj_t p0_obj = args[3].u_obj;
|
|
if(!ndarray_object_is_nditerable(x_obj) || !ndarray_object_is_nditerable(y_obj)) {
|
|
mp_raise_TypeError(translate("data must be iterable"));
|
|
}
|
|
if(!ndarray_object_is_nditerable(p0_obj)) {
|
|
mp_raise_TypeError(translate("initial values must be iterable"));
|
|
}
|
|
uint16_t len = (uint16_t)mp_obj_get_int(mp_obj_len_maybe(x_obj));
|
|
uint8_t lenp = (uint8_t)mp_obj_get_int(mp_obj_len_maybe(p0_obj));
|
|
if(len != (uint16_t)mp_obj_get_int(mp_obj_len_maybe(y_obj))) {
|
|
mp_raise_ValueError(translate("data must be of equal length"));
|
|
}
|
|
|
|
mp_float_t *x = m_new(mp_float_t, len);
|
|
fill_array_iterable(x, x_obj);
|
|
mp_float_t *y = m_new(mp_float_t, len);
|
|
fill_array_iterable(y, y_obj);
|
|
mp_float_t *p0 = m_new(mp_float_t, lenp);
|
|
fill_array_iterable(p0, p0_obj);
|
|
mp_float_t *grad = m_new(mp_float_t, len);
|
|
mp_float_t *jacobi = m_new(mp_float_t, len*len);
|
|
mp_obj_t *fargs = m_new(mp_obj_t, lenp+1);
|
|
|
|
m_del(mp_float_t, p0, lenp);
|
|
// parameters controlling convergence conditions
|
|
//mp_float_t xatol = mp_obj_get_float(args[2].u_obj);
|
|
//mp_float_t fatol = mp_obj_get_float(args[3].u_obj);
|
|
|
|
// this has finite binary representation; we will multiply/divide by 4
|
|
//mp_float_t lambda = 0.0078125;
|
|
|
|
//linalg_invert_matrix(mp_float_t *data, size_t N)
|
|
|
|
m_del(mp_float_t, x, len);
|
|
m_del(mp_float_t, y, len);
|
|
m_del(mp_float_t, grad, len);
|
|
m_del(mp_float_t, jacobi, len*len);
|
|
m_del(mp_obj_t, fargs, lenp+1);
|
|
return mp_const_none;
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(approx_curve_fit_obj, 2, approx_curve_fit);
|
|
|
|
#endif
|
|
|
|
mp_obj_t approx_interp(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_, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = mp_const_none } },
|
|
{ MP_QSTR_left, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
|
|
{ MP_QSTR_right, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
|
|
};
|
|
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);
|
|
|
|
ndarray_obj_t *x = ndarray_from_mp_obj(args[0].u_obj);
|
|
ndarray_obj_t *xp = ndarray_from_mp_obj(args[1].u_obj); // xp must hold an increasing sequence of independent values
|
|
ndarray_obj_t *fp = ndarray_from_mp_obj(args[2].u_obj);
|
|
// TODO: check if the shape is (1, n), or (m, 1)
|
|
if(((xp->m != 1) && (xp->n != 1)) || ((fp->m != 1) && (fp->n != 1)) ||
|
|
(xp->array->len < 2) || (fp->array->len < 2) || (xp->array->len != fp->array->len)) {
|
|
mp_raise_ValueError(translate("interp is defined for 1D arrays of equal length"));
|
|
}
|
|
ndarray_obj_t *y = create_new_ndarray(x->m, x->n, NDARRAY_FLOAT);
|
|
mp_float_t left_value, right_value;
|
|
mp_float_t xp_left = ndarray_get_float_value(xp->array->items, xp->array->typecode, 0);
|
|
mp_float_t xp_right = ndarray_get_float_value(xp->array->items, xp->array->typecode, xp->array->len-1);
|
|
if(args[3].u_obj == mp_const_none) {
|
|
left_value = ndarray_get_float_value(fp->array->items, fp->array->typecode, 0);
|
|
} else {
|
|
left_value = mp_obj_get_float(args[3].u_obj);
|
|
}
|
|
if(args[4].u_obj == mp_const_none) {
|
|
right_value = ndarray_get_float_value(fp->array->items, fp->array->typecode, fp->array->len-1);
|
|
} else {
|
|
right_value = mp_obj_get_float(args[4].u_obj);
|
|
}
|
|
mp_float_t *yarray = (mp_float_t *)y->array->items;
|
|
for(size_t i=0; i < x->array->len; i++, yarray++) {
|
|
mp_float_t x_value = ndarray_get_float_value(x->array->items, x->array->typecode, i);
|
|
if(x_value <= xp_left) {
|
|
*yarray = left_value;
|
|
} else if(x_value >= xp_right) {
|
|
*yarray = right_value;
|
|
} else { // do the binary search here
|
|
mp_float_t xp_left_, xp_right_;
|
|
mp_float_t fp_left, fp_right;
|
|
size_t left_index = 0, right_index = xp->array->len - 1, middle_index;
|
|
while(right_index - left_index > 1) {
|
|
middle_index = left_index + (right_index - left_index) / 2;
|
|
mp_float_t xp_middle = ndarray_get_float_value(xp->array->items, xp->array->typecode, middle_index);
|
|
if(x_value <= xp_middle) {
|
|
right_index = middle_index;
|
|
} else {
|
|
left_index = middle_index;
|
|
}
|
|
}
|
|
xp_left_ = ndarray_get_float_value(xp->array->items, xp->array->typecode, left_index);
|
|
xp_right_ = ndarray_get_float_value(xp->array->items, xp->array->typecode, right_index);
|
|
fp_left = ndarray_get_float_value(fp->array->items, fp->array->typecode, left_index);
|
|
fp_right = ndarray_get_float_value(fp->array->items, fp->array->typecode, right_index);
|
|
*yarray = fp_left + (x_value - xp_left_) * (fp_right - fp_left) / (xp_right_ - xp_left_);
|
|
}
|
|
}
|
|
return MP_OBJ_FROM_PTR(y);
|
|
}
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(approx_interp_obj, 2, approx_interp);
|
|
|
|
STATIC const mp_rom_map_elem_t ulab_approx_globals_table[] = {
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_approx) },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_bisect), (mp_obj_t)&approx_bisect_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_newton), (mp_obj_t)&approx_newton_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_fmin), (mp_obj_t)&approx_fmin_obj },
|
|
// { MP_OBJ_NEW_QSTR(MP_QSTR_curve_fit), (mp_obj_t)&approx_curve_fit_obj },
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_interp), (mp_obj_t)&approx_interp_obj },
|
|
};
|
|
|
|
STATIC MP_DEFINE_CONST_DICT(mp_module_ulab_approx_globals, ulab_approx_globals_table);
|
|
|
|
mp_obj_module_t ulab_approx_module = {
|
|
.base = { &mp_type_module },
|
|
.globals = (mp_obj_dict_t*)&mp_module_ulab_approx_globals,
|
|
};
|
|
|
|
#endif
|
|
|