f2fad82a97
* add random module skeleton * add Generator object * add placeholder for random.random method * add rudimentary random.random implementation * generator object accept seed(s) argument * add out keyword * add support for out keyword argument * update change log * add links to header files * fix file link * fix error messages * add uniform to random module * add normal distribution * fix argument options in normal and uniform * update documentation
492 lines
16 KiB
Text
492 lines
16 KiB
Text
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2020-05-01T09:27:13.438054Z",
|
|
"start_time": "2020-05-01T09:27:13.191491Z"
|
|
}
|
|
},
|
|
"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": "2022-01-07T18:24:48.499467Z",
|
|
"start_time": "2022-01-07T18:24:48.488004Z"
|
|
}
|
|
},
|
|
"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": "2020-07-23T20:31:25.296014Z",
|
|
"start_time": "2020-07-23T20:31:25.265937Z"
|
|
}
|
|
},
|
|
"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/build-2/micropython-2\", \"/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": [
|
|
"# numpy.random\n",
|
|
"\n",
|
|
"Random numbers drawn specific distributions can be generated by instantiating a `Generator` object, and calling its methods. The module defines the following three functions:\n",
|
|
"\n",
|
|
"1. [numpy.random.Generator.normal](#normal)\n",
|
|
"1. [numpy.random.Generator.random](#random)\n",
|
|
"1. [numpy.random.Generator.uniform](#uniform)\n",
|
|
"\n",
|
|
"\n",
|
|
"The `Generator` object, when instantiated, takes a single integer as its argument. This integer is the seed, which will be fed to the 32-bit or 64-bit routine. More details can be found under https://www.pcg-random.org/index.html. The generator is a standard `python` object that keeps track of its state.\n",
|
|
"\n",
|
|
"`numpy`: https://numpy.org/doc/stable/reference/random/index.html"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## normal\n",
|
|
"\n",
|
|
"A random set of number from the `normal` distribution can be generated by calling the generator's `normal` method. The method takes three optional arguments, `loc=0.0`, the centre of the distribution, `scale=1.0`, the width of the distribution, and `size=None`, a tuple containing the shape of the returned array. In case `size` is `None`, a single floating point number is returned.\n",
|
|
"\n",
|
|
"The `normal` method of the `Generator` object is based on the [Box-Muller transform](https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform).\n",
|
|
"\n",
|
|
"`numpy`: https://numpy.org/doc/stable/reference/random/generated/numpy.random.Generator.normal.html"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2019-10-19T13:08:17.647416Z",
|
|
"start_time": "2019-10-19T13:08:17.597456Z"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Gnerator() at 0x7fa9dae05340\n",
|
|
"-6.285246229407202\n",
|
|
"array([[24.95816273705659, 15.2670302229426, 14.81001577336041],\n",
|
|
" [20.17589833056986, 23.14539083787544, 26.37772041367461],\n",
|
|
" [41.94894234387275, 37.11027030608206, 25.65889562100477]], dtype=float64)\n",
|
|
"array([[21.52562779033434, 12.74685887865834, 24.08404670765186],\n",
|
|
" [4.728112596365396, 7.667757906857082, 21.61576094228444],\n",
|
|
" [2.432338873595267, 27.75945683572574, 5.730827584659245]], dtype=float64)\n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -unix 1\n",
|
|
"\n",
|
|
"from ulab import numpy as np\n",
|
|
"\n",
|
|
"rng = np.random.Generator(123456)\n",
|
|
"print(rng)\n",
|
|
"\n",
|
|
"# return single number from a distribution of scale 1, and location 0\n",
|
|
"print(rng.normal())\n",
|
|
"\n",
|
|
"print(rng.normal(loc=20.0, scale=10.0, size=(3,3)))\n",
|
|
"# same as above, with positional arguments\n",
|
|
"print(rng.normal(20.0, 10.0, (3,3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## random\n",
|
|
"\n",
|
|
"A random set of number from the uniform distribution in the interval [0, 1] can be generated by calling the generator's `random` method. The method takes two optional arguments, `size=None`, a tuple containing the shape of the returned array, and `out`. In case `size` is `None`, a single floating point number is returned. \n",
|
|
"\n",
|
|
"`out` can be used, if a floating point array is available. An exception will be raised, if the array is not of `float` `dtype`, or if both `size` and `out` are supplied, and there is a conflict in their shapes.\n",
|
|
"\n",
|
|
"If `size` is `None`, a single floating point number will be returned.\n",
|
|
"\n",
|
|
"\n",
|
|
"`numpy`: https://numpy.org/doc/stable/reference/random/generated/numpy.random.Generator.random.html"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 15,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Gnerator() at 0x7f299de05340\n",
|
|
"6.384615058863119e-11\n",
|
|
"\n",
|
|
" array([[0.4348157846574171, 0.7906325931024071, 0.878697619856133],\n",
|
|
" [0.8738606263361598, 0.4946080034142021, 0.7765890156101152],\n",
|
|
" [0.1770783715717074, 0.02080447648492112, 0.1053837559005948]], dtype=float64)\n",
|
|
"\n",
|
|
"buffer array before:\n",
|
|
" array([[0.0, 1.0, 2.0],\n",
|
|
" [3.0, 4.0, 5.0],\n",
|
|
" [6.0, 7.0, 8.0]], dtype=float64)\n",
|
|
"\n",
|
|
"buffer array after:\n",
|
|
" array([[0.8508024287393201, 0.9848489829156055, 0.7598167589604003],\n",
|
|
" [0.782995698302952, 0.2866337782847831, 0.7915884498022229],\n",
|
|
" [0.4614071706315902, 0.4792657443088592, 0.1581582066230718]], dtype=float64)\n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -unix 1\n",
|
|
"\n",
|
|
"from ulab import numpy as np\n",
|
|
"\n",
|
|
"rng = np.random.Generator(123456)\n",
|
|
"print(rng)\n",
|
|
"\n",
|
|
"# returning new objects\n",
|
|
"print(rng.random())\n",
|
|
"print('\\n', rng.random(size=(3,3)))\n",
|
|
"\n",
|
|
"# supplying a buffer\n",
|
|
"a = np.array(range(9), dtype=np.float).reshape((3,3))\n",
|
|
"print('\\nbuffer array before:\\n', a)\n",
|
|
"rng.random(out=a)\n",
|
|
"print('\\nbuffer array after:\\n', a)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## uniform\n",
|
|
"\n",
|
|
"`uniform` is similar to `random`, except that the interval over which the numbers are distributed can be specified, while the `out` argument cannot. In addition to `size` specifying the shape of the output, `low=0.0`, and `high=1.0` are accepted arguments. With the indicated defaults, `uniform` is identical to `random`, which can be seen from the fact that the first 3-by-3 tensor below is the same as the one produced by `rng.random(size=(3,3))` above.\n",
|
|
"\n",
|
|
"\n",
|
|
"If `size` is `None`, a single floating point number will be returned.\n",
|
|
"\n",
|
|
"\n",
|
|
"`numpy`: https://numpy.org/doc/stable/reference/random/generated/numpy.random.Generator.uniform.html"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 14,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Gnerator() at 0x7f1891205340\n",
|
|
"6.384615058863119e-11\n",
|
|
"\n",
|
|
" array([[0.4348157846574171, 0.7906325931024071, 0.878697619856133],\n",
|
|
" [0.8738606263361598, 0.4946080034142021, 0.7765890156101152],\n",
|
|
" [0.1770783715717074, 0.02080447648492112, 0.1053837559005948]], dtype=float64)\n",
|
|
"\n",
|
|
" array([[18.5080242873932, 19.84848982915605, 17.598167589604],\n",
|
|
" [17.82995698302952, 12.86633778284783, 17.91588449802223],\n",
|
|
" [14.6140717063159, 14.79265744308859, 11.58158206623072]], dtype=float64)\n",
|
|
"\n",
|
|
" array([[14.3380400319162, 12.72487657409978, 15.77119643621117],\n",
|
|
" [13.61835831436355, 18.96062889255558, 15.78847796795966],\n",
|
|
" [12.59435855187034, 17.68262037443622, 14.77943040598734]], dtype=float64)\n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"%%micropython -unix 1\n",
|
|
"\n",
|
|
"from ulab import numpy as np\n",
|
|
"\n",
|
|
"rng = np.random.Generator(123456)\n",
|
|
"print(rng)\n",
|
|
"\n",
|
|
"print(rng.uniform())\n",
|
|
"# returning numbers between 0, and 1\n",
|
|
"print('\\n', rng.uniform(size=(3,3)))\n",
|
|
"\n",
|
|
"# returning numbers between 10, and 20\n",
|
|
"print('\\n', rng.uniform(low=10, high=20, size=(3,3)))\n",
|
|
"\n",
|
|
"# same as above, without the keywords\n",
|
|
"print('\\n', rng.uniform(10, 20, (3,3)))"
|
|
]
|
|
}
|
|
],
|
|
"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.9.13"
|
|
},
|
|
"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
|
|
}
|