{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Síntesis de funciones de excitación RC-RL\n",
"![](\"./img/logo_UTN.svg\")
\n",
"\n",
"#### Por Mariano Llamedo Soria"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Resumen \n",
"Se presentan los métodos de Foster y Cauer para la síntesis de redes no disipativas. Ambos métodos nos permitirán implementar cualquier función de excitación, real y positiva (FRP), en una red eléctrica canónica, es decir, con la menor cantidad posible de componentes.\n",
"\n",
"* Dibujo de redes: [dibujar_cauer_RC_RL](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_cauer_RC_RL), [dibujar_foster_derivacion](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_foster_derivacion), [dibujar_foster_serie](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_foster_serie)\n",
"* Funciones de síntesis de dipolos: [cauer_RC](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/sintesis_dipolo/index.html#pytc2.sintesis_dipolo.cauer_RC), [foster](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/sintesis_dipolo/index.html#pytc2.sintesis_dipolo.foster), [foster_zRC2yRC](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/sintesis_dipolo/index.html#pytc2.sintesis_dipolo.foster_zRC2yRC)\n",
"* Funciones para presentación de markdown y latex: [print_subtitle](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/general/index.html#pytc2.general.print_subtitle), [print_latex](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/general/index.html#pytc2.general.print_latex), [a_equal_b_latex_s](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/general/index.html#pytc2.general.a_equal_b_latex_s)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Introducción a las funciones de excitación RC-RL\n",
"\n",
"Se extiende ahora el estudio a las funciones de excitación (FE) compuestas **solamente** por dos elementos, siendo uno de ellos necesariamente disipativo. Esto significa redes RC ó RL, cuya inmitancia seguirá siendo $F(s)$. En este documento se analizan solo las redes RC, ya que han tenido mayor importancia tecnológica, pero las RL pueden comprenderse mediante las siguientes dualidad:\n",
"\n",
"* $Z_{RC} \\sim Y_{RL}$\n",
"* $Y_{RC} \\sim Z_{RL}$\n",
"\n",
"es decir que se puede pensar en una $Z_{RC}$ *a la Foster*\n",
"\n",
"$$ Z_{RC}(s)= \\frac{k_0}{s} + k_K + \\sum_{i=1}^N\\frac{k_i}{s+\\sigma_i} $$\n",
"\n",
"o una $Y_{RC}$\n",
"\n",
"$$ Y_{RC}(s)= k_K + s. k_\\infty + \\sum_{i=1}^N\\frac{k_i.s}{s+\\sigma_i} $$\n",
"\n",
"dichas expresiones tienen implicancias circuitales que conviene tenerlas presentes antes de continuar con los siguientes ejemplos. Como aspecto distintivo notar que:\n",
"\n",
"* $ Z_{RC}(s) $ no tendrá residuo $k_\\infty$\n",
"* $ Y_{RC}(s) $ no tendrá residuo $k_0$\n",
"\n",
"al realizar la expansión en *fracciones simples*. Se refiere al lector interesado al cap. 4 del libro de Araujo *Síntesis de redes lineales*, o al cap. 11 de *Network Synthesis* de Franklin Kuo, donde podrán comprender todas las implicancias de éstas funciones.\n",
"\n",
"La expansión en *fracciones continuas*, es decir al aplicar el método de Cauer, también dará lugar a redes escalera (al igual que en las FE **NO** disipativas) como pronto se mostrará.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"\n",
"import sympy as sp\n",
"\n",
"# Ahora importamos las funciones de PyTC2\n",
"\n",
"from pytc2.sintesis_dipolo import cauer_RC, foster, foster_zRC2yRC\n",
"from pytc2.dibujar import dibujar_cauer_RC_RL, dibujar_foster_derivacion, dibujar_foster_serie\n",
"from pytc2.general import print_latex, print_subtitle, a_equal_b_latex_s\n",
"from IPython.display import display, Markdown\n",
"\n",
"# Importante importar símbolos de variables \n",
"from pytc2.general import s\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Funciones con las que trabajaremos"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RC}(s)=\\frac{s^{2} + 4 s + 3}{s^{2} + 2 s}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RC}(s)=\\frac{2 s^{2} + 8 s + 6}{s^{2} + 8 s + 12}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"\n",
"# Sea la siguiente función de excitación\n",
"ZRC = (s**2 + 4*s + 3)/(s**2 + 2*s)\n",
"YRC = 2*(s**2 + 4*s + 3)/(s**2 + 8*s + 12)\n",
"\n",
"print_subtitle('Funciones con las que trabajaremos')\n",
"\n",
"print_latex(a_equal_b_latex_s('Z_{RC}(s)', ZRC))\n",
"print_latex(a_equal_b_latex_s('Y_{RC}(s)', YRC))\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Expansión Foster de $Z_{RC}$ "
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RC}(s)=\\frac{s^{2} + 4 s + 3}{s^{2} + 2 s}=1 + \\frac{1}{2 \\left(s + 2\\right)} + \\frac{3}{2 s}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_0=\\frac{3}{2}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_1 = \\left[ \\frac{1}{ k_k + s. k_\\infty } \\right] = \\\n",
" \\left[ \\frac{1}{ \\frac{\\sigma_1}{k_1} + s. \\frac{1}{k_i} } \\right] = \\\n",
" \\left[ k_k, k_\\infty \\right] = \\\n",
" \\left[ \\\n",
" \\left[ \\frac{\\sigma_1}{k_1}, \\frac{1}{k_1} \\right] \\\n",
" \\right]=\\left[ \\left[ 4, \\ 2\\right]\\right]$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_k=1$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Se expande ZRC a la Foster\n",
"k0, koo, ki_wi, kk, ZRC_foster = foster(ZRC)\n",
"\n",
"print_subtitle('Expansión Foster de $Z_{RC}$ ')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('Z_{RC}(s)', ZRC)[1:-1], ZRC_foster ))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_0', k0))\n",
"\n",
"print_latex(a_equal_b_latex_s(r'k_1 = \\left[ \\frac{1}{ k_k + s. k_\\infty } \\right] = \\\n",
" \\left[ \\frac{1}{ \\frac{\\sigma_1}{k_1} + s. \\frac{1}{k_i} } \\right] = \\\n",
" \\left[ k_k, k_\\infty \\right] = \\\n",
" \\left[ \\\n",
" \\left[ \\frac{\\sigma_1}{k_1}, \\frac{1}{k_1} \\right] \\\n",
" \\right]', ki_wi ))\n",
"\n",
"\n",
"print_latex(a_equal_b_latex_s('k_k', kk))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Implementación circuital $Z_{RC}$ Foster serie"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"print_subtitle('Implementación circuital $Z_{RC}$ Foster serie')\n",
"\n",
"# Tratamos a nuestra función imitancia como una Z\n",
"dibujar_foster_serie(k0 = k0, koo = koo, ki = ki_wi, kk = kk, z_exc = ZRC_foster)\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Expansión Foster de $Y_{RC}$ "
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RC}(s)=\\frac{2 s^{2} + 8 s + 6}{s^{2} + 8 s + 12}=\\frac{5 s}{4 s + 24} + \\frac{s}{4 s + 8} + \\frac{1}{2}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_\\infty=0$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_1 = \\left[ \\frac{1}{ \\frac{k_0}{s} + k_k } \\right] = \\\n",
" \\left[ \\frac{1}{ \\frac{1}{s. \\frac{k_1}{\\sigma_1}} + \\frac{1}{k_1} } \\right] = \\\n",
" \\left[ k_0, k_k \\right] = \\\n",
" \\left[ \\\n",
" \\left[ \\frac{\\sigma_i}{k_i}, \\frac{1}{k_i} \\right] \\\n",
" \\right]=\\left[ \\left[ \\frac{24}{5}, \\ \\frac{4}{5}\\right], \\ \\left[ 8, \\ 4\\right]\\right]$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_k=\\frac{1}{2}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Se expande YRC a la Foster. Notar que se expande YRC/s, como si fuera ZRC. (Ver Kuo 331)\n",
"k0, koo, ki_wi, kk, YRC_foster = foster(YRC/s)\n",
"\n",
"# Luego lo multiplicamos por s para obtener la YRC original.\n",
"k0, koo, ki_wi, kk, YRC_foster = foster_zRC2yRC(k0, koo, ki_wi, kk, YRC_foster)\n",
"\n",
"print_subtitle('Expansión Foster de $Y_{RC}$ ')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('Y_{RC}(s)', YRC)[1:-1], YRC_foster ))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_\\infty', koo))\n",
"\n",
"print_latex(a_equal_b_latex_s(r'k_1 = \\left[ \\frac{1}{ \\frac{k_0}{s} + k_k } \\right] = \\\n",
" \\left[ \\frac{1}{ \\frac{1}{s. \\frac{k_1}{\\sigma_1}} + \\frac{1}{k_1} } \\right] = \\\n",
" \\left[ k_0, k_k \\right] = \\\n",
" \\left[ \\\n",
" \\left[ \\frac{\\sigma_i}{k_i}, \\frac{1}{k_i} \\right] \\\n",
" \\right]', ki_wi ))\n",
"\n",
"\n",
"print_latex(a_equal_b_latex_s('k_k', kk))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Implementación circuital $Y_{RC}$ Foster serie"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"print_subtitle('Implementación circuital $Y_{RC}$ Foster serie')\n",
"\n",
"# Recalculamos\n",
"k0, koo, ki_wi, kk, YRC_foster = foster(YRC/s)\n",
"k0, koo, ki_wi, kk, YRC_foster = foster_zRC2yRC(k0, koo, ki_wi, kk, YRC_foster)\n",
"\n",
"# Tratamos a nuestra función imitancia como una Y\n",
"dibujar_foster_derivacion(k0, koo, ki_wi, kk, y_exc = YRC_foster)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Implementación de FE con inductores\n",
"\n",
"Ahora presentamos las versiones equivalentes de las FE disipativas analizadas hasta ahora"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Implementación circuital $Y_{RC}$ como $Z_{RL}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"print_subtitle('Implementación circuital $Y_{RC}$ como $Z_{RL}$')\n",
"\n",
"# Tratamos a nuestra función imitancia como una Y\n",
"dibujar_foster_serie(k0, koo, ki_wi, kk, z_exc = YRC_foster)\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Implementación circuital $Z_{RC}$ como $Y_{RL}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"print_subtitle('Implementación circuital $Z_{RC}$ como $Y_{RL}$')\n",
"\n",
"k0, koo, ki_wi, kk, ZRC_foster = foster(ZRC)\n",
"\n",
"# Tratamos a nuestra función imitancia como una Y\n",
"dibujar_foster_derivacion(k0, koo, ki_wi, kk, y_exc = ZRC_foster)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Expansión en fracciones continuas: Método de Cauer\n",
"\n",
"Del mismo modo que el método de Foster se sustenta en la expansión en fracciones simples, el de Cauer consiste en la expansión en [fracciones continuas](https://en.wikipedia.org/wiki/Network_synthesis#Cauer_synthesis). En el caso de FE disipativas, se realizará la expansión mediante los residuos $k_0$, $k_\\infty$ y $k_K$, dependiendo si se expande una $Z_{RC}$ o una $Y_{RC}$:\n",
"\n",
"$$ Z_{RC}(s)= \\frac{1}{s.C_1} + \\frac{1}{ \\frac{1}{R_1} + \\frac{1}{ \\frac{1}{s.C_2} + \\cdots } } = \n",
" R_1 + \\frac{1}{ s.C_1 + \\frac{1}{ R_2 + \\cdots } } $$\n",
"\n",
"$$ Y_{RC}(s)= s.C_1 + \\frac{1}{ R_1 + \\frac{1}{ s.C_2 + \\cdots } } = \n",
" \\frac{1}{R_1} + \\frac{1}{ s.C_1 + \\frac{1}{ \\frac{1}{R_2} + \\cdots } } $$\n",
"\n",
"se ve claramente como sendas funciones de inmitancia, se corresponden con 2 redes diferentes, dependiendo dónde se realicen las remociones. Se darán ejemplos en los siguientes paneles.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## Cauer 1: remociones en $\\infty$\n",
"\n",
"Se comienza con la primera forma del método, es decir cuando se realizan remociones de los residuos en infinito."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Implementación escalera de $Z_{RC}$ e $Y_{RL}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RC}(s)=\\frac{s^{2} + 4 s + 3}{s^{2} + 2 s}=1 + \\frac{1}{\\frac{s}{2} + \\frac{1}{4 + \\frac{6}{s}}}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RL}(s)=\\frac{s^{2} + 4 s + 3}{s^{2} + 2 s}=1 + \\frac{1}{\\frac{s}{2} + \\frac{1}{4 + \\frac{6}{s}}}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from pytc2.sintesis_dipolo import cauer_RC\n",
"from pytc2.dibujar import dibujar_cauer_RC_RL\n",
"\n",
"# Implementaremos FF mediante Cauer 1 o remociones continuas en infinito\n",
"koo, ZRC_cauer_oo, rem = cauer_RC(ZRC, remover_en_inf=True)\n",
"\n",
"print_subtitle('Implementación escalera de $Z_{RC}$ e $Y_{RL}$')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('$ Z_{RC}(s)', ZRC)[1:-1], ZRC_cauer_oo ))\n",
"\n",
"# Tratamos a nuestra función inmitancia como una Z\n",
"dibujar_cauer_RC_RL(koo, z_exc = ZRC_cauer_oo)\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('$ Y_{RL}(s)', ZRC)[1:-1], ZRC_cauer_oo ))\n",
"\n",
"# Tratamos a nuestra función inmitancia como una Y\n",
"dibujar_cauer_RC_RL(koo, y_exc = ZRC_cauer_oo)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Se observa, como es de esperarse, que interpretar la inmitancia como impedancia o admitancia utilizando Cauer 1, da lugar a redes **duales**. Sin embargo en ambos casos se observan transferencias pasabajo (respecto a un posible puerto de salida en el extremo derecho de la red), ya que se obtienen inductores en serie y capacitores en derivación.\n",
"\n",
"## Cauer 2: remociones en 0 o DC\n",
"\n",
"Repetimos ahora para remociones de los residuos en 0 Hz, obtendremos dos redes también duales."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Implementación escalera de $Y_{RC}$ y $Z_{RL}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RC}(s)=\\frac{2 s^{2} + 8 s + 6}{s^{2} + 8 s + 12}=\\frac{1}{2} + \\frac{1}{\\frac{1}{\\frac{8}{7} + \\frac{1}{\\frac{14}{5} + \\frac{49}{5 s}}} + \\frac{3}{s}}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RL}(s)=\\frac{2 s^{2} + 8 s + 6}{s^{2} + 8 s + 12}=\\frac{1}{2} + \\frac{1}{\\frac{1}{\\frac{8}{7} + \\frac{1}{\\frac{14}{5} + \\frac{49}{5 s}}} + \\frac{3}{s}}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"\n",
"# Implementaremos FF mediante Cauer 1 o remociones continuas en infinito\n",
"koo, YRC_cauer_oo, rem = cauer_RC(YRC, remover_en_inf=False)\n",
"\n",
"print_subtitle('Implementación escalera de $Y_{RC}$ y $Z_{RL}$')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('$ Y_{RC}(s)', YRC)[1:-1], YRC_cauer_oo ))\n",
"\n",
"# Tratamos a nuestra función inmitancia como una Z\n",
"dibujar_cauer_RC_RL(koo, z_exc = YRC_cauer_oo)\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('$ Z_{RL}(s)', YRC)[1:-1], YRC_cauer_oo ))\n",
"\n",
"# Tratamos a nuestra función inmitancia como una Y\n",
"dibujar_cauer_RC_RL(koo, y_exc = YRC_cauer_oo)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ambas redes duales, tienen características en común como ser que ambas tienen capacitores en serie e inductores en derivación. Esto contrasta con las redes halladas mediante Cauer 1, donde observamos lo contrario: inductores en serie y capacitores en derivación. Está claro que Cauer 1 da lugar a redes que, en caso **que imaginemos un puerto de salida en el extremo derecho de la red**, serían filtros **pasabajo**, mientras que sintetizar una red mediante Cauer 2 da lugar a una red escalera **pasa-altos**.\n"
]
}
],
"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.10.16"
},
"varInspector": {
"cols": {
"lenName": 16,
"lenType": 16,
"lenVar": 40
},
"kernels_config": {
"python": {
"delete_cmd_postfix": "",
"delete_cmd_prefix": "del ",
"library": "var_list.py",
"varRefreshCmd": "print(var_dic_list())"
},
"r": {
"delete_cmd_postfix": ") ",
"delete_cmd_prefix": "rm(",
"library": "var_list.r",
"varRefreshCmd": "cat(var_dic_list()) "
}
},
"types_to_exclude": [
"module",
"function",
"builtin_function_or_method",
"instance",
"_Feature"
],
"window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 4
}