diff --git a/doc/create_names_for_reference.py b/doc/create_names_for_reference.py index eec54aba..39117918 100644 --- a/doc/create_names_for_reference.py +++ b/doc/create_names_for_reference.py @@ -1,3 +1,5 @@ +# Generate the routines divide by slicot-chapters for sphinx-doc. +# Only prints out the names, copy & past them into slycot_outer.rst and slycot_inner.rst. import re import pandas as pd import matplotlib.pyplot as plt @@ -9,7 +11,7 @@ def get_slycot_routines(sly): all_attributes = dir(sly) r = re.compile("[a-z][a-z][0-9][0-9a-z][a-z][a-z]") - matched_attributes = list(filter(r.match, all_attributes)) # Read Note below + matched_attributes = list(filter(r.match, all_attributes)) return matched_attributes slycot_wrapper = get_slycot_routines(slycot) @@ -17,11 +19,19 @@ def get_slycot_routines(sly): slycot_f2py_wrapper = get_slycot_routines(slycot._wrapper) slycot_f2py_wrapper.sort() +from itertools import groupby +from operator import itemgetter + print(f"\nslycot_wrapper {len(slycot_wrapper)}\n") -for routine in slycot_wrapper: - print(routine) +for chapter_letter, chapter_routines in groupby(sorted(slycot_wrapper), key=itemgetter(0)): + print(chapter_letter) + for routine in chapter_routines: + print(routine) + print("\n") print(f"\nslycot_f2py_wrapper {len(slycot_f2py_wrapper)}\n") -for routine in slycot_f2py_wrapper: - print("_wrapper."+routine) - +for chapter_letter, chapter_routines in groupby(sorted(slycot_f2py_wrapper), key=itemgetter(0)): + print(chapter_letter) + for routine in chapter_routines: + print("_wrapper."+routine) + print("\n") diff --git a/doc/source/dev/inspect_slycot.ipynb b/doc/source/dev/inspect_slycot.ipynb index 8d28451a..81907b4a 100644 --- a/doc/source/dev/inspect_slycot.ipynb +++ b/doc/source/dev/inspect_slycot.ipynb @@ -20,14 +20,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.1.dev607+g25317fd.d20230808\n" + "0.1.dev609+g4f08655.d20230809\n" ] } ], @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -92,14 +92,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 49 routines implemented.\n", + "There are currently 49 routines that are found in slycot.\n", "------\n", "['ab01nd', 'ab05md', 'ab05nd', 'ab07nd', 'ab08nd', 'ab08nz']\n", "['ab09ad', 'ab09ax', 'ab09bd', 'ab09md', 'ab09nd', 'ab13bd']\n", @@ -117,7 +117,7 @@ "source": [ "slycot_wrapper = get_slycot_routines(slycot)\n", "\n", - "print(f\"Currently there are {len(slycot_wrapper)} routines implemented.\")\n", + "print(f\"There are currently {len(slycot_wrapper)} routines that are found in slycot.\")\n", "print(\"------\")\n", "print(print_list_chunks(slycot_wrapper))" ] @@ -132,14 +132,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 71 routines implemented.\n", + "There are currently 71 routines that are found in slycot._wrapper.\n", "------\n", "['ab01nd', 'ab05md', 'ab05nd', 'ab07nd', 'ab08nd', 'ab08nz']\n", "['ab09ad', 'ab09ax', 'ab09bd', 'ab09md', 'ab09nd', 'ab13bd']\n", @@ -160,7 +160,7 @@ "source": [ "slycot_f2py_wrapper = get_slycot_routines(slycot._wrapper)\n", "\n", - "print(f\"Currently there are {len(slycot_f2py_wrapper)} routines implemented.\")\n", + "print(f\"There are currently {len(slycot_f2py_wrapper)} routines that are found in slycot._wrapper.\")\n", "print(\"------\")\n", "print(print_list_chunks(slycot_f2py_wrapper))" ] @@ -175,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -185,40 +185,28 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 10 routines implemented in slycot_wrapper which are not in slycot_f2py_wrapper.\n", + "There are currently 10 routines that found in slycot not in slycot._wrapper.\n", "------\n", - "['tb04ad', 'tb05ad', 'sb02mt', 'td04ad', 'tc04ad', 'tc01od']\n", - "['sg02ad', 'tb03ad', 'sb02od', 'sb03md57']\n", + "['sb02od', 'tb05ad', 'sb02mt', 'tb04ad', 'sb03md57', 'sg02ad']\n", + "['tc01od', 'tb03ad', 'td04ad', 'tc04ad']\n", "None\n", "\n", "\n", - "Currently there are 32 routines implemented in slycot_f2py_wrapper which are not in slycot_wrapper.\n", + "There are currently 32 routines that are found in slycot._wrapper not in slycot.\n", "------\n", - "['td04ad_c', 'sb02mt_cl', 'sg02ad_bb', 'sb02mt_c', 'tc04ad_l', 'tg01fd_nn']\n", - "['tc01od_r', 'sb02od_c', 'tb04ad_r', 'ag08bd', 'sb02mt_n', 'sg02ad_bn']\n", - "['td04ad_r', 'tb03ad_l', 'sg02ad_bc', 'sb02od_d', 'tc04ad_r', 'tg01fd_ii']\n", - "['tc01od_l', 'tb05ad_ng', 'sb02od_n', 'sb02mt_nl', 'sb10jd', 'sb02od_b']\n", - "['tb05ad_ag', 'tb05ad_nh', 'tg01fd_uu', 'tb04ad_c', 'tg01ad', 'tb03ad_r']\n", - "['sg02ad_bd', 'sg02ad_g']\n", - "None\n", - "\n", - "\n", - "Currently there are 42 routines implemented in slycot_wrapper or slycot_f2py_wrapper.\n", - "------\n", - "['td04ad_c', 'tb05ad', 'sb02mt_cl', 'sg02ad_bb', 'sb02mt', 'sb02mt_c']\n", - "['tc04ad_l', 'tg01fd_nn', 'tc01od_r', 'tb03ad', 'ag08bd', 'sb02od_c']\n", - "['tb04ad_r', 'sb03md57', 'sb02mt_n', 'tb04ad', 'td04ad', 'sg02ad_bn']\n", - "['td04ad_r', 'tb03ad_l', 'sg02ad_bc', 'sb02od_d', 'tc04ad_r', 'tg01fd_ii']\n", - "['tc01od_l', 'tb05ad_ng', 'sb02od_n', 'sg02ad', 'sb02od', 'sb02mt_nl']\n", - "['sb10jd', 'sb02od_b', 'tb05ad_ag', 'tb05ad_nh', 'tg01fd_uu', 'tc04ad']\n", - "['tb04ad_c', 'tg01ad', 'tb03ad_r', 'sg02ad_bd', 'tc01od', 'sg02ad_g']\n", + "['tb05ad_ag', 'sb02od_b', 'td04ad_c', 'tg01ad', 'sb02mt_n', 'sg02ad_bc']\n", + "['sb02od_n', 'tb05ad_nh', 'tg01fd_ii', 'ag08bd', 'tg01fd_nn', 'tc04ad_l']\n", + "['sg02ad_bd', 'sb10jd', 'tb05ad_ng', 'sb02od_d', 'tb03ad_r', 'tg01fd_uu']\n", + "['tc04ad_r', 'tb04ad_r', 'tb04ad_c', 'sb02mt_cl', 'sg02ad_bb', 'tc01od_l']\n", + "['td04ad_r', 'sb02mt_nl', 'tc01od_r', 'sg02ad_g', 'tb03ad_l', 'sb02od_c']\n", + "['sg02ad_bn', 'sb02mt_c']\n", "None\n", "\n", "\n" @@ -226,68 +214,60 @@ } ], "source": [ - "in_slycot_wrapper = list(set(slycot_wrapper) - set(slycot_f2py_wrapper))\n", - "in_slycot_wrapper\n", - "\n", - "print(f\"Currently there are {len(in_slycot_wrapper)} routines implemented in slycot_wrapper which are not in slycot_f2py_wrapper.\")\n", - "print(\"------\")\n", - "print(print_list_chunks(in_slycot_wrapper))\n", - "print(\"\\n\")\n", - "\n", - "in_slycot_f2py_wrapper = list(set(slycot_f2py_wrapper) - set(slycot_wrapper))\n", - "in_slycot_f2py_wrapper\n", + "not_in_slycot_f2py_wrapper = list(set(slycot_wrapper) - set(slycot_f2py_wrapper))\n", + "not_in_slycot_f2py_wrapper\n", "\n", - "print(f\"Currently there are {len(in_slycot_f2py_wrapper)} routines implemented in slycot_f2py_wrapper which are not in slycot_wrapper.\")\n", + "print(f\"There are currently {len(not_in_slycot_f2py_wrapper)} routines that found in slycot not in slycot._wrapper.\")\n", "print(\"------\")\n", - "print(print_list_chunks(in_slycot_f2py_wrapper))\n", + "print(print_list_chunks(not_in_slycot_f2py_wrapper))\n", "print(\"\\n\")\n", "\n", - "diff = list(set(slycot_f2py_wrapper) ^ set(slycot_wrapper))\n", - "diff\n", + "not_in_slycot_wrapper = list(set(slycot_f2py_wrapper) - set(slycot_wrapper))\n", + "not_in_slycot_wrapper\n", "\n", - "print(f\"Currently there are {len(diff)} routines implemented in slycot_wrapper or slycot_f2py_wrapper.\")\n", + "print(f\"There are currently {len(not_in_slycot_wrapper)} routines that are found in slycot._wrapper not in slycot.\")\n", "print(\"------\")\n", - "print(print_list_chunks(diff))\n", + "print(print_list_chunks(not_in_slycot_wrapper))\n", "print(\"\\n\")" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 39 routines implemented in slycot_wrapper and in slycot_f2py_wrapper.\n", + "There are currently 81 routines that are found in slycot or in slycot._wrapper. (union)\n", "------\n", - "['mc01td', 'sb04qd', 'ab13dd', 'ab13md', 'ab13fd', 'sb03od']\n", - "['sg03bd', 'ab08nz', 'tb01id', 'mb03rd', 'tb01pd', 'mb05nd']\n", - "['sb04md', 'tf01rd', 'sb01bd', 'mb03vd', 'mb05md', 'ab05nd']\n", - "['mb03vy', 'ab08nd', 'ab05md', 'ab09ax', 'sb02md', 'sg03ad']\n", - "['ab09md', 'sb10dd', 'sb03md', 'ab09bd', 'tf01md', 'ab09ad']\n", - "['sb10hd', 'sb10ad', 'ab07nd', 'ab01nd', 'mb03wd', 'ab09nd']\n", - "['ab13ed', 'ab13bd', 'sb10fd']\n", + "['tb05ad_ag', 'sb02md', 'sb03md', 'ab08nd', 'tg01fd_ii', 'tb05ad_nh']\n", + "['sb04md', 'ag08bd', 'tb01pd', 'mb03vd', 'sb03md57', 'ab13bd']\n", + "['sb02mt', 'tc04ad', 'ab09nd', 'tc04ad_l', 'sb10jd', 'tf01rd']\n", + "['tb05ad_ng', 'sb02od_d', 'ab05md', 'ab07nd', 'sb04qd', 'ab08nz']\n", + "['tb04ad', 'mb05nd', 'ab09bd', 'tg01fd_uu', 'mb03vy', 'td04ad']\n", + "['ab09ad', 'sb10dd', 'sb10hd', 'sg02ad_bb', 'sg03ad', 'tc01od_l']\n", + "['td04ad_r', 'ab13md', 'tc01od', 'mb03wd', 'sb02mt_nl', 'tc01od_r']\n", + "['tb03ad_l', 'tb05ad', 'tf01md', 'sb02od_c', 'sb01bd', 'mc01td']\n", + "['sb02mt_c', 'sb02od_b', 'td04ad_c', 'tg01ad', 'sb02mt_n', 'sg02ad_bc']\n", + "['sb02od_n', 'sg03bd', 'sg02ad', 'tb03ad', 'tb01id', 'mb05md']\n", + "['tg01fd_nn', 'sg02ad_bd', 'ab13dd', 'tb03ad_r', 'ab09ax', 'ab05nd']\n", + "['mb03rd', 'sb10ad', 'tc04ad_r', 'ab01nd', 'tb04ad_r', 'ab09md']\n", + "['tb04ad_c', 'sb02mt_cl', 'ab13fd', 'ab13ed', 'sb03od', 'sg02ad_g']\n", + "['sb02od', 'sb10fd', 'sg02ad_bn']\n", "None\n", "\n", "\n", - "Currently there are 81 routines implemented in slycot_wrapper or in slycot_f2py_wrapper.\n", + "There are currently 39 routines that are found in slycot and in slycot._wrapper. (intersection)\n", "------\n", - "['mc01td', 'td04ad_c', 'sg02ad_bb', 'sb02mt', 'sb02mt_c', 'tc01od_r']\n", - "['ab13md', 'ag08bd', 'ab08nz', 'tb01id', 'mb03rd', 'tb04ad']\n", - "['td04ad', 'sb04md', 'tf01rd', 'mb03vd', 'ab05nd', 'tc04ad_r']\n", - "['sb02md', 'sg03ad', 'tg01fd_ii', 'tc01od_l', 'tb05ad_ng', 'sb02od_n']\n", - "['sb03md', 'sb02mt_nl', 'sb10jd', 'tf01md', 'sb02od_b', 'ab09ad']\n", - "['tb05ad_ag', 'sb10hd', 'tb04ad_c', 'sb10ad', 'ab01nd', 'tg01ad']\n", - "['ab13ed', 'tb03ad', 'sg02ad_bd', 'tb05ad', 'sb02mt_cl', 'sb04qd']\n", - "['tc04ad_l', 'tg01fd_nn', 'ab13dd', 'ab13fd', 'sb03od', 'sb02od_c']\n", - "['tb04ad_r', 'sg03bd', 'sb02mt_n', 'sb03md57', 'tb01pd', 'mb05nd']\n", - "['sg02ad_bn', 'td04ad_r', 'sb01bd', 'tb03ad_l', 'mb05md', 'sg02ad_bc']\n", - "['sb02od_d', 'mb03vy', 'ab08nd', 'ab05md', 'ab09ax', 'ab09md']\n", - "['sb10dd', 'sg02ad', 'ab09bd', 'sb02od', 'tb05ad_nh', 'tg01fd_uu']\n", - "['tc04ad', 'ab07nd', 'mb03wd', 'ab09nd', 'tb03ad_r', 'ab13bd']\n", - "['sb10fd', 'tc01od', 'sg02ad_g']\n", + "['sb02md', 'sb03md', 'ab08nd', 'sb04md', 'sg03bd', 'tb01pd']\n", + "['mb03vd', 'tb01id', 'ab13bd', 'mb05md', 'ab09nd', 'ab13dd']\n", + "['tf01rd', 'ab05md', 'ab07nd', 'ab09ax', 'ab08nz', 'sb04qd']\n", + "['ab05nd', 'mb03rd', 'mb05nd', 'ab09bd', 'sb10ad', 'mb03vy']\n", + "['ab01nd', 'ab09md', 'ab09ad', 'sb10dd', 'sb10hd', 'sg03ad']\n", + "['ab13md', 'ab13fd', 'ab13ed', 'mb03wd', 'sb03od', 'tf01md']\n", + "['sb01bd', 'sb10fd', 'mc01td']\n", "None\n", "\n", "\n" @@ -295,30 +275,31 @@ } ], "source": [ - "intersection = list(set(slycot_f2py_wrapper) & set(slycot_wrapper))\n", - "intersection\n", + "union = list(set(slycot_f2py_wrapper) | set(slycot_wrapper))\n", "\n", - "print(f\"Currently there are {len(intersection)} routines implemented in slycot_wrapper and in slycot_f2py_wrapper.\")\n", + "print(f\"There are currently {len(union)} routines that are found in slycot or in slycot._wrapper. (union)\")\n", "print(\"------\")\n", - "print(print_list_chunks(intersection))\n", + "print(print_list_chunks(union))\n", "print(\"\\n\")\n", "\n", - "union = list(set(slycot_f2py_wrapper) | set(slycot_wrapper))\n", "\n", - "print(f\"Currently there are {len(union)} routines implemented in slycot_wrapper or in slycot_f2py_wrapper.\")\n", + "intersection = list(set(slycot_f2py_wrapper) & set(slycot_wrapper))\n", + "intersection\n", + "\n", + "print(f\"There are currently {len(intersection)} routines that are found in slycot and in slycot._wrapper. (intersection)\")\n", "print(\"------\")\n", - "print(print_list_chunks(union))\n", + "print(print_list_chunks(intersection))\n", "print(\"\\n\")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -330,7 +311,7 @@ "source": [ "venn2(subsets = (len(set(slycot_wrapper)), \n", " len(set(slycot_f2py_wrapper)), \n", - " len(intersection)), set_labels = ('slycot_wrapper', 'slycot_f2py_wrapper'))\n", + " len(intersection)), set_labels = ('slycot', 'slycot._wrapper'))\n", "plt.show()" ] } diff --git a/doc/source/dev/slicot_slycot.ipynb b/doc/source/dev/slicot_slycot.ipynb index 98c6b4d0..ddc76215 100644 --- a/doc/source/dev/slicot_slycot.ipynb +++ b/doc/source/dev/slicot_slycot.ipynb @@ -19,16 +19,16 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'0.1.dev607+g25317fd.d20230808'" + "'0.1.dev609+g4f08655.d20230809'" ] }, - "execution_count": 19, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ @@ -90,14 +90,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 607 routines implemented.\n", + "There are currently 607 routines that are found in slicot.\n", "['mb01wd', 'tg01gd', 'ab13fd', 'sg03ay', 'mb01oe', 'mb02fd']\n", "['tg01oa', 'dg01ny', 'sg03ax', 'fb01qd', 'ma02az', 'mc01md']\n", "['md03by', 'tf01mx', 'ib01nd', 'mb02rz', 'mb04bp', 'tb01kd']\n", @@ -210,20 +210,20 @@ "\n", "slicot_routines = [x.split(\"\\n\")[0] for x in lines]\n", "\n", - "print(f\"Currently there are {len(slicot_routines)} routines implemented.\")\n", + "print(f\"There are currently {len(slicot_routines)} routines that are found in slicot.\")\n", "print(print_list_chunks(slicot_routines))" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 49 methods implemented.\n", + "There are currently 49 routines that are found in slycot.\n", "------\n", "['ab01nd', 'ab05md', 'ab05nd', 'ab07nd', 'ab08nd', 'ab08nz']\n", "['ab09ad', 'ab09ax', 'ab09bd', 'ab09md', 'ab09nd', 'ab13bd']\n", @@ -241,7 +241,7 @@ "source": [ "slycot_routines = get_slycot_routines(slycot)\n", "\n", - "print(f\"Currently there are {len(slycot_routines)} methods implemented.\")\n", + "print(f\"There are currently {len(slycot_routines)} routines that are found in slycot.\")\n", "print(\"------\")\n", "print(print_list_chunks(slycot_routines))" ] @@ -256,151 +256,115 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 61, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 608 routines implemented.\n", + "There are currently 1 routines that are found in slycot and not in slicot.\n", "------\n", - "['sb03os', 'sb04py', 'mb04md', 'tb04cd', 'sb10ud', 'tg01nx']\n", - "['ud01md', 'mb02id', 'mb04tb', 'sb08md', 'ma02dd', 'ib01my']\n", - "['ab09jw', 'sb10ed', 'ib01od', 'sb02mu', 'mb03td', 'mb04py']\n", - "['ab09jx', 'mb01ot', 'mb03gz', 'mb04kd', 'sb03qx', 'tb04bv']\n", - "['ab05od', 'mb01nd', 'mb02sz', 'tb01xz', 'sb10hd', 'tf01mx']\n", - "['tg01fd', 'mb01vd', 'sb02ox', 'fd01ad', 'mb3lzp', 'mb02nd']\n", - "['sb03ot', 'mb03my', 'ma02pd', 'mb04az', 'mb03qy', 'mb02hd']\n", - "['mb04ru', 'mc03nx', 'mc01md', 'tb01wd', 'sg03bz', 'mb03fd']\n", - "['mb04tt', 'ab04md', 'sb16cy', 'mb03bb', 'ma01bd', 'sb08my']\n", - "['sb03ou', 'sb04od', 'sb03oz', 'mb03ya', 'mb01ry', 'sb04ry']\n", - "['mb04od', 'sb04rv', 'mb04pb', 'ib01nd', 'mb04iy', 'ab13bd']\n", - "['sg03bd', 'tg01hd', 'tc04ad', 'mb04bd', 'mc01sw', 'mb04ow']\n", - "['sg03bv', 'tg01kz', 'tg01hx', 'sb10wd', 'tb04ad', 'nf01by']\n", - "['sb04rd', 'mb04wp', 'ab05md', 'sb09md', 'sb10fd', 'tg01ly']\n", - "['sg03ad', 'mb04ox', 'mb02cv', 'td05ad', 'sb03my', 'mb02gd']\n", - "['sb04qd', 'mb05my', 'bb04ad', 'mb04id', 'ag08by', 'mb04ld']\n", - "['mb03ud', 'mb04qb', 'mc01sd', 'mb04vx', 'nf01bw', 'td03ay']\n", - "['tf01od', 'tb01ty', 'sb03mv', 'ab08nz', 'mb3oyz', 'mb03pd']\n", - "['sb10qd', 'mc01wd', 'mb03lf', 'mb04xy', 'mb01oo', 'mb03ry']\n", - "['sb08dd', 'nf01bv', 'ag07bd', 'ab09nd', 'sb03ud', 'mb04wr']\n", - "['mb3jzp', 'mb02xd', 'sb04qy', 'sb16cd', 'mb01xy', 'ab09jd']\n", - "['mb02uw', 'ma02jz', 'ab09iy', 'mb03ah', 'mb03zd', 'ib01pd']\n", - "['sb01md', 'sb04rx', 'tg01kd', 'sb10sd', 'mb01oc', 'ma02id']\n", - "['sb04nd', 'mb03ld', 'mb03rw', 'mb01uy', 'mb02cx', 'ab13id']\n", - "['mb04bz', 'sb10kd', 'ma01bz', 'mb04cd', 'ab09bd', 'nf01be']\n", - "['sb03od', 'tb01nd', 'mb01zd', 'ab09kx', 'tb01xd', 'mb04ed']\n", - "['nf01br', 'sb04mr', 'sb04nx', 'sb02ou', 'mb01rw', 'sb02qd']\n", - "['sb03mw', 'ag08bd', 'mb02td', 'bd02ad', 'mb04su', 'mb02sd']\n", - "['de01pd', 'mb04ds', 'ma02hz', 'mb03cz', 'ab08nx', 'ma02pz']\n", - "['ab09cx', 'dg01od', 'mb01kd', 'mb01ux', 'mb02cy', 'tb04bx']\n", - "['dk01md', 'ma02gz', 'mc01pd', 'tg01pd', 'md03bf', 'sb04qr']\n", - "['sb10jd', 'ma02ed', 'sb04mu', 'sb08fd', 'nf01ay', 'ab09hx']\n", - "['sg03ay', 'mb03id', 'mb04yd', 'ab13ad', 'sb03qy', 'sg03by']\n", - "['ib01py', 'mb03ab', 'mb05md', 'mb01oe', 'sb02rd', 'tb01ud']\n", - "['tb01px', 'sb10vd', 'sb03md57', 'tb01pd', 'mb01os', 'mb03ny']\n", - "['ma02gd', 'mb01uz', 'mb04hd', 'tb01ld', 'mb02md', 'ab09hd']\n", - "['mb04fd', 'mb03ai', 'sb02pd', 'mb01sd', 'ud01dd', 'sb04px']\n", - "['mb03md', 'ag8byz', 'mb03qx', 'ma02ad', 'ud01bd', 'mb04di']\n", - "['mb04wd', 'sb03sx', 'mc01td', 'mc01sx', 'ma02md', 'tg01hy']\n", - "['sb02oy', 'ab13fd', 'sb03pd', 'sb02mt', 'ib01px', 'ab08nw']\n", - "['ma02cz', 'ma02nz', 'mb03xu', 'tc01od', 'mb03qv', 'sg03bu']\n", - "['nf01bx', 'sb01bd', 'sb04ny', 'mb03oy', 'sb10yd', 'mb03qg']\n", - "['sb02cx', 'sb04nw', 'mb03wx', 'bd01ad', 'tg01nd', 'mb01ld']\n", - "['tg01dd', 'ud01mz', 'mb03xz', 'mb4dlz', 'sb01by', 'ab09id']\n", - "['mb03jd', 'mb03bc', 'ab09ax', 'mb02vd', 'sg02ad', 'mb04nd']\n", - "['mb01ud', 'mc01nd', 'mb04oy', 'md03ba', 'sb10md', 'ab13dd']\n", - "['ib01oy', 'ab13md', 'sb04nv', 'mb01yd', 'tb01id', 'tg01gd']\n", - "['mb03jp', 'sb10pd', 'nf01bu', 'mc01xd', 'mb05oy', 'mb02ed']\n", - "['sb04my', 'fb01td', 'ab09gd', 'nf01ad', 'mb03vy', 'ab07nd']\n", - "['mb05nd', 'mb01rd', 'tb01ux', 'mb03kb', 'ib03ad', 'sb10zd']\n", - "['ab13ax', 'mb03bz', 'ud01nd', 'sb08cd', 'sg02cx', 'mb04tw']\n", - "['mb01rh', 'mb03rd', 'tg01ob', 'mb02ny', 'mb04qf', 'ma02fd']\n", - "['tg01bd', 'mb02jd', 'mb04ad', 'mb02qy', 'ma02es', 'ab05sd']\n", - "['tb01wx', 'mb03ed', 'tf01nd', 'tg01od', 'sb10ad', 'tb01md']\n", - "['mb04tx', 'mb03yt', 'nf01bb', 'sb02ow', 'bb02ad', 'ab09bx']\n", - "['ab05nd', 'mb03xp', 'tg01hu', 'ab08ny', 'sb02md', 'sb16ay']\n", - "['mb03xs', 'sb03sd', 'sb02ms', 'mc03md', 'mb04ty', 'mb01rx']\n", - "['ab09cd', 'mb02cu', 'mb4dpz', 'mb02wd', 'mc01qd', 'sb04qu']\n", - "['nf01bf', 'tc05ad', 'ab09md', 'tb01zd', 'mb02tz', 'mb04iz']\n", - "['mb03lp', 'mb01rt', 'mc03nd', 'mb03wd', 'mb02ud', 'mb03iz']\n", - "['mc01py', 'td04ad', 'sb02ov', 'ib01md', 'ud01cd', 'mb02pd']\n", - "['ab09hy', 'sb10ld', 'ab09jv', 'mb03jz', 'mb04qu', 'sb03oy']\n", - "['sg02cw', 'mb03py', 'sb02mv', 'mb03wa', 'tg01id', 'tb01vd']\n", - "['ab09ed', 'mb03kd', 'mb03af', 'mc03ny', 'mb03bd', 'sb10dd']\n", - "['ab01od', 'sb03or', 'mb04fp', 'tg01qd', 'mb04tv', 'bb03ad']\n", - "['ab07md', 'tb01uy', 'tb05ad', 'ue01md', 'nf01bd', 'ma02ez']\n", - "['tg01az', 'mb03gd', 'ib01qd', 'mc01rd', 'mb03ba', 'mb03bf']\n", - "['mb04zd', 'ag08bz', 'mb03ad', 'fb01sd', 'mb03qd', 'tg01ad']\n", - "['mb04pa', 'tg01jy', 'tb01kd', 'ib01cd', 'mb04dp', 'tf01rd']\n", - "['mb02kd', 'ma02bd', 'ab13cd', 'mb03nd', 'nf01ba', 'mb03hz']\n", - "['mb04yw', 'mb01xd', 'ab09dd', 'md03bx', 'md03bb', 'tg01ed']\n", - "['sb08ny', 'sg03bt', 'de01od', 'mb03fz', 'ma02az', 'mc01sy']\n", - "['tb03ay', 'tb01yd', 'dg01md', 'fb01rd', 'mb03za', 'ab05qd']\n", - "['tb04bw', 'tg01oa', 'ab09kd', 'mb01md', 'mb03dd', 'sg03ax']\n", - "['mb03be', 'sg03bx', 'sb03rd', 'tf01qd', 'tg01jd', 'mb03hd']\n", - "['sg03br', 'nf01bp', 'mb01uw', 'mb04dz', 'sg03bs', 'sb08gd']\n", - "['df01md', 'sb02mx', 'mb03dz', 'mb04dd', 'ab01nd', 'mb02rz']\n", - "['dg01ny', 'mb03ke', 'sg02cv', 'ab01md', 'sb04rw', 'fb01qd']\n", - "['ma02iz', 'ib01rd', 'ib01ad', 'sb02sd', 'mb02uu', 'ab08nd']\n", - "['mb01ru', 'sb16ad', 'mb04ny', 'ab09ad', 'mb04tu', 'bb01ad']\n", - "['tb01iz', 'mb04rb', 'mb04dl', 'mc01vd', 'sb02mr', 'fb01vd']\n", - "['mb01oh', 'mb04qc', 'mb04gd', 'ab13dx', 'sb03mu', 'tf01md']\n", - "['mb04ud', 'mb03cd', 'mb03qw', 'mb04vd', 'sb02ru', 'mb02qd']\n", - "['mb03yd', 'mb01pd', 'sb03md', 'tg01md', 'mb04ts', 'sb03td']\n", - "['mb04pu', 'tb04bd', 'ma02jd', 'ma02od', 'sb03mx', 'sb01fy']\n", - "['mb02rd', 'mb02cd', 'mb02jx', 'mb03rx', 'mb02yd', 'tg01ld']\n", - "['md03ad', 'mb04dy', 'mb04jd', 'mb03lz', 'md03bd', 'mb03ka']\n", - "['mb02uv', 'tb01kx', 'ab09fd', 'sb04pd', 'sb10id', 'mb01od']\n", - "['mb01qd', 'mb04db', 'mb01wd', 'mb03ae', 'ab8nxz', 'ma02cd']\n", - "['mb05od', 'sb01dd', 'ab08md', 'nf01bs', 'mb03ag', 'mc01od']\n", - "['sb10rd', 'mb03ts', 'sb04md', 'ma02hd', 'mb03xd', 'sb02mw']\n", - "['sb04mw', 'md03by', 'mb02od', 'sb01bx', 'mb01ss', 'tg01fz']\n", - "['ma02oz', 'tf01pd', 'sb08nd', 'tb01vy', 'sg03bw', 'mb3pyz']\n", - "['tg01wd', 'td03ad', 'mb02dd', 'sb08hd', 'ma02bz', 'mb04bp']\n", - "['ma02mz', 'mb03kc', 'mb03sd', 'tf01my', 'sb03ov', 'sb04ow']\n", - "['ab13ed', 'sb10zp', 'dg01nd', 'sb06nd', 'tg01oz', 'tg01cd']\n", - "['ma01cd', 'sb02od', 'mb03vw', 'sb02nd', 'mb01rb', 'mb4dbz']\n", - "['ab05rd', 'ab05pd', 'mb03od', 'mb04wu', 'mb01td', 'sb03sy']\n", - "['mb02fd', 'mb03rz', 'tb04ay', 'sb16bd', 'ib01bd', 'ab08mz']\n", - "['mb04qs', 'tb03ad', 'mb03bg', 'sb03qd', 'mb03vd', 'sg02nd']\n", - "['ab09ix', 'ma01ad', 'mb04xd', 'nf01bq', 'sb10td', 'ib03bd']\n", - "['sb08ed', 'tb01td']\n", + "['sb03md57']\n", "None\n", "\n", - "\n" - ] - } - ], - "source": [ - "union = list(set(slicot_routines) | set(slycot_routines))\n", - "\n", - "print(f\"Currently there are {len(union)} routines implemented.\")\n", - "print(\"------\")\n", - "print(print_list_chunks(union))\n", - "print(\"\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Currently there are 48 routines which are found in slicot and slycot.\n", + "\n", + "There are currently 559 routines that are found in slicot and not in slycot.\n", "------\n", - "['ab09bd', 'sb02md', 'ab01nd', 'ab13bd', 'sg03bd', 'tb05ad']\n", - "['sb03od', 'sb02od', 'ab09nd', 'tc04ad', 'sb03md', 'ab09ax']\n", - "['sb04md', 'sg02ad', 'ab08nd', 'mc01td', 'tb04ad', 'mb03rd']\n", - "['ab09ad', 'ab05md', 'ab13dd', 'ab13fd', 'ab13md', 'sb02mt']\n", - "['sb10fd', 'sb10hd', 'sg03ad', 'tb01id', 'mb05md', 'sb04qd']\n", - "['tc01od', 'sb10dd', 'tf01rd', 'ab09md', 'tb01pd', 'sb10ad']\n", - "['sb01bd', 'tb03ad', 'mb03vd', 'mb03vy', 'ab13ed', 'ab07nd']\n", - "['mb03wd', 'mb05nd', 'tf01md', 'td04ad', 'ab08nz', 'ab05nd']\n", + "['mb03od', 'tb04bw', 'mb03qy', 'tc05ad', 'mb04pu', 'ab08md']\n", + "['ab09jw', 'sb04rx', 'ma02iz', 'sg03bu', 'tg01gd', 'ab09ed']\n", + "['mb01zd', 'sb02oy', 'mb04iz', 'sb10rd', 'mb01wd', 'sb10pd']\n", + "['sb02ox', 'mb03hz', 'mb03bb', 'tb04bd', 'tg01ob', 'tg01md']\n", + "['sb01fy', 'mb02uu', 'sb01md', 'mb03lp', 'tg01hd', 'tb01wd']\n", + "['mb02cd', 'ma02hz', 'sb10kd', 'mb04dz', 'mb03za', 'mb04iy']\n", + "['sb02ow', 'ab09hx', 'sb03qd', 'tg01az', 'sb08my', 'sb03mv']\n", + "['sb02mv', 'mb03rw', 'mb03fz', 'dg01nd', 'ma02cz', 'sb03sd']\n", + "['ma02gd', 'mc01wd', 'ab05qd', 'sb01by', 'sb03mw', 'mb03vw']\n", + "['mb03kd', 'sb03oy', 'ib01qd', 'mb02uv', 'mb01vd', 'md03ba']\n", + "['ma01cd', 'tg01ld', 'sb04ny', 'mb03xd', 'ab09cx', 'mb04qb']\n", + "['mb03ka', 'mb04qc', 'mb04az', 'sb03ud', 'mb03iz', 'mb04di']\n", + "['mb01uw', 'mc03nx', 'mb01kd', 'sb04my', 'mb03ae', 'mb01oc']\n", + "['mb02fd', 'mb02sz', 'tb01kd', 'tg01ad', 'ib01oy', 'mb04wd']\n", + "['tg01cd', 'mb01oo', 'tg01qd', 'tb01ty', 'tb01yd', 'sb02qd']\n", + "['tg01id', 'mb04bd', 'tb01ld', 'tb01td', 'tg01nd', 'sb03or']\n", + "['ab09hy', 'nf01bq', 'mb02rd', 'tg01ed', 'ma02od', 'ib01cd']\n", + "['mb03ke', 'nf01bw', 'mb02qy', 'md03bx', 'mb04vd', 'mb04ny']\n", + "['sb02mx', 'ab8nxz', 'mb04ad', 'tg01kz', 'tg01fd', 'mc03nd']\n", + "['mb03jd', 'mb01rw', 'sb08cd', 'mb02tz', 'mb02od', 'mb02gd']\n", + "['mb02yd', 'nf01be', 'sb03oz', 'mb03qw', 'sg03bw', 'ud01dd']\n", + "['mb03md', 'mc01xd', 'sb10jd', 'nf01bp', 'ma02es', 'sb02ms']\n", + "['mb04fp', 'fb01sd', 'ma02az', 'mb03xs', 'mb02ed', 'mb04vx']\n", + "['mb01td', 'ib01bd', 'mb04xy', 'mb03lz', 'sb04nx', 'ma02ad']\n", + "['sg03ay', 'tg01hx', 'sb04mu', 'mb04dy', 'ab04md', 'mb01rt']\n", + "['ab09id', 'tb04ay', 'sb08dd', 'sb03ot', 'nf01bu', 'mb03xz']\n", + "['sb10id', 'sb04rv', 'ma02gz', 'mb03ud', 'mb04bz', 'tg01pd']\n", + "['mb03wa', 'mb03ed', 'mb03be', 'sg02cw', 'sb10wd', 'mc03md']\n", + "['mb01ud', 'nf01bb', 'sb03mu', 'ab09hd', 'ab09iy', 'mb04od']\n", + "['sb04mr', 'mb04qu', 'ib01px', 'td05ad', 'nf01ay', 'mb3pyz']\n", + "['mb03bg', 'mb03xp', 'mb03zd', 'dk01md', 'sg02cv', 'ud01cd']\n", + "['mb03sd', 'tb01ux', 'tf01nd', 'sb02cx', 'sb10sd', 'mb03qg']\n", + "['sb10zd', 'mb01rh', 'mb03nd', 'tb01vy', 'ib03bd', 'de01od']\n", + "['mb01nd', 'ib01rd', 'mb02cu', 'mb03jz', 'mb02pd', 'ab09ix']\n", + "['mb03fd', 'mb03kb', 'mb04zd', 'mb04ed', 'ag8byz', 'ib03ad']\n", + "['sb04rd', 'mb01od', 'mb02qd', 'bb04ad', 'ab08mz', 'fb01qd']\n", + "['ab09bx', 'bb01ad', 'mb03wx', 'sb01dd', 'mb01qd', 'ab09gd']\n", + "['sb04pd', 'mb03dz', 'ab09jd', 'sb02ou', 'ab09kd', 'mb02jx']\n", + "['ma02pd', 'mb04wu', 'ab09dd', 'sb01bx', 'sb03rd', 'nf01ba']\n", + "['tg01nx', 'sb16cd', 'mb05oy', 'sb04qu', 'tb01zd', 'tb01wx']\n", + "['tb01ud', 'bd01ad', 'sb08ed', 'sg03bv', 'ma01bz', 'mb02vd']\n", + "['mb02cv', 'sb10ed', 'mb03ba', 'nf01bf', 'mb04oy', 'md03ad']\n", + "['ma01bd', 'mb03ab', 'tg01bd', 'mb03td', 'ab09jx', 'sg03by']\n", + "['tg01kd', 'tf01pd', 'mb3jzp', 'sb04nw', 'sb16cy', 'mb01pd']\n", + "['mb04kd', 'nf01bs', 'mb04ow', 'ud01bd', 'tb01nd', 'sb08nd']\n", + "['mb04wp', 'ma02cd', 'tg01od', 'sb04mw', 'mc01rd', 'fb01vd']\n", + "['mb04yw', 'mb01uz', 'mb01rd', 'ud01md', 'mb01ld', 'md03bf']\n", + "['tb01uy', 'fb01rd', 'mb01ot', 'ab01od', 'mb03ag', 'mb03ai']\n", + "['sb10md', 'mb03pd', 'mb01ux', 'mb01xy', 'mc01vd', 'mb04py']\n", + "['mb03rx', 'ma02pz', 'tg01hu', 'mb02wd', 'sb09md', 'sb03my']\n", + "['ma02jd', 'ab05od', 'mb04pb', 'mb03id', 'tf01od', 'mb04jd']\n", + "['ab08ny', 'nf01bx', 'mb03ny', 'tb03ay', 'tb04bv', 'ma02id']\n", + "['sb10qd', 'tg01dd', 'mb03rz', 'sb03qy', 'bd02ad', 'mc01qd']\n", + "['tb01iz', 'mc03ny', 'ma02ed', 'mb02kd', 'tg01ly', 'ab05rd']\n", + "['ab08nx', 'mb02dd', 'mb03xu', 'ma02nz', 'mb04md', 'mb04tu']\n", + "['sb02ru', 'ab09fd', 'mb02xd', 'sb08gd', 'ab05sd', 'mb03dd']\n", + "['ib01nd', 'mb03oy', 'ma02fd', 'ib01od', 'bb03ad', 'mb03ld']\n", + "['ib01py', 'mb04nd', 'tg01jd', 'mb04tv', 'mc01sx', 'tf01mx']\n", + "['mb3lzp', 'sb10td', 'sb10zp', 'nf01ad', 'sb02mu', 'tg01hy']\n", + "['tg01wd', 'mb04ld', 'mb02ud', 'mb04pa', 'mb04tw', 'mb03bc']\n", + "['tb01xz', 'tb01px', 'tg01fz', 'sb04qy', 'sb03td', 'mb04gd']\n", + "['dg01md', 'mb03lf', 'nf01br', 'md03bd', 'mb04rb', 'sb03ov']\n", + "['sb03pd', 'mb01oh', 'sb03os', 'ab13ad', 'mb03bz', 'mb01uy']\n", + "['ib01pd', 'sb04qr', 'mb4dbz', 'tf01my', 'sb03qx', 'ab05pd']\n", + "['sb04rw', 'ab08nw', 'mb03qx', 'mb01oe', 'mb01yd', 'tg01oz']\n", + "['mb02ny', 'ma02dd', 'sb03sy', 'mb04tb', 'sb04py', 'mb03ya']\n", + "['sb16ay', 'mb04id', 'ib01my', 'ma02ez', 'sb10vd', 'sb16bd']\n", + "['mb01rx', 'ab13dx', 'mc01sd', 'mb04fd', 'mb03jp', 'mb04qf']\n", + "['ma01ad', 'mb01os', 'mc01py', 'ag07bd', 'mb03ts', 'mc01od']\n", + "['mb05od', 'sg03ax', 'mb02jd', 'tb01kx', 'tb01md', 'sb03ou']\n", + "['mb03bf', 'sb02nd', 'sb02mw', 'sb04ry', 'mb04wr', 'sg03bz']\n", + "['sb04nv', 'sb03mx', 'bb02ad', 'mb04yd', 'mb03py', 'mb4dlz']\n", + "['fb01td', 'sb04px', 'mb03hd', 'ma02mz', 'mb04tt', 'mb04qs']\n", + "['mb01md', 'ud01nd', 'mb03yd', 'mc01md', 'de01pd', 'mb03ry']\n", + "['ma02hd', 'ab09kx', 'sg03br', 'tb04cd', 'mb4dpz', 'mb04ud']\n", + "['ib01md', 'mb03yt', 'mb03cz', 'tg01oa', 'nf01bv', 'nf01bd']\n", + "['ib01ad', 'mb02cy', 'mc01pd', 'sb10ud', 'sg03bs', 'tg01jy']\n", + "['td03ay', 'mb02nd', 'sb03sx', 'mb01rb', 'ab01md', 'mb03gd']\n", + "['mb04su', 'sb08hd', 'sg03bx', 'sb02pd', 'mb04bp', 'mb03af']\n", + "['mb05my', 'mb03gz', 'mb02id', 'sb04od', 'ma02bd', 'mb04dp']\n", + "['nf01by', 'mb03kc', 'mb04ox', 'mc01nd', 'dg01od', 'sb02ov']\n", + "['sb10yd', 'sg02nd', 'mb02td', 'ab13ax', 'ab09jv', 'ma02oz']\n", + "['fd01ad', 'tb04bx', 'ag08bz', 'mb04dl', 'mb02hd', 'sb04nd']\n", + "['sg02cx', 'ab13id', 'mc01sw', 'mb01ss', 'sg03bt', 'mb3oyz']\n", + "['sb16ad', 'mb02cx', 'tb01xd', 'tb01vd', 'ma02md', 'mb04xd']\n", + "['md03bb', 'mb04ds', 'mb01sd', 'mb02uw', 'mb04ts', 'mb02md']\n", + "['mb04tx', 'mb02sd', 'dg01ny', 'sb06nd', 'sb08fd', 'mc01sy']\n", + "['ab09cd', 'ab07md', 'mb04db', 'mb03ad', 'ud01mz', 'mb03qd']\n", + "['tf01qd', 'ab13cd', 'mb03bd', 'ag08bd', 'ma02bz', 'mb03ah']\n", + "['ma02jz', 'md03by', 'df01md', 'td03ad', 'sb10ld', 'ue01md']\n", + "['sb08ny', 'ag08by', 'sb02mr', 'mb04ty', 'mb03cd', 'sb08md']\n", + "['mb04cd', 'sb04ow', 'mb03qv', 'mb03my', 'mb04ru', 'mb02rz']\n", + "['sb02sd', 'mb04hd', 'mb04dd', 'mb01ru', 'sb02rd', 'mb01ry']\n", + "['mb01xd']\n", "None\n", "\n", "\n" @@ -408,47 +372,173 @@ } ], "source": [ + "not_in_slicot = list(set(slycot_routines)- set(slicot_routines))\n", + "not_in_slicot\n", "\n", - "intersection = list(set(slicot_routines) & set(slycot_routines))\n", - "intersection\n", + "print(f\"There are currently {len(not_in_slicot)} routines that are found in slycot and not in slicot.\")\n", + "print(\"------\")\n", + "print(print_list_chunks(not_in_slicot))\n", + "print(\"\\n\")\n", + "\n", + "not_in_slycot = list(set(slicot_routines) - set(slycot_routines))\n", + "not_in_slycot\n", "\n", - "print(f\"Currently there are {len(intersection)} routines which are found in slicot and slycot.\")\n", + "print(f\"There are currently {len(not_in_slycot)} routines that are found in slicot and not in slycot.\")\n", "print(\"------\")\n", - "print(print_list_chunks(intersection))\n", + "print(print_list_chunks(not_in_slycot))\n", "print(\"\\n\")" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Currently there are 1 routines which are found in slicot and slycot.\n", + "There are currently 608 routines that are found in slicot or in slycot. (union)\n", "------\n", - "['sb03md57']\n", + "['mb03od', 'tb04bw', 'mb03qy', 'tc05ad', 'mb04pu', 'ab08nd']\n", + "['ab08md', 'ab09jw', 'sb04rx', 'ma02iz', 'sg03bu', 'tg01gd']\n", + "['sb03od', 'ab09ed', 'mb01zd', 'sb02oy', 'mb04iz', 'sb10rd']\n", + "['mb01wd', 'sb10pd', 'sb02ox', 'mb03hz', 'mb03bb', 'tb04bd']\n", + "['tg01ob', 'tg01md', 'sb01fy', 'mb02uu', 'ab07nd', 'sb01md']\n", + "['mb03lp', 'tg01hd', 'tb01wd', 'mb02cd', 'ma02hz', 'sb10kd']\n", + "['mb04dz', 'mb03za', 'mb04iy', 'sb02ow', 'ab09hx', 'sb03qd']\n", + "['tg01az', 'sb08my', 'sb03mv', 'sb02mv', 'mb03rw', 'mb03fz']\n", + "['dg01nd', 'ma02cz', 'sb03sd', 'mb05nd', 'ma02gd', 'mc01wd']\n", + "['ab05qd', 'sb01by', 'sb03mw', 'mb03vw', 'mb03kd', 'sb03oy']\n", + "['ib01qd', 'tf01rd', 'mb02uv', 'mb01vd', 'md03ba', 'ma01cd']\n", + "['tg01ld', 'sb04ny', 'mb03xd', 'ab09cx', 'mb04qb', 'mb03ka']\n", + "['mb04qc', 'mb04az', 'sb03ud', 'mb03iz', 'mb04di', 'sb04md']\n", + "['mb01uw', 'sg03bd', 'mc03nx', 'mb01kd', 'sb04my', 'mb03ae']\n", + "['mb01oc', 'mb02fd', 'mb02sz', 'tb01kd', 'tg01ad', 'ib01oy']\n", + "['mb04wd', 'tg01cd', 'mb01oo', 'tg01qd', 'tb01ty', 'tb01yd']\n", + "['sb02qd', 'tg01id', 'mb04bd', 'tb01ld', 'tb01td', 'tg01nd']\n", + "['tb05ad', 'sb03or', 'ab09hy', 'nf01bq', 'mb02rd', 'tg01ed']\n", + "['ma02od', 'ib01cd', 'mb03ke', 'nf01bw', 'mb02qy', 'ab09md']\n", + "['md03bx', 'mb04vd', 'mb04ny', 'sb02mx', 'ab8nxz', 'mb04ad']\n", + "['tg01kz', 'tg01fd', 'mc03nd', 'mb03jd', 'mb01rw', 'sb08cd']\n", + "['mb02tz', 'mb02od', 'mb02gd', 'mb02yd', 'nf01be', 'ab13dd']\n", + "['sb03oz', 'sb04qd', 'mb03qw', 'sg03bw', 'ud01dd', 'mb03md']\n", + "['mc01xd', 'sb10jd', 'nf01bp', 'ma02es', 'sb02ms', 'mb04fp']\n", + "['fb01sd', 'ma02az', 'mb03xs', 'mb02ed', 'mb04vx', 'mb01td']\n", + "['ib01bd', 'mb04xy', 'mb03lz', 'sb04nx', 'ma02ad', 'td04ad']\n", + "['sg03ay', 'tg01hx', 'sb04mu', 'mb04dy', 'ab04md', 'mb01rt']\n", + "['ab09id', 'tb04ay', 'sb08dd', 'sb03ot', 'nf01bu', 'mb03xz']\n", + "['sb10id', 'sb04rv', 'ma02gz', 'mb03ud', 'mb04bz', 'tg01pd']\n", + "['mb05md', 'tf01md', 'mb03wa', 'mb03ed', 'mb03be', 'sg02cw']\n", + "['sb10wd', 'mc03md', 'mb01ud', 'sg02ad', 'nf01bb', 'sb03mu']\n", + "['ab09hd', 'ab09iy', 'mb04od', 'sb04mr', 'mb04qu', 'sb03md']\n", + "['ib01px', 'td05ad', 'nf01ay', 'mb3pyz', 'mb03bg', 'mb03xp']\n", + "['mb03zd', 'dk01md', 'sg02cv', 'ud01cd', 'mb03sd', 'tb01ux']\n", + "['tf01nd', 'sb02cx', 'sb10sd', 'mb03qg', 'sb10zd', 'mb01rh']\n", + "['mb03nd', 'tb01vy', 'ib03bd', 'de01od', 'mb01nd', 'ib01rd']\n", + "['mb02cu', 'mb03jz', 'mb02pd', 'ab09ix', 'mb03fd', 'mb03kb']\n", + "['mb04zd', 'mb04ed', 'ag8byz', 'ib03ad', 'sb04rd', 'mb01od']\n", + "['mb02qd', 'bb04ad', 'ab08mz', 'fb01qd', 'ab09bx', 'bb01ad']\n", + "['mb03wx', 'sb01dd', 'mb01qd', 'ab09gd', 'tb04ad', 'sb04pd']\n", + "['mb03dz', 'ab09jd', 'sb02ou', 'ab09kd', 'mb02jx', 'ma02pd']\n", + "['sb03md57', 'mb04wu', 'ab09dd', 'sb01bx', 'ab13bd', 'sb03rd']\n", + "['nf01ba', 'tg01nx', 'sb16cd', 'mb05oy', 'sb04qu', 'tb01zd']\n", + "['tb01wx', 'tb01ud', 'bd01ad', 'sb08ed', 'sg03bv', 'ma01bz']\n", + "['mb02vd', 'mb02cv', 'sb10ed', 'mb03ba', 'sb10fd', 'nf01bf']\n", + "['mb04oy', 'md03ad', 'ma01bd', 'mb03ab', 'tg01bd', 'mb03td']\n", + "['ab09jx', 'sg03by', 'tg01kd', 'ab09nd', 'tf01pd', 'mb3jzp']\n", + "['sb04nw', 'sb16cy', 'tc04ad', 'mb01pd', 'mb04kd', 'nf01bs']\n", + "['mb03wd', 'mb04ow', 'ud01bd', 'tb01nd', 'sb08nd', 'mb04wp']\n", + "['ma02cd', 'tg01od', 'sb04mw', 'mc01rd', 'fb01vd', 'mb04yw']\n", + "['mb01uz', 'mb01rd', 'ud01md', 'mb01ld', 'md03bf', 'tb01pd']\n", + "['tb01uy', 'fb01rd', 'mb01ot', 'ab01od', 'mb03ag', 'sb01bd']\n", + "['mb03ai', 'sb10md', 'sb10dd', 'mb03pd', 'mb01ux', 'mb01xy']\n", + "['mc01vd', 'ab01nd', 'mb04py', 'mb03rx', 'ma02pz', 'tg01hu']\n", + "['mb02wd', 'ab13fd', 'sb09md', 'sb03my', 'ma02jd', 'ab05od']\n", + "['mb04pb', 'mb03id', 'tf01od', 'mb04jd', 'ab08ny', 'nf01bx']\n", + "['mb03ny', 'tb03ay', 'tb04bv', 'ma02id', 'sb10qd', 'tg01dd']\n", + "['mb03rz', 'sb03qy', 'bd02ad', 'ab05md', 'mc01qd', 'mc01td']\n", + "['tb01iz', 'mc03ny', 'ma02ed', 'mb02kd', 'tg01ly', 'ab05rd']\n", + "['ab08nz', 'ab08nx', 'mb02dd', 'mb03xu', 'ma02nz', 'mb04md']\n", + "['mb04tu', 'sb02ru', 'ab09fd', 'mb02xd', 'sb08gd', 'ab05sd']\n", + "['mb03dd', 'ib01nd', 'ab09ax', 'sb10ad', 'mb03oy', 'ma02fd']\n", + "['ib01od', 'bb03ad', 'mb03ld', 'ib01py', 'mb04nd', 'tg01jd']\n", + "['mb04tv', 'mc01sx', 'tf01mx', 'mb3lzp', 'ab13md', 'sb10td']\n", + "['sb10zp', 'nf01ad', 'sb02mu', 'tg01hy', 'tg01wd', 'mb04ld']\n", + "['mb02ud', 'mb04pa', 'mb04tw', 'mb03bc', 'tb01xz', 'tb01px']\n", + "['tg01fz', 'sb04qy', 'sb03td', 'mb04gd', 'dg01md', 'mb03lf']\n", + "['nf01br', 'md03bd', 'mb04rb', 'sb03ov', 'sb03pd', 'mb01oh']\n", + "['sb03os', 'ab13ad', 'mb03bz', 'mb01uy', 'ib01pd', 'sb04qr']\n", + "['mb4dbz', 'tf01my', 'sb03qx', 'ab05pd', 'sb04rw', 'ab08nw']\n", + "['mb03qx', 'mb01oe', 'mb01yd', 'tg01oz', 'mb02ny', 'ma02dd']\n", + "['sb03sy', 'mb04tb', 'sb04py', 'mb03ya', 'sb16ay', 'mb04id']\n", + "['ib01my', 'ma02ez', 'sb10vd', 'sb16bd', 'mb01rx', 'ab13dx']\n", + "['mc01sd', 'mb04fd', 'mb03jp', 'ab05nd', 'mb04qf', 'ma01ad']\n", + "['mb01os', 'mc01py', 'ag07bd', 'mb03ts', 'mc01od', 'mb05od']\n", + "['sg03ax', 'mb02jd', 'tb01kx', 'tb01md', 'sb03ou', 'mb03bf']\n", + "['sb02nd', 'sb02mw', 'sb04ry', 'mb04wr', 'sg03bz', 'sb04nv']\n", + "['sb03mx', 'sb02mt', 'bb02ad', 'mb04yd', 'sb02md', 'mb03py']\n", + "['mb4dlz', 'fb01td', 'sb04px', 'mb03hd', 'ma02mz', 'mb04tt']\n", + "['mb04qs', 'mb01md', 'ud01nd', 'mb03yd', 'mc01md', 'de01pd']\n", + "['mb03ry', 'ma02hd', 'ab09kx', 'sg03br', 'tb04cd', 'mb4dpz']\n", + "['mb04ud', 'ib01md', 'mb03yt', 'mb03cz', 'tg01oa', 'nf01bv']\n", + "['nf01bd', 'ib01ad', 'mb02cy', 'ab09ad', 'mc01pd', 'sb10ud']\n", + "['sg03bs', 'tg01jy', 'td03ay', 'mb02nd', 'sb03sx', 'mb01rb']\n", + "['ab01md', 'mb03gd', 'mb04su', 'mb03rd', 'sb08hd', 'sg03bx']\n", + "['sb02pd', 'mb04bp', 'mb03af', 'mb05my', 'mb03gz', 'mb02id']\n", + "['sb04od', 'ma02bd', 'mb04dp', 'nf01by', 'mb03kc', 'mb04ox']\n", + "['mc01nd', 'dg01od', 'sb02ov', 'sb10yd', 'sb02od', 'sg02nd']\n", + "['mb02td', 'ab13ax', 'ab09jv', 'ma02oz', 'fd01ad', 'tb04bx']\n", + "['ag08bz', 'mb04dl', 'mb02hd', 'sb04nd', 'sg02cx', 'ab13id']\n", + "['tb01id', 'mc01sw', 'mb01ss', 'sg03bt', 'mb3oyz', 'sb16ad']\n", + "['mb02cx', 'sb10hd', 'tb01xd', 'ab13ed', 'sg03ad', 'tb01vd']\n", + "['ma02md', 'mb04xd', 'md03bb', 'mb04ds', 'mb01sd', 'mb02uw']\n", + "['mb04ts', 'mb02md', 'mb04tx', 'mb02sd', 'dg01ny', 'mb03vy']\n", + "['sb06nd', 'sb08fd', 'mc01sy', 'ab09cd', 'ab07md', 'mb04db']\n", + "['mb03ad', 'ud01mz', 'mb03qd', 'tf01qd', 'ab13cd', 'mb03bd']\n", + "['ag08bd', 'ma02bz', 'mb03ah', 'ma02jz', 'md03by', 'df01md']\n", + "['td03ad', 'sb10ld', 'ue01md', 'tb03ad', 'sb08ny', 'ag08by']\n", + "['sb02mr', 'mb04ty', 'mb03cd', 'sb08md', 'mb04cd', 'sb04ow']\n", + "['mb03qv', 'mb03my', 'tc01od', 'mb04ru', 'mb02rz', 'sb02sd']\n", + "['mb04hd', 'mb04dd', 'ab09bd', 'mb01ru', 'sb02rd', 'mb01ry']\n", + "['mb03vd', 'mb01xd']\n", "None\n", "\n", - "\n" + "\n", + "There are currently 48 routines that are found in slicot and slycot. (intersection)\n", + "------\n", + "['ab09nd', 'ab13md', 'sb04md', 'sg03bd', 'mb03rd', 'ab01nd']\n", + "['ab09md', 'mc01td', 'tc04ad', 'td04ad', 'sb03md', 'tb01id']\n", + "['tb04ad', 'mb03wd', 'ab08nd', 'mb05nd', 'ab13fd', 'mb03vd']\n", + "['ab08nz', 'sb03od', 'ab13bd', 'tb03ad', 'sb10hd', 'ab13dd']\n", + "['ab05nd', 'ab13ed', 'sb04qd', 'sg03ad', 'tf01rd', 'sb02md']\n", + "['ab07nd', 'tb01pd', 'tc01od', 'ab09ad', 'ab09ax', 'sb10ad']\n", + "['sb02od', 'mb05md', 'tf01md', 'ab09bd', 'sb01bd', 'mb03vy']\n", + "['sb10fd', 'tb05ad', 'sb02mt', 'sb10dd', 'ab05md', 'sg02ad']\n", + "None\n" ] } ], "source": [ - "not_in_slicot = list(set(slycot_routines)- set(slicot_routines))\n", - "not_in_slicot\n", + "union = list(set(slicot_routines) | set(slycot_routines))\n", "\n", - "print(f\"Currently there are {len(not_in_slicot)} routines which are found in slicot and slycot.\")\n", + "print(f\"There are currently {len(union)} routines that are found in slicot or in slycot. (union)\")\n", "print(\"------\")\n", - "print(print_list_chunks(not_in_slicot))\n", - "print(\"\\n\")" + "print(print_list_chunks(union))\n", + "print(\"\\n\")\n", + "\n", + "\n", + "intersection = list(set(slicot_routines) & set(slycot_routines))\n", + "intersection\n", + "\n", + "print(f\"There are currently {len(intersection)} routines that are found in slicot and slycot. (intersection)\")\n", + "print(\"------\")\n", + "print(print_list_chunks(intersection))" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -545,7 +635,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 64, "metadata": {}, "outputs": [ {