467 lines
14 KiB
Text
467 lines
14 KiB
Text
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2021-01-08T13:02:42.934528Z",
|
|
"start_time": "2021-01-08T13:02:42.720862Z"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Populating the interactive namespace from numpy and matplotlib\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%pylab inline"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Notebook magic"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2021-01-08T13:02:44.890094Z",
|
|
"start_time": "2021-01-08T13:02:44.878787Z"
|
|
}
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from IPython.core.magic import Magics, magics_class, line_cell_magic\n",
|
|
"from IPython.core.magic import cell_magic, register_cell_magic, register_line_magic\n",
|
|
"from IPython.core.magic_arguments import argument, magic_arguments, parse_argstring\n",
|
|
"import subprocess\n",
|
|
"import os"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2021-01-08T13:06:20.583308Z",
|
|
"start_time": "2021-01-08T13:06:20.525830Z"
|
|
}
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"@magics_class\n",
|
|
"class PyboardMagic(Magics):\n",
|
|
" @cell_magic\n",
|
|
" @magic_arguments()\n",
|
|
" @argument('-skip')\n",
|
|
" @argument('-unix')\n",
|
|
" @argument('-pyboard')\n",
|
|
" @argument('-file')\n",
|
|
" @argument('-data')\n",
|
|
" @argument('-time')\n",
|
|
" @argument('-memory')\n",
|
|
" def micropython(self, line='', cell=None):\n",
|
|
" args = parse_argstring(self.micropython, line)\n",
|
|
" if args.skip: # doesn't care about the cell's content\n",
|
|
" print('skipped execution')\n",
|
|
" return None # do not parse the rest\n",
|
|
" if args.unix: # tests the code on the unix port. Note that this works on unix only\n",
|
|
" with open('/dev/shm/micropython.py', 'w') as fout:\n",
|
|
" fout.write(cell)\n",
|
|
" proc = subprocess.Popen([\"../../micropython/ports/unix/micropython\", \"/dev/shm/micropython.py\"], \n",
|
|
" stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n",
|
|
" print(proc.stdout.read().decode(\"utf-8\"))\n",
|
|
" print(proc.stderr.read().decode(\"utf-8\"))\n",
|
|
" return None\n",
|
|
" if args.file: # can be used to copy the cell content onto the pyboard's flash\n",
|
|
" spaces = \" \"\n",
|
|
" try:\n",
|
|
" with open(args.file, 'w') as fout:\n",
|
|
" fout.write(cell.replace('\\t', spaces))\n",
|
|
" printf('written cell to {}'.format(args.file))\n",
|
|
" except:\n",
|
|
" print('Failed to write to disc!')\n",
|
|
" return None # do not parse the rest\n",
|
|
" if args.data: # can be used to load data from the pyboard directly into kernel space\n",
|
|
" message = pyb.exec(cell)\n",
|
|
" if len(message) == 0:\n",
|
|
" print('pyboard >>>')\n",
|
|
" else:\n",
|
|
" print(message.decode('utf-8'))\n",
|
|
" # register new variable in user namespace\n",
|
|
" self.shell.user_ns[args.data] = string_to_matrix(message.decode(\"utf-8\"))\n",
|
|
" \n",
|
|
" if args.time: # measures the time of executions\n",
|
|
" pyb.exec('import utime')\n",
|
|
" message = pyb.exec('t = utime.ticks_us()\\n' + cell + '\\ndelta = utime.ticks_diff(utime.ticks_us(), t)' + \n",
|
|
" \"\\nprint('execution time: {:d} us'.format(delta))\")\n",
|
|
" print(message.decode('utf-8'))\n",
|
|
" \n",
|
|
" if args.memory: # prints out memory information \n",
|
|
" message = pyb.exec('from micropython import mem_info\\nprint(mem_info())\\n')\n",
|
|
" print(\"memory before execution:\\n========================\\n\", message.decode('utf-8'))\n",
|
|
" message = pyb.exec(cell)\n",
|
|
" print(\">>> \", message.decode('utf-8'))\n",
|
|
" message = pyb.exec('print(mem_info())')\n",
|
|
" print(\"memory after execution:\\n========================\\n\", message.decode('utf-8'))\n",
|
|
"\n",
|
|
" if args.pyboard:\n",
|
|
" message = pyb.exec(cell)\n",
|
|
" print(message.decode('utf-8'))\n",
|
|
"\n",
|
|
"ip = get_ipython()\n",
|
|
"ip.register_magics(PyboardMagic)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## pyboard"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 57,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2020-05-07T07:35:35.126401Z",
|
|
"start_time": "2020-05-07T07:35:35.105824Z"
|
|
}
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"import pyboard\n",
|
|
"pyb = pyboard.Pyboard('/dev/ttyACM0')\n",
|
|
"pyb.enter_raw_repl()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2020-05-19T19:11:18.145548Z",
|
|
"start_time": "2020-05-19T19:11:18.137468Z"
|
|
}
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"pyb.exit_raw_repl()\n",
|
|
"pyb.close()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 58,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2020-05-07T07:35:38.725924Z",
|
|
"start_time": "2020-05-07T07:35:38.645488Z"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -pyboard 1\n",
|
|
"\n",
|
|
"import utime\n",
|
|
"import ulab as np\n",
|
|
"\n",
|
|
"def timeit(n=1000):\n",
|
|
" def wrapper(f, *args, **kwargs):\n",
|
|
" func_name = str(f).split(' ')[1]\n",
|
|
" def new_func(*args, **kwargs):\n",
|
|
" run_times = np.zeros(n, dtype=np.uint16)\n",
|
|
" for i in range(n):\n",
|
|
" t = utime.ticks_us()\n",
|
|
" result = f(*args, **kwargs)\n",
|
|
" run_times[i] = utime.ticks_diff(utime.ticks_us(), t)\n",
|
|
" print('{}() execution times based on {} cycles'.format(func_name, n, (delta2-delta1)/n))\n",
|
|
" print('\\tbest: %d us'%np.min(run_times))\n",
|
|
" print('\\tworst: %d us'%np.max(run_times))\n",
|
|
" print('\\taverage: %d us'%np.mean(run_times))\n",
|
|
" print('\\tdeviation: +/-%.3f us'%np.std(run_times)) \n",
|
|
" return result\n",
|
|
" return new_func\n",
|
|
" return wrapper\n",
|
|
"\n",
|
|
"def timeit(f, *args, **kwargs):\n",
|
|
" func_name = str(f).split(' ')[1]\n",
|
|
" def new_func(*args, **kwargs):\n",
|
|
" t = utime.ticks_us()\n",
|
|
" result = f(*args, **kwargs)\n",
|
|
" print('execution time: ', utime.ticks_diff(utime.ticks_us(), t), ' us')\n",
|
|
" return result\n",
|
|
" return new_func"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"__END_OF_DEFS__"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Comparison of arrays"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## equal, not_equal\n",
|
|
"\n",
|
|
"`numpy`: https://numpy.org/doc/stable/reference/generated/numpy.equal.html\n",
|
|
"\n",
|
|
"`numpy`: https://numpy.org/doc/stable/reference/generated/numpy.not_equal.html\n",
|
|
"\n",
|
|
"In `micropython`, equality of arrays or scalars can be established by utilising the `==`, `!=`, `<`, `>`, `<=`, or `=>` binary operators. In `circuitpython`, `==` and `!=` will produce unexpected results. In order to avoid this discrepancy, and to maintain compatibility with `numpy`, `ulab` implements the `equal` and `not_equal` operators that return the same results, irrespective of the `python` implementation.\n",
|
|
"\n",
|
|
"These two functions take two `ndarray`s, or scalars as their arguments. No keyword arguments are implemented."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 13,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2021-01-08T14:22:13.990898Z",
|
|
"start_time": "2021-01-08T14:22:13.941896Z"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"a: array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], dtype=float64)\n",
|
|
"b: array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=float64)\n",
|
|
"\n",
|
|
"a == b: array([True, False, False, False, False, False, False, False, False], dtype=bool)\n",
|
|
"a != b: array([False, True, True, True, True, True, True, True, True], dtype=bool)\n",
|
|
"a == 2: array([False, False, True, False, False, False, False, False, False], dtype=bool)\n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -unix 1\n",
|
|
"\n",
|
|
"from ulab import numpy as np\n",
|
|
"\n",
|
|
"a = np.array(range(9))\n",
|
|
"b = np.zeros(9)\n",
|
|
"\n",
|
|
"print('a: ', a)\n",
|
|
"print('b: ', b)\n",
|
|
"print('\\na == b: ', np.equal(a, b))\n",
|
|
"print('a != b: ', np.not_equal(a, b))\n",
|
|
"\n",
|
|
"# comparison with scalars\n",
|
|
"print('a == 2: ', np.equal(a, 2))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## minimum\n",
|
|
"\n",
|
|
"`numpy`: https://docs.scipy.org/doc/numpy/reference/generated/numpy.minimum.html\n",
|
|
"\n",
|
|
"Returns the minimum of two arrays, or two scalars, or an array, and a scalar. If the arrays are of different `dtype`, the output is upcast as in [Binary operators](#Binary-operators). If both inputs are scalars, a scalar is returned. Only positional arguments are implemented.\n",
|
|
"\n",
|
|
"## maximum\n",
|
|
"\n",
|
|
"`numpy`: https://docs.scipy.org/doc/numpy/reference/generated/numpy.maximum.html\n",
|
|
"\n",
|
|
"Returns the maximum of two arrays, or two scalars, or an array, and a scalar. If the arrays are of different `dtype`, the output is upcast as in [Binary operators](#Binary-operators). If both inputs are scalars, a scalar is returned. Only positional arguments are implemented."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2021-01-08T13:21:17.151280Z",
|
|
"start_time": "2021-01-08T13:21:17.123768Z"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"minimum of a, and b:\n",
|
|
"array([1.0, 2.0, 3.0, 2.0, 1.0], dtype=float64)\n",
|
|
"\n",
|
|
"maximum of a, and b:\n",
|
|
"array([5.0, 4.0, 3.0, 4.0, 5.0], dtype=float64)\n",
|
|
"\n",
|
|
"maximum of 1, and 5.5:\n",
|
|
"5.5\n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -unix 1\n",
|
|
"\n",
|
|
"from ulab import numpy as np\n",
|
|
"\n",
|
|
"a = np.array([1, 2, 3, 4, 5], dtype=np.uint8)\n",
|
|
"b = np.array([5, 4, 3, 2, 1], dtype=np.float)\n",
|
|
"print('minimum of a, and b:')\n",
|
|
"print(np.minimum(a, b))\n",
|
|
"\n",
|
|
"print('\\nmaximum of a, and b:')\n",
|
|
"print(np.maximum(a, b))\n",
|
|
"\n",
|
|
"print('\\nmaximum of 1, and 5.5:')\n",
|
|
"print(np.maximum(1, 5.5))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## clip\n",
|
|
"\n",
|
|
"`numpy`: https://docs.scipy.org/doc/numpy/reference/generated/numpy.clip.html\n",
|
|
"\n",
|
|
"Clips an array, i.e., values that are outside of an interval are clipped to the interval edges. The function is equivalent to `maximum(a_min, minimum(a, a_max))` broadcasting takes place exactly as in [minimum](#minimum). If the arrays are of different `dtype`, the output is upcast as in [Binary operators](#Binary-operators)."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2021-01-08T13:22:14.147310Z",
|
|
"start_time": "2021-01-08T13:22:14.123961Z"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"a:\t\t array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=uint8)\n",
|
|
"clipped:\t array([3, 3, 3, 3, 4, 5, 6, 7, 7], dtype=uint8)\n",
|
|
"\n",
|
|
"a:\t\t array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=uint8)\n",
|
|
"b:\t\t array([3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0], dtype=float64)\n",
|
|
"clipped:\t array([3.0, 3.0, 3.0, 3.0, 4.0, 5.0, 6.0, 7.0, 7.0], dtype=float64)\n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -unix 1\n",
|
|
"\n",
|
|
"from ulab import numpy as np\n",
|
|
"\n",
|
|
"a = np.array(range(9), dtype=np.uint8)\n",
|
|
"print('a:\\t\\t', a)\n",
|
|
"print('clipped:\\t', np.clip(a, 3, 7))\n",
|
|
"\n",
|
|
"b = 3 * np.ones(len(a), dtype=np.float)\n",
|
|
"print('\\na:\\t\\t', a)\n",
|
|
"print('b:\\t\\t', b)\n",
|
|
"print('clipped:\\t', np.clip(a, b, 7))"
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.8.5"
|
|
},
|
|
"toc": {
|
|
"base_numbering": 1,
|
|
"nav_menu": {},
|
|
"number_sections": true,
|
|
"sideBar": true,
|
|
"skip_h1_title": false,
|
|
"title_cell": "Table of Contents",
|
|
"title_sidebar": "Contents",
|
|
"toc_cell": false,
|
|
"toc_position": {
|
|
"height": "calc(100% - 180px)",
|
|
"left": "10px",
|
|
"top": "150px",
|
|
"width": "382.797px"
|
|
},
|
|
"toc_section_display": true,
|
|
"toc_window_display": true
|
|
},
|
|
"varInspector": {
|
|
"cols": {
|
|
"lenName": 16,
|
|
"lenType": 16,
|
|
"lenVar": 40
|
|
},
|
|
"kernels_config": {
|
|
"python": {
|
|
"delete_cmd_postfix": "",
|
|
"delete_cmd_prefix": "del ",
|
|
"library": "var_list.py",
|
|
"varRefreshCmd": "print(var_dic_list())"
|
|
},
|
|
"r": {
|
|
"delete_cmd_postfix": ") ",
|
|
"delete_cmd_prefix": "rm(",
|
|
"library": "var_list.r",
|
|
"varRefreshCmd": "cat(var_dic_list()) "
|
|
}
|
|
},
|
|
"types_to_exclude": [
|
|
"module",
|
|
"function",
|
|
"builtin_function_or_method",
|
|
"instance",
|
|
"_Feature"
|
|
],
|
|
"window_display": false
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 4
|
|
}
|