{ "cells": [ { "cell_type": "markdown", "id": "a0f6d1a0", "metadata": {}, "source": [ "---\n", "#### MYST_NB_TEST_BED2\n", "..." ] }, { "cell_type": "code", "execution_count": 4, "id": "c6640ad9", "metadata": {}, "outputs": [ { "ename": "ModuleNotFoundError", "evalue": "No module named 'myst_nb'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m----> 5\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmyst_nb\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mmnb\u001b[39;00m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpandas\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[0;32m 8\u001b[0m x \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m200\u001b[39m)\n", "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'myst_nb'" ] } ], "source": [ "#### import myst_nb as mnb\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import myst_nb as mnb\n", "import pandas as pd\n", "\n", "x = np.linspace(0, 10, 200)\n", "y = np.sin(x)\n", "fig, ax = plt.subplots()\n", "ax.plot(x, y, 'b-', linewidth=2)\n", "\n", "fig.set_size_inches(0.6, 0.2)\n", "fig.set_facecolor('white')\n", "fig.set_edgecolor('white')\n", "\n", "ax.set_xticks([])\n", "ax.set_yticks([])\n", "ax.set_axis_off()\n", "\n", "# mnb.glue(\"glued_fig\", fig, display=False)\n", "\n", "# temp = ''\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "445a3906", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 24, "id": "10f51b11", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Data for plotting\n", "t = np.arange(0.0, 2.0, 0.01)\n", "s = 1 + np.sin(2 * np.pi * t)\n", "\n", "fig, ax = plt.subplots()\n", "ax.plot(t, s)\n", "\n", "ax.set(xlabel='time (s)', ylabel='voltage (mV)',\n", " title='About as simple as it gets, folks')\n", "ax.grid()\n", "\n", "fig.savefig(\"test.png\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 25, "id": "59a2661b", "metadata": {}, "outputs": [], "source": [ "import itertools\n", "from collections import Counter\n", "from random import random\n", "from decimal import *\n", "from numbers import Number" ] }, { "cell_type": "code", "execution_count": 26, "id": "d64be56b", "metadata": {}, "outputs": [], "source": [ "def KLHfloatround(myfloat, my10power):\n", " return float(\n", " Decimal(round(myfloat, my10power)).quantize(Decimal(str(10**-my10power)))\n", " )" ] }, { "cell_type": "code", "execution_count": 27, "id": "4c9b1c1f", "metadata": {}, "outputs": [], "source": [ "def interval_compare_X(bracket_number1, bracket_number2, interval_type):\n", " \"\"\"Given an Excel cell, filter the numeric value, retaining only if within the interval\n", "\n", " Args:\n", " bracket_number1: one extreme value in the interval (*)\n", " bracket_number2: the other extreme value in the interval (*)\n", " interval_type: type of interval closure (closed/open and combinations)\n", " number_entry: a single Excel cell to be filtered\n", " sortQ: a boolean, True indicates an ascending sort\n", " reverseQ: a boolean, True indicates sorted descending\n", " unique_onlyQ: a boolean, indicates removal of duplicates\n", " (*) or in [\"minf\", \"pinf\", \"-inf\", \"inf\"]\n", "\n", " Returns:\n", " List of values meeting the comparison specification, if any. Otherwise, the string 'empty'\n", " \n", " Raises:\n", " ValueError(\"Expected 2 numeric values and string interval_type\")\n", "\n", " \"\"\"\n", " b1, b2 = min(bracket_number1, bracket_number2), max(bracket_number1, bracket_number2)\n", "\n", " b1_ok, b2_ok = False, False\n", " \n", " if isinstance(b1, str):\n", " b1 = bracket_inf(b1)\n", " if not b1:\n", " input_check = False\n", " # print(\"ValueError('bracket1 must be numeric\")\n", " raise ValueError('bracket1 must be numeric or in [\"minf\", \"pinf\", \"-inf\", \"inf\"]')\n", " else:\n", " b1_ok =True\n", "\n", " if isinstance(b2, str):\n", " b2 = bracket_inf(b2)\n", " if not b2:\n", " # print(\"ValueError('bracket2 must be numeric\")\n", " raise ValueError('bracket2 must be numeric or in [\"minf\", \"pinf\", \"-inf\", \"inf\"]')\n", " else:\n", " b2_ok =True\n", " \n", " if not ((isinstance(b1, Number) or b1_ok) \n", " and (isinstance(b2, Number) or b2_ok) \n", " and isinstance(interval_type, str)):\n", " # print(\"ValueError('Expected ...\")\n", " raise ValueError(\"Expected 2 numeric values (*) and string interval_type\")\n", "\n", " ivupper = interval_type.upper()\n", "\n", " if not(ivupper in ['[]','[)','(]','()','CC','CO','OC','OO']):\n", " raise ValueError(\"Interval_type must be \\n['[]','[)','(]','()','CC','CO','OC','OO']\")\n", " \n", " if ivupper in ['[]','CC']:\n", " def CC(x):\n", " if (b1 < x < b2):\n", " return x\n", " else:\n", " return None\n", " return CC\n", " elif ivupper in ['[)','CO']:\n", " def CO(x):\n", " if (b1 < x <= b2):\n", " return x\n", " else:\n", " return None\n", " return CO\n", " elif ivupper in ['(]','OC']:\n", " def OC(x):\n", " if (b1 <= x < b2):\n", " return x\n", " else:\n", " return None\n", " return OC\n", " elif ivupper in ['()','OO']:\n", " def OO(x):\n", " if (b1 <= x <= b2):\n", " return x\n", " else:\n", " return None\n", " return OO" ] }, { "cell_type": "code", "execution_count": 28, "id": "baafe071", "metadata": {}, "outputs": [], "source": [ "def interval_compare_X(bracket_number1, bracket_number2, interval_type):\n", " \"\"\"Given an Excel cell, filter the numeric value, retaining only if within the interval\n", "\n", " Args:\n", " bracket_number1: one extreme value in the interval (*)\n", " bracket_number2: the other extreme value in the interval (*)\n", " interval_type: type of interval closure (closed/open and combinations)\n", " number_entry: a single Excel cell to be filtered\n", " sortQ: a boolean, True indicates an ascending sort\n", " reverseQ: a boolean, True indicates sorted descending\n", " unique_onlyQ: a boolean, indicates removal of duplicates\n", " (*) or in [\"minf\", \"pinf\", \"-inf\", \"inf\"]\n", "\n", " Returns:\n", " List of values meeting the comparison specification, if any. Otherwise, the string 'empty'\n", " \n", " Raises:\n", " ValueError(\"Expected 2 numeric values and string interval_type\")\n", "\n", " \"\"\"\n", " b1, b2 = min(bracket_number1, bracket_number2), max(bracket_number1, bracket_number2)\n", "\n", " b1_ok, b2_ok = False, False\n", " \n", " if isinstance(b1, str):\n", " b1 = bracket_inf(b1)\n", " if not b1:\n", " input_check = False\n", " # print(\"ValueError('bracket1 must be numeric\")\n", " raise ValueError('bracket1 must be numeric or in [\"minf\", \"pinf\", \"-inf\", \"inf\"]')\n", " else:\n", " b1_ok =True\n", "\n", " if isinstance(b2, str):\n", " b2 = bracket_inf(b2)\n", " if not b2:\n", " # print(\"ValueError('bracket2 must be numeric\")\n", " raise ValueError('bracket2 must be numeric or in [\"minf\", \"pinf\", \"-inf\", \"inf\"]')\n", " else:\n", " b2_ok =True\n", " \n", " if not ((isinstance(b1, Number) or b1_ok) \n", " and (isinstance(b2, Number) or b2_ok) \n", " and isinstance(interval_type, str)):\n", " # print(\"ValueError('Expected ...\")\n", " raise ValueError(\"Expected 2 numeric values (*) and string interval_type\")\n", "\n", " ivupper = interval_type.upper()\n", "\n", " if not(ivupper in ['[]','[)','(]','()','CC','CO','OC','OO']):\n", " raise ValueError(\"Interval_type must be \\n['[]','[)','(]','()','CC','CO','OC','OO']\")\n", " \n", " if ivupper in ['[]','CC']:\n", " def CC(x):\n", " if (b1 < x < b2):\n", " return x\n", " else:\n", " return None\n", " return CC\n", " elif ivupper in ['[)','CO']:\n", " def CO(x):\n", " if (b1 < x <= b2):\n", " return x\n", " else:\n", " return None\n", " return CO\n", " elif ivupper in ['(]','OC']:\n", " def OC(x):\n", " if (b1 <= x < b2):\n", " return x\n", " else:\n", " return None\n", " return OC\n", " elif ivupper in ['()','OO']:\n", " def OO(x):\n", " if (b1 <= x <= b2):\n", " return x\n", " else:\n", " return None\n", " return OO\n", " " ] }, { "cell_type": "code", "execution_count": 29, "id": "84f08fa2", "metadata": {}, "outputs": [], "source": [ "def filter_int_comp_list_X(bracket_number1, bracket_number2, interval_type, number_entry_list, sortQ=False, reverseQ=False, unique_onlyQ=False):\n", " \"\"\"Given an Excel range, filter the numeric values, retaining only those that are within the interval\n", "\n", " Args:\n", " bracket_number1: one extreme value in the interval\n", " bracket_number2: the other extreme value in the interval\n", " interval_type: type of interval closure (closed/open and combinations)\n", " number_entry_list: a LIST of values to be filtered\n", " sortQ: a boolean, True indicates sorted ascending\n", " reverseQ: a boolean, True indicates sorted descending\n", " unique_onlyQ: a boolean, indicates removal of duplicates\n", "\n", " Returns:\n", " List of values meeting the comparison specification, if any. Otherwise, the string 'empty'\n", " \n", " Raises:\n", " string 'Error in multiple range input': If the function fails.\n", "\n", " \"\"\"\n", "\n", " ret = []\n", " icx=interval_compare_X(bracket_number1, bracket_number2, interval_type)\n", " # rg_flattened = itertools.chain.from_iterable(number_entry_range)\n", " # for e in number_entry_list:\n", " # e_value = None\n", " # if e == '' or e is None:\n", " # # no conversion\n", " # e_value = ''\n", " # else:\n", " # try:\n", " # e_value = e.Value\n", " # except:\n", " # e_value = e\n", " # if type(e_value) == float:\n", " # comparison = icx(e_value)\n", " # if comparison:\n", " # ret.append(e_value)\n", "\n", " # ret = [icx(x) for x in number_entry_list] \n", "\n", " ret = [y for x in number_entry_list for y in [icx(x)] if y is not None]\n", "\n", " if unique_onlyQ:\n", " ret = list(set(ret))\n", " if sortQ:\n", " ret.sort()\n", " if reverseQ:\n", " ret.reverse()\n", "\n", " if len(ret) == 0:\n", " return 0\n", " else:\n", " return ret\n", " " ] }, { "cell_type": "code", "execution_count": 30, "id": "f2446c35", "metadata": {}, "outputs": [], "source": [ "def mix_func(x):\n", " \"\"\"Return a list of x random values\n", "\n", " Args:\n", " x: integer number of values to produce\n", " \n", " Returns:\n", " an x-length list of random numbers\n", " \n", " Raises:\n", " zero, if x == 0\n", " \"Function error\" if function fails\n", "\n", " Disclosure:\n", " Lifted from Page 56 of https://www.pyxll.com/docs/pyxll-5.5.4.pdf \n", " \"\"\"\n", " try:\n", " if x == 0:\n", " # return as a number to Excel\n", " return 0\n", "\n", " # return a list of values as an 'object'\n", " array = [random() for i in range(x)]\n", " return array\n", " except:\n", " return \"Function error\"" ] }, { "cell_type": "code", "execution_count": 31, "id": "8c7e2a5c", "metadata": {}, "outputs": [], "source": [ "def stats_X(x, n, decimal_places=3):\n", " \"\"\"Return a list of lists counting and comparing number of runs with each possible length\n", "\n", " :param x: integer number of values per run\n", " :param n: integer number of runs\n", " :param decimal_places: decimal places in ratio result \n", "\n", " Returns:\n", " a 3-column by x-row range\n", " column 1: possible values of counter function\n", " column 2: count of runs for each possible value\n", " column 3: ratio of specific count of runs to total runs, n\n", " \n", " Raises:\n", " \"Function error\" if function fails\n", "\n", " Example:\n", "\n", " = stats_X(10,50000,3) returns\n", "\n", " 0:\t47 0.001\n", " 1:\t489 0.010\n", " 2:\t2224 0.044\n", " 3:\t5882 0.118\n", " 4:\t10232 0.205\n", " 5:\t12299 0.246\n", " 6:\t10183 0.204\n", " 7:\t5933 0.119\n", " 8:\t2135 0.043\n", " 9:\t533 0.011\n", " 10:\t43 0.001\n", "\n", " \"\"\"\n", "\n", " try:\n", " # consider x might be a list or an int\n", " # this avoids the error from len(an_integer)\n", " len_int_or_list = lambda x: 0 if x == 0 else len(x)\n", " results = []\n", " # for f in range(n):\n", " # mfx = mix_func(x)\n", " # this_run = filter_int_comp_list(0.0, 0.5, 'oo', mfx)\n", " # results.append(len_int_or_list(this_run))\n", " results = [len_int_or_list(filter_int_comp_list_X(0.5, 1.0, 'oo', mix_func(x))) \\\n", " for e in range(n)]\n", " \n", " counts = Counter(results)\n", " output = []\n", " # total = sum([counts.get(e, 0) for e in counts])\n", " for e in range(x+1):\n", " output.append([str(e)+':', counts.get(e, 0), KLHfloatround(counts.get(e, 0)/n,decimal_places)])\n", " return output\n", " except:\n", " return 'Function error'\n", "\n", "temp = stats_X(10,50000,3)" ] }, { "cell_type": "code", "execution_count": 32, "id": "c65312ad", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "12403" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "temp\n", "temp[5][1]" ] }, { "cell_type": "code", "execution_count": 33, "id": "28b9e8c2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.6382322692042504,\n", " 0.20593987257093727,\n", " 0.1372562039528411,\n", " 0.175526098497076,\n", " 0.3810352308348103,\n", " 0.8053243688081783,\n", " 0.4703688470655447,\n", " 0.32208402078371123,\n", " 0.06771485444436087,\n", " 0.035216331634439046]" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mix_func(10)" ] }, { "cell_type": "code", "execution_count": 34, "id": "7696e480", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "50.62" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "KLHfloatround(50.625, 2)" ] }, { "cell_type": "code", "execution_count": 35, "id": "fc75248a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ ".OO(x)>" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "interval_compare_X(12, 15, 'oo')" ] }, { "cell_type": "code", "execution_count": 36, "id": "d28a61ce", "metadata": {}, "outputs": [], "source": [ "# list of lists\n", "temp = mix_func(10)\n", "\n", "# create a dataframe\n", "# using list comprehension to get last two columns of all rows\n", "temp_trimmed = [[e] for e in temp]\n", "df = pd.DataFrame(temp_trimmed, columns = ['List'])\n", "\n", "# Inserting variables into pages using glue: entire table\n", "# mnb.glue(\"MYST_TEST_BED\", df, display=False)" ] }, { "cell_type": "code", "execution_count": 37, "id": "cd88efc5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.4334561661076195,\n", " 0.011254751261764673,\n", " 0.28611461448825504,\n", " 0.9223646910945967,\n", " 0.2820420824716148,\n", " 0.5798604286539191,\n", " 0.566171717032284,\n", " 0.359868275510286,\n", " 0.6785723491897521,\n", " 0.5223123690464662]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "temp" ] }, { "cell_type": "code", "execution_count": 38, "id": "e0f5fe1c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.9361875926635123,\n", " 0.35237587248635904,\n", " 0.22269487604751603,\n", " 0.44439425762759155,\n", " 0.6388078635862119,\n", " 0.3622515501766691,\n", " 0.48510969279617977,\n", " 0.18189673577736443,\n", " 0.29904569849795615,\n", " 0.5769370034959724,\n", " 0.6542470949012684]" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mix_func(11)" ] }, { "cell_type": "code", "execution_count": 39, "id": "049ae86d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[0.4334561661076195],\n", " [0.011254751261764673],\n", " [0.28611461448825504],\n", " [0.9223646910945967],\n", " [0.2820420824716148],\n", " [0.5798604286539191],\n", " [0.566171717032284],\n", " [0.359868275510286],\n", " [0.6785723491897521],\n", " [0.5223123690464662]]" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "temp_trimmed\n" ] }, { "cell_type": "code", "execution_count": 40, "id": "38529852", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
List
00.433456
10.011255
20.286115
30.922365
40.282042
50.579860
60.566172
70.359868
80.678572
90.522312
\n", "
" ], "text/plain": [ " List\n", "0 0.433456\n", "1 0.011255\n", "2 0.286115\n", "3 0.922365\n", "4 0.282042\n", "5 0.579860\n", "6 0.566172\n", "7 0.359868\n", "8 0.678572\n", "9 0.522312" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df" ] }, { "cell_type": "code", "execution_count": 41, "id": "f4344ee1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " List\n", "0 0.433456\n", "1 0.011255\n", "2 0.286115\n", "3 0.922365\n", "4 0.282042\n", "5 0.579860\n", "6 0.566172\n", "7 0.359868\n", "8 0.678572\n", "9 0.522312\n" ] } ], "source": [ "print(df)" ] }, { "cell_type": "code", "execution_count": 42, "id": "9523e3b2", "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'mnb' is not defined", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "Input \u001b[1;32mIn [42]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# Inserting variables into pages using glue: entire table\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmnb\u001b[49m\u001b[38;5;241m.\u001b[39mglue(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMYST_TEST_BED\u001b[39m\u001b[38;5;124m\"\u001b[39m, df, display\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n", "\u001b[1;31mNameError\u001b[0m: name 'mnb' is not defined" ] } ], "source": [ "# Inserting variables into pages using glue: entire table\n", "mnb.glue(\"MYST_TEST_BED\", df, display=False)" ] }, { "cell_type": "code", "execution_count": null, "id": "11bb0743", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "pyxll310", "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.10.4" } }, "nbformat": 4, "nbformat_minor": 5 }