Examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some brief examples on using array_to_latex to get nicely formatted latex versions of your arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import array_to_latex as a2l\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create an array and output it as $\\LaTeX$. We are going to use [Python 3.0 string formatting](https://docs.python.org/3.7/library/string.html) \n",
    "\n",
    "The following shows a float style output with 2 decimal places. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "  1.23 + 0.00j &  23.46 + 0.00j\\\\\n",
      "  456.23 + 1.00j &  8.24 + 0.00j\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1.23456, 23.45678],[456.23+1j, 8.239521]])\n",
    "a2l.to_ltx(A, frmt = '{:.2f}', arraytype = 'bmatrix', mathform = True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Design is to print results to the screen with no output being available. However, new usages have highlighted the need to enable outputs and hide printing. Thus the addition of the ``print_out`` boolean to turn off printing but instead return an output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1.23456, 23.45678],[456.23+1j, 8.239521]])\n",
    "latex_code = a2l.to_ltx(A, frmt = '{:.2f}', arraytype = 'bmatrix', mathform = True, print_out=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can still print the returned formatted latex code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "  1.23 + 0.00j &  23.46 + 0.00j\\\\\n",
      "  456.23 + 1.00j &  8.24 + 0.00j\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "print(latex_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can use a number before the decimal place. This defines the minimum width to use for the number, padding with spaces at the beginning. \n",
    "\n",
    "Since the largest number needs 6 characters (3 before the decimal, the decimal, and 2 after), putting a 6 in this location makes everything line up nicely. This would also be a nice default to code up. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "    1.23 +   0.00j &   23.46 +   0.00j\\\\\n",
      "  456.23 +   1.00j &    8.24 +   0.00j\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1.23456, 23.45678],[456.23+1j, 8.239521]])\n",
    "a2l.to_ltx(A, frmt = '{:6.2f}', arraytype = 'bmatrix', mathform = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's put it in exponential form. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "  1.23e+00 + 0.00e+00j &  2.35e+01 + 0.00e+00j\\\\\n",
      "  4.56e+02 + 1.00e+00j &  8.24e+00 + 0.00e+00j\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "a2l.to_ltx(A, frmt = '{:.2e}', arraytype = 'bmatrix', mathform=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's not how humans/textbooks write exponential form. Let's use `mathform=True` (which is the default). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "  1.23\\times 10^{+00} + 0.00\\times 10^{+00}j &  2.35\\times 10^{+01} + 0.00\\times 10^{+00}j\\\\\n",
      "  4.56\\times 10^{+02} + 1.00\\times 10^{+00}j &  8.24\\times 10^{+00} + 0.00\\times 10^{+00}j\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "a2l.to_ltx(A, frmt = '{:6.2e}', arraytype = 'bmatrix', mathform=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's easier to make these columns line up than when using `f` format styling- so I believe it is working. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, the typeset $\\LaTeX$ will look better than the raw $\\LaTeX$.\n",
    "\n",
    "One can also capture the string in the output. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It will also do column and row-vectors. It's the array is 1-D, the default is a row. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "    1.23 &   23.46 &  456.23 &    8.24\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1.23456, 23.45678, 456.23, 8.239521])\n",
    "a2l.to_ltx(A, frmt = '{:6.2f}', arraytype = 'bmatrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "    1.23 &   23.46 &  456.23 &    8.24\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1.23456, 23.45678, 456.23, 8.239521]])\n",
    "a2l.to_ltx(A, frmt='{:6.2f}', arraytype='bmatrix')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "    1.23\\\\\n",
      "   23.46\\\\\n",
      "  456.23\\\\\n",
      "    8.24\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1.23456, 23.45678, 456.23, 8.239521]]).T\n",
    "a2l.to_ltx(A, frmt='{:6.2f}', arraytype='bmatrix')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to plot a few nods or points in latex using tizk, like\n",
    "```latex\n",
    "\\documentclass{standalone}\n",
    "\\usepackage{pgfplots}\n",
    "\\begin{document}\n",
    "\\begin{tikzpicture}\n",
    "  \\foreach \\Point in \n",
    "  {(0.23,2.46),(1.23,2.24)}\n",
    "  {\\node at \\Point {$\\circ$};}\n",
    "\\end{tikzpicture}\n",
    "\\end{document}\n",
    "```\n",
    "you may want to output a list of coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(0.23,2.46),(1.23,2.24)}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[0.23456, 2.45678],[1.23, 2.239521]])\n",
    "a2l.to_ltx(A, frmt='{:1.2f}', arraytype='coords')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the `lambda` function method to create a function with personalized defaults. This makes for a much more compact call, and one that can be adjusted for an entire session.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "  2.35\\times 10^{-01} &  2.46\\times 10^{+00}\\\\\n",
      "  1.23\\times 10^{+00} &  2.24\\times 10^{+00}\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "def to_tex(A): return a2l.to_ltx(\n",
    "    A, frmt='{:6.2e}', arraytype='bmatrix', mathform=True)\n",
    "to_tex(A)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      "    0.23 &    2.46\\\\\n",
      "    1.23 &    2.24\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "def to_tex(A): return a2l.to_ltx(\n",
    "    A, frmt='{:6.2f}', arraytype='bmatrix', mathform=True)\n",
    "to_tex(A)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Panda DataFrames\n",
    "\n",
    "You can also produce tables or math arrays from Panda DataFrames.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(np.random.randint(low=0, high=10, size=(5, 5)),\n",
    "...                    columns=['a', 'b', 'c', 'd', 'e'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8</td>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b  c  d  e\n",
       "0  5  1  8  3  2\n",
       "1  8  4  8  9  6\n",
       "2  2  9  6  8  9\n",
       "3  7  5  6  2  1\n",
       "4  7  2  4  3  3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 1, 8, 3, 2],\n",
       "       [8, 4, 8, 9, 6],\n",
       "       [2, 9, 6, 8, 9],\n",
       "       [7, 5, 6, 2, 1],\n",
       "       [7, 2, 4, 3, 3]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{bmatrix}\n",
      " 0 &  5.00 &  1.00 &  8.00 &  3.00 &  2.00\\\\\n",
      " 1 &  8.00 &  4.00 &  8.00 &  9.00 &  6.00\\\\\n",
      " 2 &  2.00 &  9.00 &  6.00 &  8.00 &  9.00\\\\\n",
      " 3 &  7.00 &  5.00 &  6.00 &  2.00 &  1.00\\\\\n",
      " 4 &  7.00 &  2.00 &  4.00 &  3.00 &  3.00\n",
      "\\end{bmatrix}\n"
     ]
    }
   ],
   "source": [
    "a2l.to_ltx(df, arraytype='bmatrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{lrrrrr}\n",
      "\\toprule\n",
      "     & a & b & c & d & e \\\\\\n\\midrule\n",
      " 0 &  5.00 &  1.00 &  8.00 &  3.00 &  2.00\\\\\n",
      " 1 &  8.00 &  4.00 &  8.00 &  9.00 &  6.00\\\\\n",
      " 2 &  2.00 &  9.00 &  6.00 &  8.00 &  9.00\\\\\n",
      " 3 &  7.00 &  5.00 &  6.00 &  2.00 &  1.00\\\\\n",
      " 4 &  7.00 &  2.00 &  4.00 &  3.00 &  3.00\\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n"
     ]
    }
   ],
   "source": [
    "a2l.to_ltx(df, arraytype='tabular')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pets</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cat</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>dog</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>bird</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>snake</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>honey badger</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           pets\n",
       "0           cat\n",
       "1           dog\n",
       "2          bird\n",
       "3         snake\n",
       "4  honey badger"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = pd.DataFrame(['cat', 'dog', 'bird', 'snake', 'honey badger'], columns=['pets'])\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "      <th>e</th>\n",
       "      <th>pets</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>cat</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8</td>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>6</td>\n",
       "      <td>dog</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>bird</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>snake</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>honey badger</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b  c  d  e          pets\n",
       "0  5  1  8  3  2           cat\n",
       "1  8  4  8  9  6           dog\n",
       "2  2  9  6  8  9          bird\n",
       "3  7  5  6  2  1         snake\n",
       "4  7  2  4  3  3  honey badger"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_mixed = df.join(df2)\n",
    "df_mixed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{lrrrrrr}\n",
      "\\toprule\n",
      "     & a & b & c & d & e & pets \\\\\\n\\midrule\n",
      " 0 &  5.00 &  1.00 &  8.00 &  3.00 &  2.00 &  cat         \\\\\n",
      " 1 &  8.00 &  4.00 &  8.00 &  9.00 &  6.00 &  dog         \\\\\n",
      " 2 &  2.00 &  9.00 &  6.00 &  8.00 &  9.00 &  bird        \\\\\n",
      " 3 &  7.00 &  5.00 &  6.00 &  2.00 &  1.00 &  snake       \\\\\n",
      " 4 &  7.00 &  2.00 &  4.00 &  3.00 &  3.00 &  honey badger\\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n"
     ]
    }
   ],
   "source": [
    "a2l.to_ltx(df_mixed, arraytype='tabular')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{array}{ c, c}\n",
      "    1.23 &   23.46\\\\\n",
      "  456.23 &    8.24\n",
      "\\end{array}\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1.23456, 23.45678],[456.23, 8.239521]])\n",
    "a2l.to_ltx(A, frmt = '{:6.2f}', arraytype = 'array')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1.23456, 23.45678],[456.72+392.71j, 8.239521]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "8264b34d39e23030c6fea90141f98fb73263e8f59eb03375f5597f19271b8965"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}