{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Intrepydd functions reference\n",
"\n",
"This notebook serves as a \"executable\" reference guide to the functions available in reference, as summarized [here in the Intrepydd Guide](https://hpcgarage.github.io/intrepyddguide/library/functions.html).\n",
"\n",
"**Run these first.** If you are executing this reference, please run the following two code cells first. You can then run any subsection, as there are no additional dependencies among them."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from os import makedirs\n",
"makedirs('ref', exist_ok=True)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from numpy import array, float32, int32"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Table of contents\n",
"\n",
"The following [Python builtins](https://docs.python.org/3/library/functions.html) have counterparts in Intrepydd.\n",
"\n",
"- [`abs`](#abs): Absolute value of an iterable collection\n",
"- [`all`](#all): Check whether all elements of an iterable collection are `True`\n",
"- [`any`](#any): Check whether any element of an iterable collection is `True`\n",
"- [`len`](#len): Returns the length of an iterable collection\n",
"- [`max`](#max): Returns the largest value in an iterable collection\n",
"- [`pow`](#pow): Raises a given value or every element of an iterable object to some power\n",
"- [`range`](#range): Generates an integer range (sequence).\n",
"- [`sum`](#sum): Returns the sum of the elements in an iterable object.\n",
"- [Type conversion](#type_conv):`int32`, `int64`, `float32`, `float64`: Constructors and converters for basic primitive types.\n",
"\n",
"Intrepydd also provides counterparts to a subset of the functions available in [Numpy/Scipy](https://www.numpy.org/).\n",
"\n",
"- [Basic arithmetic, unary operators](#unary) `elemwise_not`, `minus`: Elementwise arithmetic on a single input array.\n",
"- [Basic arithmetic, binary operators](#binary) `add`, `sub`, `mul`, `div`: Elementwise arithmetic between pairs of arrays.\n",
"- [Comparisons](#comparisons) `eq`, `ge`, `gt`, `le`, `lt`: Elementwise signed comparison (e.g., equality, less than, greater than).\n",
"- [Trignometric functions](#trig), `acos`, `asin`, `atan`, `cos`, `sin`, `sqrt`, `tan`: Elementwise trigonometric functions.\n",
"- [`allclose`](#allclose): Returns `True` if all elements of a given array are close to a given value.\n",
"- [`argmin`](#argmin): Returns the location of the minimum value in an array.\n",
"- [`argmax`](#argmax): Returns the location of the maximum value in an array.\n",
"- [`empty`](#empty): Returns an \"empty\" (uninitialized) multidimensional array.\n",
"- [`innerprod`](#innerprod): Returns the inner product (dot-product) between two arrays of the same size.\n",
"- [`isinf`, `isnan`](#isfpXXX): Tests for IEEE-754 floating-point infinity (`inf`) and not-a-number (`NaN`) values.\n",
"- [`prod`](#prod): Returns the product of all elements of a collection.\n",
"- [`transpose`](#transpose): Returns the transpose of a matrix.\n",
"- [`zeros`](#zeros): Returns an array of all zero elements."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python builtin-equivalents"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='abs'></a>\n",
"\n",
"## Function: `abs`\n",
"\n",
"Returns the absolute value of a given object or iterable; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#abs)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example.**"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/abs.pydd\n"
]
}
],
"source": [
"%%writefile ref/abs.pydd\n",
"\n",
"def demo_float32(x: float32) -> float32:\n",
" return abs(x)\n",
"\n",
"def demo_Array(x: Array(float64, 2)) -> Array(float64, 2):\n",
" return abs(x)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/abs.pydd"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.140000104904175\n",
"[[1. 2. 3.]\n",
" [4. 5. 6.]]\n"
]
}
],
"source": [
"import ref.abs\n",
"print(ref.abs.demo_float32(-3.14))\n",
"\n",
"A = array([[-1., 2., -3.],\n",
" [4., -5., 6.]])\n",
"print(ref.abs.demo_Array(A))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='all'></a>\n",
"\n",
"## Function: `all`\n",
"\n",
"Returns `True` if all elements of a given iterable object are `True`; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#all)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example.**"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/all.pydd\n"
]
}
],
"source": [
"%%writefile ref/all.pydd\n",
"\n",
"def demo_bool(A: Array(bool, 2)) -> bool:\n",
" return all(A)\n",
"\n",
"def demo_int(A: Array(int64)) -> bool:\n",
" return all(A)\n",
"\n",
"def demo_double(A: Array(float64, 2)) -> bool:\n",
" return all(A)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/all.pydd"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"False\n",
"[0 1 2 3 4 5 6 7 8 9]\n",
"False\n",
"True\n",
"[[ 1. -2. 3.]\n",
" [-4. 5. 6.]]\n",
"True\n",
"[[ 1. -2. 3.]\n",
" [-4. 5. 0.]]\n",
"False\n"
]
}
],
"source": [
"import ref.all\n",
"\n",
"A = array(2 * [3 * [True]])\n",
"print(ref.all.demo_bool(A))\n",
"\n",
"A[0, 1] = False\n",
"print(ref.all.demo_bool(A))\n",
"\n",
"L = array(range(10)) # Doesn't work with `list(range(10))`\n",
"print(L)\n",
"print(ref.all.demo_int(L)) # False\n",
"\n",
"L[0] = -1\n",
"print(ref.all.demo_int(L)) # True\n",
"\n",
"A = array([[1., -2., 3.],\n",
" [-4., 5., 6.]])\n",
"print(A)\n",
"print(ref.all.demo_double(A))\n",
"\n",
"A[-1, -1] = 0.0\n",
"print(A)\n",
"print(ref.all.demo_double(A))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='any'></a>\n",
"\n",
"## Function: `any`\n",
"\n",
"Returns `True` if any element of a given iterable object is `True`; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#any)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example.**"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/any.pydd\n"
]
}
],
"source": [
"%%writefile ref/any.pydd\n",
"\n",
"def demo_bool(A: Array(bool, 2)) -> bool:\n",
" return any(A)\n",
"\n",
"def demo_int(A: Array(int64)) -> bool:\n",
" return any(A)\n",
"\n",
"def demo_double(A: Array(float64, 2)) -> bool:\n",
" return any(A)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/any.pydd"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n",
"[0 0 0 0 0]\n",
"False\n",
"True\n"
]
}
],
"source": [
"import ref.any\n",
"\n",
"A = array(2 * [3 * [False]])\n",
"print(ref.any.demo_bool(A))\n",
"\n",
"A[0, 1] = True\n",
"print(ref.any.demo_bool(A))\n",
"\n",
"L = array([0] * 5) # Doesn't work with `list(range(10))`\n",
"print(L)\n",
"print(ref.any.demo_int(L)) # False\n",
"\n",
"L[0] = -1\n",
"print(ref.any.demo_int(L)) # True"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='len'></a>\n",
"\n",
"## Function: `len`\n",
"\n",
"Returns the length of the object; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#len)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example.**"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/len.pydd\n"
]
}
],
"source": [
"%%writefile ref/len.pydd\n",
"\n",
"def demo_list(L: List(int)) -> int64:\n",
" return len(L)\n",
"\n",
"def demo_dict(D: Dict(int64, float64)) -> int64:\n",
" return len(D)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/len.pydd"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"4\n"
]
}
],
"source": [
"import ref.len\n",
"print(ref.len.demo_list([-1, -2, -3]))\n",
"print(ref.len.demo_dict({1: 3.14, 2: 2.718, 3: 6.9824, 4: -1.2}))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='max'></a>\n",
"\n",
"## Function: `max`\n",
"\n",
"Returns the maximum value of an iterable; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#max)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example.**"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/max.pydd\n"
]
}
],
"source": [
"%%writefile ref/max.pydd\n",
"\n",
"def demo_int(A: Array(int64, 1)) -> int64:\n",
" return max(A)\n",
"\n",
"def demo_float32_2d(A: Array(float32, 2)) -> float32:\n",
" return max(A)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/max.pydd"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"100\n",
"100.0\n"
]
}
],
"source": [
"import ref.max\n",
"print(ref.max.demo_int(array([3, 2, 100, 7])))\n",
"print(ref.max.demo_float32_2d(array([[3, 2, 100, 33], [-500, 1, 0, -40]], dtype=float32)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='min'></a>\n",
"\n",
"## Function: `min`\n",
"\n",
"Returns the maximum value of an iterable object; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#max)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example.**"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/min.pydd\n"
]
}
],
"source": [
"%%writefile ref/min.pydd\n",
"\n",
"def demo_int(A: Array(int64, 1)) -> int64:\n",
" return min(A)\n",
"\n",
"def demo_float32_2d(A: Array(float32, 2)) -> float32:\n",
" return min(A)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/min.pydd"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"-500.0\n"
]
}
],
"source": [
"import ref.min\n",
"print(ref.min.demo_int(array([3, 2, 100, 7])))\n",
"print(ref.min.demo_float32_2d(array([[3, 2, 100, 33], [-500, 1, 0, -40]], dtype=float32)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='pow'></a>\n",
"\n",
"## Function: `pow`\n",
"\n",
"Raises a given value or every element of an iterable object to some power; equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#pow)."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/pow.pydd\n"
]
}
],
"source": [
"%%writefile ref/pow.pydd\n",
"\n",
"def demo_float32(x: float32, p: float32) -> float32:\n",
" return pow(x, p)\n",
"\n",
"def demo_float32_1d(A: Array(float32, 1), p: float32) -> Array(float32, 1):\n",
" return pow(A, p)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/pow.pydd"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"9.859601020812988\n",
"[ 30.959146 -30.959146]\n"
]
}
],
"source": [
"import ref.pow\n",
"\n",
"print(ref.pow.demo_float32(3.14, 2.0))\n",
"print(ref.pow.demo_float32_1d(array([3.14, -3.14], dtype=float32), 3.0))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='print'></a>\n",
"\n",
"## Function: `print`\n",
"\n",
"Prints a value to standard output.\n",
"\n",
"This function is equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#print). However, in the current version of Intrepydd, it is limited to accepting just one argument, i.e., `print(x)`, where `x` must be a primitive type."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/print.pydd\n"
]
}
],
"source": [
"%%writefile ref/print.pydd\n",
"\n",
"def demo_float32(x: float32):\n",
" print(x)\n",
"\n",
"def demo_float32_1d(A: Array(float32, 1)):\n",
" for i in range(shape(A, 0)):\n",
" print(A[i])"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/print.pydd"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.140000104904175\n",
"1.0\n",
"2.0\n",
"3.0\n"
]
}
],
"source": [
"import ref.print\n",
"ref.print.demo_float32(3.14)\n",
"ref.print.demo_float32_1d(array([1, 2, 3], dtype=float32))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='range'></a>\n",
"\n",
"## Function: `range`\n",
"\n",
"Generates an integer range (sequence); equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#func-range)."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/range.pydd\n"
]
}
],
"source": [
"%%writefile ref/range.pydd\n",
"\n",
"def demo_std(n: int64) -> int64:\n",
" s = 0\n",
" for i in range(n):\n",
" s += i\n",
" print(i)\n",
" return s\n",
" \n",
"def demo_start_end(a: int64, b: int64) -> int64:\n",
" s = 0\n",
" for i in range(a, b):\n",
" print(i)\n",
" s += i\n",
" return s\n",
"\n",
"def demo_start_end_step(a: int64, b: int64, c: int64) -> int64:\n",
" s = 0\n",
" for i in range(a, b, c):\n",
" print(i)\n",
" s += i\n",
" return s"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/range.pydd"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"-3\n",
"-2\n",
"-1\n",
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"-3\n",
"-1\n",
"1\n",
"3\n",
"5\n"
]
},
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.range\n",
"ref.range.demo_std(5)\n",
"ref.range.demo_start_end(-3, 7)\n",
"ref.range.demo_start_end_step(-3, 7, 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='sum'></a>\n",
"\n",
"## Function: `sum`\n",
"\n",
"Returns the sum of the elements in an iterable object.\n",
"\n",
"This function is equivalent to its [Python builtin](https://docs.python.org/3/library/functions.html#sum), except it does **not** support the optional start argument, i.e., it does not support the calling signature, `sum(x, start)`, where in standard Python `start` is the position of the first index at which to begin the sum."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/sum.pydd\n"
]
}
],
"source": [
"%%writefile ref/sum.pydd\n",
"\n",
"def demo(x: Array(int64, 2)) -> int64:\n",
" return sum(x)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/sum.pydd"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"55"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.sum\n",
"ref.sum.demo(array([[1, 2, 3, 4, 5],\n",
" [6, 7, 8, 9, 10]]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='type_conv'></a>\n",
"\n",
"## Type conversion\n",
"\n",
"Construct or convert scalar variables among primitive types: `int32`, `int64`, `float32`, `float64`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example:** `float32`."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/types.pydd\n"
]
}
],
"source": [
"%%writefile ref/types.pydd\n",
"\n",
"def do_float32() -> float32:\n",
" return float32()\n",
"\n",
"def do_float32_2(val: int32) -> float32:\n",
" return float32(val)"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/types.pydd"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0\n",
"124.0\n",
"1.0\n"
]
}
],
"source": [
"import ref.types\n",
"\n",
"print(ref.types.do_float32()) # 0, as a float\n",
"print(ref.types.do_float32_2(124))\n",
"print(ref.types.do_float32_2(True))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Numpy equivalents"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='unary'></a>\n",
"\n",
"## Basic arithmetic: unary operators, `elemwise_not`, `minus`\n",
"\n",
"Applies basic arithmetic options elementwise to an input. These are equivalent to their Numpy counterparts; e.g., see [Numpy's `logical_not`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.logical_not.html)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example:** `minus`."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/minus.pydd\n"
]
}
],
"source": [
"%%writefile ref/minus.pydd\n",
"\n",
"def demo_float32(x: Array(float32, 2)) -> Array(float32, 2):\n",
" return minus(x)\n",
"\n",
"def demo_int64(x: Array(int64, 2)) -> Array(int64, 2):\n",
" return minus(x)"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/minus.pydd"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[-1., -2., -3.],\n",
" [-4., -5., -6.]], dtype=float32)"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.minus\n",
"x = array([[1, 2, 3], [4, 5, 6]], dtype=float32)\n",
"ref.minus.demo_float32(x)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[-1, 2, -3],\n",
" [ 4, -5, 6]])"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = array([[1, -2, 3], [-4, 5, -6]], dtype=int)\n",
"ref.minus.demo_int64(y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='binary'></a>\n",
"\n",
"## Basic arithmetic: binary operators, `add`, `sub`, `mul`, `div`\n",
"\n",
"Applies basic arithmetic options elementwise to a pair of inputs. These are equivalent to their Numpy counterparts; e.g., see [Numpy's `add`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.add.html?highlight=add#numpy.add)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example:** `add`."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/add.pydd\n"
]
}
],
"source": [
"%%writefile ref/add.pydd\n",
"\n",
"def demo_float32(x: Array(float32, 2), y: Array(float32, 2)) -> Array(float32, 2):\n",
" return add(x, y)\n",
"\n",
"def demo_int64(x: Array(int64, 2), y: Array(int64, 2)) -> Array(int64, 2):\n",
" return add(x, y)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/add.pydd"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 2., 0., 6.],\n",
" [ 0., 10., 0.]], dtype=float32)"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.add\n",
"x = array([[1, 2, 3], [4, 5, 6]], dtype=float32)\n",
"y = array([[1, -2, 3], [-4, 5, -6]], dtype=float32)\n",
"ref.add.demo_float32(x, y)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 2, 0, 6],\n",
" [ 0, 10, 0]], dtype=int64)"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = array([[1, 2, 3], [4, 5, 6]], dtype=int)\n",
"y = array([[1, -2, 3], [-4, 5, -6]], dtype=int)\n",
"ref.add.demo_int64(x, y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='comparisons'></a>\n",
"\n",
"## Comparisons: binary logical operators, `eq`, `ge`, `gt`, `le`, `lt`\n",
"\n",
"Given a pair of inputs, performs elementwise binary comparisons: equality (`eq`), greater than (`gt`), greater than or equal to (`ge`), less than (`lt`), and less than or equal to (`le`). These are equivalent to their Numpy counterparts; e.g., see [Numpy's `eq`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.eq.html?highlight=eq#numpy.eq) for an example of equality comparison.\n",
"\n",
"> When the inputs are floating-point, it is usually better to apply `allclose` rather than `eq` to test for approximate equality due to round-off errors with floating-point arithmetic."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example:** greater than (`gt`)."
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/gt.pydd\n"
]
}
],
"source": [
"%%writefile ref/gt.pydd\n",
"\n",
"def demo_float32(x: Array(float32, 2), y: Array(float32, 2)) -> Array(bool, 2):\n",
" return gt(x, y)\n",
"\n",
"def demo_int64(x: Array(int64, 2), y: Array(int64, 2)) -> Array(bool, 2):\n",
" return gt(x, y)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/gt.pydd"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[False, True, False],\n",
" [ True, False, True]])"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.gt\n",
"eps = 1e-6 # greater than float32 machine epsilon\n",
"x = array([[1, 2, 3], [4, 5, 6]], dtype=float32)\n",
"y = x + eps*array([[1, -1, 1], [-1, 0, -1]], dtype=float32)\n",
"ref.gt.demo_float32(x, y)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[False, True, False],\n",
" [ True, False, True]])"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = array([[1, 2, 3], [4, 5, 6]], dtype=int)\n",
"y = x + array([[1, -1, 1], [-1, 0, -1]], dtype=int)\n",
"ref.gt.demo_int64(x, y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='elemfun'></a>\n",
"\n",
"## Elementary functions: `acos`, `asin`, `atan`, `cos`, `exp`, `log`, `sin`, `sqrt`, `tan`\n",
"\n",
"Applies trigonometric function elementwise and returns the result. These are equivalent to their Numpy equivalents, e.g., see [Numpy's `arccos`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arccos.html).\n",
"\n",
"**Example:** `acos`."
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/acos.pydd\n"
]
}
],
"source": [
"%%writefile ref/acos.pydd\n",
"\n",
"def demo(x: Array(float32, 2)) -> Array(float32, 2):\n",
" return acos(x)"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/acos.pydd"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0.99999994 0.6666667 0.5 ]\n",
" [0.5 0.33333328 0. ]] * pi\n"
]
}
],
"source": [
"import math\n",
"import ref.acos\n",
"theta_over_pi = ref.acos.demo(array([[-1, -0.5, 0],\n",
" [0, 0.5, 1]], dtype=float32))/math.pi\n",
"print('{} * pi'.format(theta_over_pi))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='allclose'></a>\n",
"\n",
"## Function: `allclose`\n",
"\n",
"Returns `True` if all elements of a given array are close to a given value.\n",
"\n",
"This function implements `allclose(x, atol)`, where `x` is an input array and `atol` is an absolute threshold. Therefore, Intrepydd's `allclose` is similar to, but **not** equivalent to, its [Numpy counterpart](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Numpy's `allclose`.** In particular, Numpy's `allclose` evaluates the logical operation $\\bigwedge_i \\left( |a_i - b_i| \\leq \\alpha + \\rho |b_i| \\right)$, where $\\bigwedge$ denotes logical-and, $a_i$ and $b_i$ are the elements of two arrays, and $\\alpha$ and $\\rho$ are absolute and relative threshold parameters, respectively. (The values of $\\alpha$ and $\\rho$ are the `atol` and `rtol` arguments to `allclose()`.) For instance, suppose we have two Numpy arrays, `a` and `b`, and suppose the absolute difference between any pair of corresponding elements is $10^{-10}$.\n",
"\n",
"```python\n",
"# Numpy allclose\n",
"from numpy import allclose, array\n",
"tiny_diff = 1e-10\n",
"a = array([1., 2., 3.])\n",
"b = a + array([tiny_diff, -tiny_diff, tiny_diff])\n",
"```\n",
"\n",
"Consider two calls to `allclose`: one that checks whether the absolute difference is less than $10^{-11}$, which will be false, and the other that checks against $10^{-9}$, which will be true.\n",
"\n",
"```python\n",
"print(allclose(a, b, atol=1e-11, rtol=0)) # False!\n",
"print(allclose(a, b, atol=1e-9, rtol=0)) # True!\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Intrepydd's `allclose`.** By contrast, Intrepydd's interface, `allclose(x, atol)`, is \"lighter.\" It accepts just a single array (`x`) and an absolute tolerance (`atol`). There is no direct relative tolerance support (but see below!). The previous two checks would be rewritten as follows:\n",
"\n",
"```python\n",
" # Intrepydd:\n",
" allclose(abs(a-b), 1e-11) # False!\n",
" allclose(abs(a-b), 1e-9) # True!\n",
"```\n",
"\n",
"To implement something like Numpy's `allclose()`, which accepts both `atol` and `rtol` parameters, see the `demo` function in the code cells below."
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[-1.00000008e-10 1.00000008e-10 -1.00000008e-10]\n",
"False\n",
"True\n"
]
}
],
"source": [
"from numpy import allclose, array\n",
"a = array([1., 2., 3.])\n",
"b = a + array([1e-10, -1e-10, 1e-10])\n",
"print(a-b)\n",
"print(allclose(a, b, atol=1e-11, rtol=0)) # False!\n",
"print(allclose(a, b, atol=1e-9, rtol=0)) # True!"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/allclose.pydd\n"
]
}
],
"source": [
"%%writefile ref/allclose.pydd\n",
"\n",
"def scale_array(x: Array(float64, 2), s: float64) -> Array(float64, 2):\n",
" y = empty([shape(x, 0), shape(x, 1)])\n",
" for i in range(shape(y, 0)):\n",
" for j in range(shape(y, 1)):\n",
" y[i, j] = x[i, j] * s\n",
" return y\n",
"\n",
"def demo(a: Array(float64, 2), b: Array(float64, 2), atol: float64, rtol: float64) -> bool:\n",
" diff = abs(sub(a, b))\n",
" relterm = abs(scale_array(b, rtol))\n",
" x = sub(diff, relterm)\n",
" return allclose(x, atol)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/allclose.pydd"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n"
]
}
],
"source": [
"import ref.allclose\n",
"\n",
"a = array([[1., 2., 3.],\n",
" [4., 5., 6.]])\n",
"b = a + 1e-10\n",
"print(ref.allclose.demo(a, b, 1e-11, 0.)) # False?\n",
"print(ref.allclose.demo(a, b, 1e-9, 0.)) # True?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='argmin'></a>\n",
"\n",
"## Function: `argmin`\n",
"\n",
"Returns the location of the minimum value of an array; equivalent to its [Numpy counterpart](https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmin.html?highlight=add#numpy.argmin).\n",
"\n",
"The return value is a list, since the input array may be multidimensional. A best-practice in the current version of Intrepydd is to recast this return as an array before returning, as the following example shows.\n",
"\n",
"> If there are duplicates, one of them will be returned. The precise one is not specified."
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/argmin.pydd\n"
]
}
],
"source": [
"%%writefile ref/argmin.pydd\n",
"\n",
"def demo(A: Array(float64, 3)) -> Array(int32) :\n",
" r = argmin(A)\n",
" r_np = empty((3,), int32())\n",
" r_np[0] = r[0]\n",
" r_np[1] = r[1]\n",
" r_np[2] = r[2]\n",
" return r_np"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/argmin.pydd"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 1 2] : <class 'numpy.ndarray'>\n",
"Min value is -6.0, which resides at location x[1 1 2]\n"
]
}
],
"source": [
"import ref.argmin\n",
"plane = array([[1., 2., 3.],\n",
" [4., 5., 6.]])\n",
"x = array([plane, -plane, plane])\n",
"loc = ref.argmin.demo(x)\n",
"print(loc, ':', type(loc))\n",
"print(\"Min value is {}, which resides at location x{}\".format(x[loc[0], loc[1], loc[2]], loc))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='argmax'></a>\n",
"\n",
"## Function: `argmax`\n",
"\n",
"Returns the location of the maximum value of an array; equivalent to its [Numpy counterpart](https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmax.html?highlight=add#numpy.argmax).\n",
"\n",
"The return value is a list, since the input array may be multidimensional. A best-practice in the current version of Intrepydd is to recast this return as an array before returning, as the following example shows.\n",
"\n",
"> If there are duplicates, one of them will be returned. The precise one is not specified."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/argmax.pydd\n"
]
}
],
"source": [
"%%writefile ref/argmax.pydd\n",
"\n",
"def demo(A: Array(float64, 3)) -> Array(int32) :\n",
" r = argmax(A)\n",
" r_np = empty((3,), int32())\n",
" r_np[0] = r[0]\n",
" r_np[1] = r[1]\n",
" r_np[2] = r[2]\n",
" return r_np"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/argmax.pydd"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 1 2] : <class 'numpy.ndarray'>\n",
"Max value is 6.0, which resides at location x[1 1 2]\n"
]
}
],
"source": [
"import ref.argmax\n",
"plane = array([[1., 2., 3.],\n",
" [4., 5., 6.]])\n",
"x = array([-plane, plane, -plane])\n",
"loc = ref.argmax.demo(x)\n",
"print(loc, ':', type(loc))\n",
"print(\"Max value is {}, which resides at location x{}\".format(x[loc[0], loc[1], loc[2]], loc))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='empty'></a>\n",
"\n",
"## Function: `empty`\n",
"\n",
"Returns an \"empty\" (uninitialized) multidimensional array; equivalent to its [Numpy counterpart](https://docs.scipy.org/doc/numpy/reference/generated/numpy.empty.html?highlight=add#numpy.empty).\n",
"\n",
"> Intrepydd does not currently implement the `order` parameter, which would be used to specify row- vs. column-major layouts. Intrepydd's default is row-major."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/empty.pydd\n"
]
}
],
"source": [
"%%writefile ref/empty.pydd\n",
"\n",
"def demo_int32(shape: List(int32)) -> Array(int32):\n",
" return empty(shape, int32())\n",
"\n",
"def demo_float64(shape: List(int32)) -> Array(float64):\n",
" return empty(shape, float64())"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/empty.pydd"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'numpy.ndarray'> int32\n",
"[[[ 0 -1074790400]\n",
" [ 0 -1073741824]\n",
" [ 0 -1073217536]]\n",
"\n",
" [[ 0 -1072693248]\n",
" [ 0 -1072431104]\n",
" [ 0 -1072168960]]]\n",
"<class 'numpy.ndarray'> float64\n",
"[[[-8.39911598e-323 -0.00000000e+000]\n",
" [ 1.49458072e-154 -0.00000000e+000]\n",
" [ 7.41098469e-323 0.00000000e+000]]\n",
"\n",
" [[ 0.00000000e+000 0.00000000e+000]\n",
" [ 0.00000000e+000 0.00000000e+000]\n",
" [ 0.00000000e+000 0.00000000e+000]]]\n"
]
}
],
"source": [
"import ref.empty\n",
"A = ref.empty.demo_int32([2, 3, 2])\n",
"print(type(A), A.dtype)\n",
"print(A)\n",
"\n",
"B = ref.empty.demo_float64([2, 3, 2])\n",
"print(type(B), B.dtype)\n",
"print(B)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='innerprod'></a>\n",
"\n",
"## Function: `innerprod`\n",
"\n",
"Returns the inner product (dot-product) between two arrays of the same size. Its closest counterpart in Numpy is [`numpy.ma.innerproduct`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ma.innerproduct.html)."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/innerprod.pydd\n"
]
}
],
"source": [
"%%writefile ref/innerprod.pydd\n",
"\n",
"def func(A: Array(int32, 1), B: Array(float64, 1)) -> float64:\n",
" return innerprod(A, B)"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/innerprod.pydd"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"14.0"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.innerprod\n",
"\n",
"x = array([1, 2, 3], dtype=int32)\n",
"y = array([1., 2., 3.])\n",
"\n",
"ref.innerprod.func(x, y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='isfpXXX'></a>\n",
"\n",
"## Functions: `isinf`, `isnan`\n",
"\n",
"Tests whether values of an array are IEEE floating-point infinity (`inf`) or not-a-number (`NaN`) values; equivalent to the Numpy functions [`numpy.isinf`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.isinf.html) and [`numpy.isnan`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.isnan.html)."
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/isfpXXX.pydd\n"
]
}
],
"source": [
"%%writefile ref/isfpXXX.pydd\n",
"\n",
"def demo_isinf(x: Array(float64, 2)) -> Array(bool, 2):\n",
" return isinf(x)\n",
"\n",
"def demo_isnan(x: Array(float32, 2)) -> Array(bool, 2):\n",
" return isnan(x)"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/isfpXXX.pydd"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[False True False]\n",
" [False False True]]\n",
"[[False False False]\n",
" [ True False False]]\n"
]
}
],
"source": [
"import ref.isfpXXX\n",
"\n",
"z = array([[1.0, float('inf'), 0.0],\n",
" [float('nan'), -2.0, float('inf')]])\n",
"\n",
"print(ref.isfpXXX.demo_isinf(z))\n",
"print(ref.isfpXXX.demo_isnan(z.astype(float32)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='prod'></a>\n",
"\n",
"## Function: `prod`\n",
"\n",
"Returns the product of all elements of a collection; equivalent to its [`Numpy counterpart`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.prod.html)."
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/prod.pydd\n"
]
}
],
"source": [
"%%writefile ref/prod.pydd\n",
"\n",
"def demo(arr: Array(int64)) -> int64:\n",
" return prod(arr)"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/prod.pydd"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-30"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.prod\n",
"ref.prod.demo(array([1, -2, 3, 5], dtype=int))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='transpose'></a>\n",
"\n",
"## Function: `transpose`\n",
"\n",
"Returns the transpose of a matrix.\n",
"\n",
"This function is roughly equivalent to its [`Numpy counterpart`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html), except that it works only for matrix (2-D) inputs."
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/transpose.pydd\n"
]
}
],
"source": [
"%%writefile ref/transpose.pydd\n",
"\n",
"def demo(arr: Array(int32, 2)) -> Array(int32, 2):\n",
" return transpose(arr)"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/transpose.pydd"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1, 4],\n",
" [2, 5],\n",
" [3, 6]], dtype=int32)"
]
},
"execution_count": 75,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import ref.transpose\n",
"ref.transpose.demo(array([[1, 2, 3], [4, 5, 6]], dtype=int32))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='zeros'></a>\n",
"\n",
"## Function: `zeros`\n",
"\n",
"Returns an array of all zeros; equivalent to its [`Numpy counterpart`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html)."
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ref/zeros.pydd\n"
]
}
],
"source": [
"%%writefile ref/zeros.pydd\n",
"\n",
"def zeros_1d(n: int) -> Array(float64, 1):\n",
" return zeros(n, float64())\n",
"\n",
"def ones_2d(m:int, n: int) -> Array(float64, 2):\n",
" C = zeros([m, n], float64())\n",
" return cos(C)"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [],
"source": [
"!pyddc ref/zeros.pydd"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 0. 0. 0.]\n",
"[[1. 1. 1.]\n",
" [1. 1. 1.]]\n"
]
}
],
"source": [
"import ref.zeros\n",
"print(ref.zeros.zeros_1d(4))\n",
"print(ref.zeros.ones_2d(2, 3))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"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.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}