Ir al contenido principal

Using MikTex with LaTeX Workshop on Windows

This is a post to mention how to setup Visual Studio Code for LaTeX—through the LaTeX Workshop extension.

In the past, I have used several text editors and for LaTeX. A couple of years ago I replaced TeXstudio for VS Code, and I think that it works just fine. Visual Studio Code is one of the most used IDE right now. One advantage of using VS Code to type your documents is that you can set it up to fit your workflow and use it for several languages/purposes. It is also cross-platform, you will not be worrying for having different workflows in Linux or Windows.

You need to follow these steps to make it work:

  • Install Perl. You can use Strawberry Perl in Windows.

  • If you don't have administrator privileges you can install the portable version and add the path to the executable to the PATH environment variable.

  • Install MikTeX. The creator of LaTeX Workshop suggests to use TeX Live instead because it already comes with Perl and you could skip one step in this list. The disadvantages of using TeX Live instead of MikTeX are more (see here).

  • Install LaTeX Workshop.

References

  1. Cangemi, Denis. “The Reasons Why You Must Use Visual Studio Code.” Medium, 13 Aug. 2020, https://blog.devgenius.io/the-reasons-why-you-must-use-visual-studio-code-b522f946a849.

  2. Wright, Joseph. “TeX on Windows: TeX Live versus MiKTeX Revisited.” Some TeX Developments, 18 Dec. 2016, https://www.texdev.net/2016/12/18/tex-on-windows-tex-live-versus-miktex-revisited/.


Escritura técnica: usando figuras

En una publicación anterior mencioné algunos aspectos generales de la escritura técnica. En este me gustaría hablar sobre la inclusión de figuras en documentos técnicos.

Formatos de gráficos

Primero, debo mencionar que hay dos tipos principales de gráficos, a saber:

  • gráficos vectoriales; y

  • gráficos de mapa de bits.

Sirven para diferentes propósitos y deberíamos usarlos teniendo esto en cuenta. Por ejemplo, para diagramas o esquemas es mejor utilizar formatos vectoriales, en general. Por otro lado, los formatos ráster son más adecuados para imágenes como fotografías o ilustraciones.

Gráficos vectoriales

Una imagen vectorial es una imagen que está conformada por entidades geométricas. En este caso, la información almacenada no es punto a punto sino la construcción de las formas que la conforman. Por esta razón, estas imágenes no se pixelan ya que que la información con la que se cuenta es de cómo se construye. Este tipo de imágenes es la mejor opción para esquemas y diagramas, ya que sólo se almacenaría la información de trazos y texto. El estándar de facto para este tipo de imágenes es PDF—este es el tipo que uso en mis documentos de \(\LaTeX\)—. Aunque PDF es el estándar, mi formato preferido es SVG (Scalable Vector Graphics) que es un estándar a través de internet y que se puede renderizar en la mayoría de navegadores modernos.

Gráficos ráster

Una imagen ráster es una imagen que está representada por un arreglo (o rejilla rectangular) de píxeles. En otras palabras, la información del color que hay en cada uno de los puntos de la imagen. Los formatos más populares almacenan la información de forma comprimida. Para gráficos de alto contraste (como esquemas o diagramas) el mejor formato es PNG. Si se tienen animaciones, sería preferible usar GIF. Y en el caso de fotografías es mejor usar JPG.

Resumen para los formatos

Resumiendo, deberíamos usar imágenes JPG (solo) para fotografías y SVG para esquemas/diagramas. Otro atributo que puede resultar útil es la gestión de capas. Tener varias capas brinda la opción de apilar diferentes tipos de información por separado. Por ejemplo, puede tener el fondo, la imagen y las anotaciones en diferentes capas. De esta forma se puede modificar sólo la parte de la figura de interés. Se puede automatizar la traducción de las anotaciones de esta manera sin muchos problemas. Los formatos como SVG permiten tener varias capas. En el caso de los formatos ráster, tenemos la opción de utilizar TIFF.

En cuanto al software para generar/editar este tipo de imágenes debo decir que existe una gran cantidad de programas que permiten exportar a estos formatos: Python/Matplotlib, Matlab, Inkscape, Adobe Illustrator, GIMP, Photoshop, LibreOffice. Si el gráfico se genera a partir de un cálculo o una serie de datos, uso Matplotlib. Si, en cambio, queremos hacer un esquema, mi herramienta de elección es Inkscape. Este programa está destinado a ser una alternativa gratuita a programas como Adobe Illustrator, y lo logra. Obviamente, se puede usar Illustrator o Corel Draw para esto. Si el único uso es hacer esquemas técnicos, creo que sería un desperdicio.

Diseñando figuras para documentos

Mi sugerencia es partir del tamaño nominal de la figura del documento. Para la mayoría de nuestros documentos, las cifras seguirán siendo digitales y esto puede parecer contradictorio. Sin embargo, encuentro este enfoque mucho más fácil. Una de las razones es que todavía incrustamos nuestra figura en un documento con un tamaño nominal. Además, a la hora de pensar en el tamaño de la fuente es habitual que tengamos como referencia el texto impreso. Además de eso, debemos considerar que el ojo humano tiene un límite de resolución, por lo que no podemos simplemente reducir nuestras figuras.

Además, no existe la resolución de una imagen digital. La resolución se refiere a una densidad de píxeles por unidad de longitud. Esto tiene sentido al imprimir imágenes, pero no en el caso digital. Sin embargo, las figuras tienen un tamaño nominal y, por lo tanto, una resolución nominal. Es decir, el número de píxeles en una dirección dividido por su tamaño nominal. Es una buena idea considerar una resolución mínima de 150 ppp (puntos por pulgada). Por ejemplo, una imagen de 6 × 3 pulgadas. Esta imagen tendría un tamaño de (a 150 ppp) de 900 px × 450 px.

El siguiente código de Python crea una figura de tamaño 6 in × 3 in, y grafica la función \(f(x) = \sin(x^2)\) y la guarda como una imagen de tamaño 900 in × 450 in.

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2*np.pi, 500, linewidth=2)
y = np.sin(x**2)
plt.figure(figsize=(6, 3))
plt.plot(x, y)
plt.xlabel("x", fontsize=10)
plt.ylabel("y", fontsize=10)
plt.savefig("fig_ex_python.png", dpi)

Y el siguiente código de Matlab.

fig = figure(1);
fig.Units = 'inches';
fig.Position(3:4) =  [6 4];
x = linspace(0, 2*pi, 500);
y = sin(x.^2);
plot(x, y, 'LineWidth', 2);
xlabel('x', 'FontSize', 10)
ylabel('y', 'FontSize', 10)
set(fig, 'PaperSize', [6,4]);
print(fig,'fig_ex_matlab', '-dpng', '-r150');

A continuación resumo algunos tamaños para artículos, pósters y diapositivas.

Artículos

Para un artículo es común usar tamaño carta que es 8.5 in × 11 in (215.9 mm × 279.4 mm). Otro formato común es A4 que es 210 mm × 297 mm (8.27 in × 11.7 in).

Una guía para tamaños comunes es la siguiente:

  • ancho de 1.0 columna: 90 mm (3.5 in);

  • ancho de 1.5 columna: 140 mm (5.5 in);

  • ancho de 2.0 columna: 190 mm (6.5 in);

y se muestra en la siguiente imagen.

Anchos de figuras comparados con papel tamaño carta.

Si consideramos una resolución de 300 ppi, tenemos los siguientes números de píxeles horizontalmente

  • ancho de 1.0 columna: 1050 píxeles;

  • ancho de 1.5 columna: 1650 píxeles; y

  • ancho de 2.0 columna: 1950 píxeles.

Tenga en cuenta que un monitor HD tiene 1920 píxeles en la dirección horizontal. Esto significa que se necesita un monitor HD para ser capaz de ver tanto píxeles.

Respecto al tamaño del texto, es común tener tamaños entre 8 y 12 pts para figuras.

Pósters

En el caso de papel tamaño A0 (841 mm × 1189 mm, 33 in × 47 in) los tamaños serían algo como:

  • ancho de 1.0 columna: 360 mm (14 in);

  • ancho de 1.5 columna: 560 mm (22 in); y

  • ancho de 2.0 columna: 760 mm (26 in).

Tenga en cuenta que un póster puede que no encaje tan bien en el formato de dos columans. Sin embargo, creo que la referencia sigue siendo útil.

Respecto al tamaño dl texto en pósters es una buena idea mantenerlo por encima de 24 pts (ver referencia 3).

Diapositivas

En el caso de diapositivas hay dos relaciones de aspecto comunes 16:9 y 4:3. Además, diferentes programas usan diferentes tamaños nominales. La siguiente tabla muestra los tamaños nomiales para LibreOffice Impress y MS Power Point.

16:9

4:3

LibreOffice Impress

11.02 in × 6.20 in

11.02 in × 8.00 in

MS Power Point

13.32 in × 7.50 in

10.00 in × 7.50 in

Referencias

  1. Matthew Butterick (2019). Butterick's Practical Typography. Segunda edición, Matthew Butterick.

  2. Rougier, Nicolas P., Michael Droettboom, y Philip E. Bourne (2014). “Ten Simple Rules for Better Figures.” PLOS Computational Biology 10(9):e1003833. DOI: 10.1371/journal.pcbi.1003833.

  3. Erren, Thomas C., y Philip E. Bourne. 2007. “Ten Simple Rules for a Good Poster Presentation.” PLOS Computational Biology 3(5):e102. DOI: 10.1371/journal.pcbi.0030102

  4. Elsevier. (n.d.). "Artwork Overview." Fecha de acceso: Noviembre 1, 2021, de https://www.elsevier.com/authors/policies-and-guidelines/artwork-and-media-instructions/artwork-overview

  5. Elsevier. (n.d.). "Artwork sizing." Fecha de acceso: Noviembre 1, 2021, de https://www.elsevier.com/authors/policies-and-guidelines/artwork-and-media-instructions/artwork-sizing

  6. Journal of applied physics (n.d.). "Preparing Your Manuscript: Authors Instruction." Fecha de acceso: Noviembre 1, 2021, de https://aip.scitation.org/jap/authors/manuscript


¿Cuánto chicharrón puede comprar Jeff Bezos?

Este es un cálculo que hizo Sebastián Tobón cuando estaba cursando Métodos Numéricos para Ecuaciones en Derivadas Parciales (en 2020). El propósito era incentivar realizar cuentas rápidas (cuentas de servilleta) y que tuvieran el tamaño de algunos números (por ejemplo, 10¹²) en su cabeza. Esta fue la pregunta que hice:

¿Cuánto chicharrón puede comprar Jeff Bezos?

A continuación está su respuesta.

Respuesta de Sebastián

Supongamos que un cerdo promedio pesa 80 kg. Si su tejido muscular constituye de un 35 % a 40 % de su peso corporal, se pueden sacar 30 kg de carne.

Jeff Bezos tiene un patrimonio neto igual a

\begin{equation*} JB = 115.7 \times 10^9 \text{ USD}\, . \end{equation*}

El precio de 100 g de chicharrón era

\begin{equation*} 7000\text{ COP}\, \frac{1\text{ USD}}{3539.13\text{ COP}} = 1.978\text{ USD}\, . \end{equation*}

Por tanto, Jeff Bezos puede comprar

\begin{equation*} \frac{115.7\times 10^9\text{ USD}}{\frac{1.978\text{ USD}}{100\text{ g}}} = 5.85\times 10^{12}\text{ g de chicharrón.} \end{equation*}

El total de cerdos en el mundo es 1×10⁹ cabezas. Esto equivale a un total de chicharrón

\begin{equation*} 1\times 10^9 \text{ cabezas} \times \frac{30\text{ kg}}{1\text{ cabeza}} = 3\times 10^{13} \text{ g de chicharrón.} \end{equation*}

Para poder comprar todo el chicharrón del mundo debe aumentar su patrimonio neto en 5.13 veces el valor actual.

Los cerdos más caros del mundo cuestan alrededor de 1000 USD, luego

\begin{equation*} \frac{1000\text{ USD}}{\text{cabeza}}\times 10^9\text{ cabezas} = 10^{12}\text{ USD}\, . \end{equation*}

Por otra parte, puede comprar 5.85 veces la cantidad de cerdos a nivel global— siendo estos de los más caros del mercado—. Por lo tanto

le sale más rentable comprar todos los cerdos del mundo.


Usando el lenguaje de Wolfram en Jupyter: Alternativa gratuita a Mathematica

En esta publicación voy a describir cómo agregar Wolfram Language a Jupyter. Esto proporciona una alternativa gratuita a Mathematica con, prácticamente, la misma sintaxis. El uso de Wolfram Engine es gratuito en un ambiente que no sea de producción como se describe en su sitio web:

Wolfram Engine es gratuito para desarrolladores está disponible para desarrollo de software en aplicaciones que no son de producción.

Puede utilizar este producto para:

  • desarrollar un producto para usted o su empresa

  • realizar proyectos personales en casa, en la escuela, en el trabajo

  • explorar Wolfram Language para futuros proyectos de producción

Instalación

Para instalar debes seguir los siguientes pasos:

  • Descargar Wolfram Engine.

  • Crear una cuenta de Wolfram, si no tienes una.

  • Ejecutar el instalador.

  • Digitar lo siguiente en la terminal.

    wolframscript
    

y te debería preguntar por tu correo y contraseña.

Luego deberías estar en una terminal y ver lo siguiente

Wolfram Engine activated. See https://www.wolfram.com/wolframscript/ for more information.
Wolfram Language 12.2.0 Engine for Linux x86 (64-bit)
Copyright 1988-2021 Wolfram Research, Inc.

Y podemos probar que está funcionando

In[1]:= $Version

Out[1]= 12.2.0 for Linux x86 (64-bit) (January 7, 2021)

In[2]:= Integrate[1/(1 + x^2), x]

Out[2]= ArcTan[x]

Ahora debemos instalar WolframLanguageForJupyter. Para esto debemos digitar lo siguiente en una terminal

git clone https://github.com/WolframResearch/WolframLanguageForJupyter.git

cd WolframLanguageForJupyter/

./configure-jupyter.wls add

Para probar que está instalado podemos digitar lo siguiente

jupyter kernelspec list

y debería tener una salida similar a la siguiente

wolframlanguage12.   /home/nicoguaro/.local/share/jupyter/kernels/wolframlanguage12.2

O también podemos intentar con

jupyter notebook

y ver lo siguiente en el menú de kernel.

Menú de kernels luego de instalar  WolframLanguageForJupyter.

Prueba

Probé algunas de las capacidades y puedes descargar el notebook o ver una versión estática aquí.

Calculemos la integral

\begin{equation*} \int \frac{1}{1 + x^3}\mathrm{d}x\, . \end{equation*}
sol:= Integrate[1/(1 + x^3), x]
TeXForm[sol]
\begin{equation*} -\frac{1}{6} \log \left(x^2-x+1\right)+\frac{1}{3} \log (x+1)+\frac{\tan^{-1}\left(\frac{2 x-1}{\sqrt{3}}\right)}{\sqrt{3}} \end{equation*}

Y realicemos un gráfico 3D.

fun:= Sin[Sqrt[x^2 + y^2]]/Sqrt[x^2 + y^2]
Plot3D[fun, {x, -5*Pi, 5*Pi}, {y, -5*Pi, 5*Pi},
    PlotPoints -> 100, BoxRatios -> {1, 1, 0.2},
    PlotRange -> All]
Gráfico 3D en el notebook.

En este caso no tenemos gráficos interactivos. Esto no está implementado aún, pero si estás interesado puede ver el issue sobre esto en GitHub.

Regresando al Método de elementos de frontera

Durante octubre (2017) estuve escribiendo un programa por día para algunos métodos numéricos famosos en Python y Julia. Esto estaba pensado como un ejercicio para aprender Julia. Puedne ver un resumen aquí. Tuve éxito en 30 de los retos, exceptuando por el BEM (Método de elementos de frontera, en inglés), donde no pude encontrar que hice mal ese día. La publicación original está aquí.

Thomas Klimpel encontró el error y me escribió un email describiendo lo que estaba mal. Entonces, estoy creando esta publicación con la implementación correcta del BEM.

El Método de Elementos de Frontera

Queremos rsolver la ecuación

\begin{equation*} \nabla^2 u = -f(x, y)\quad \forall (x, y) \in \Omega\, , \end{equation*}

con

\begin{equation*} u(x) = g(x, y), \quad \forall (x, y)\in \partial \Omega \, . \end{equation*}

Para este método, necesitamos usar la representación integral de la ecuación, que, en este caso, es

\begin{equation*} u(\boldsymbol{\xi}) = \int_{S} [u(\mathbf{x}) F(\mathbf{x}, \boldsymbol{\xi}) - q(\mathbf{x})G(\mathbf{x}, \boldsymbol{\xi})]\mathrm{d}S(\mathbf{x}) + \int_{V} f(\mathbf{x}) G(\mathbf{x}, \boldsymbol{\xi}) \mathrm{d}V(\mathbf{x}) \end{equation*}

con

\begin{equation*} G(\mathbf{x}, \boldsymbol{\xi})= -\frac{1}{2\pi}\ln|\mathbf{x} - \xi| \end{equation*}

y

\begin{equation*} F(\mathbf{x}, \boldsymbol{\xi}) = -\frac{1}{2\pi |\mathbf{x} - \boldsymbol{\xi}|^2} (\mathbf{x} - \boldsymbol{\xi})\cdot\hat{\mathbf{n}} \end{equation*}

Entonces, podemos formar un sistema de ecuaciones

\begin{equation*} [G]\{q\} = [F]\{u\}\, , \end{equation*}

que obtenemos discretizando la frontera. Si tomamos variables constantes en la discretización, las integrales se pueden calcular analíticamente

\begin{equation*} G_{nm} = -\frac{1}{2\pi}\left[r \sin\theta\left(\ln|r| - 1\right) + \theta r\cos\theta\right]^{\theta_B, r_B}_{\theta_A, r_A} \end{equation*}

y

\begin{equation*} F_{nm} = \left[\frac{\theta}{2\pi}\right]^{\theta_B}_{\theta_A} \end{equation*}

para puntos \(n\) y \(m\) en diferentos elementos, y los subíndices \(A, B\) se refieren a los puntos finales del elemento de evaluación. Debemos tener cuidado al evaluar esta expresión ya que \(r_A\) y \(r_B\) pueden ser (casi) cero y hacer que explote. Además, aquí es donde estaba el problema principal ya que olvidé calcular los ángulos para elements que están, en general, no alineados con los ejes vertical u horizontal.

Para los términos en la diagonal las integrales se evalúan como

\begin{equation*} G_{nn} = -\frac{L}{2\pi}\left(\ln\left\vert\frac{L}{2}\right\vert - 1\right) \end{equation*}

y

\begin{equation*} F_{nn} = - \frac{1}{2} \end{equation*}

con \(L\) el tamaño del elemento.

A continuación está el código. Tengan en cuenta que este código funciona para problemas puramente de Dirichlet. Para problemas mixtos Dirichlet-Neumann, las matrices de influencia deben reordenarse para separar las incógnitas de las variables conocidas en lados opuestos de la ecuación.

Pueden descargar los archivos para este proyecto aquí. Se incluye un archivo YML para crear un ambiente de conda con la lista de dependencias. Por ejemplo, se usa la versión 3.0 de Meshio.

import numpy as np
from numpy import log, arctan2, pi, mean, arctan
from numpy.linalg import norm, solve
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import meshio


  def assem(coords, elems):
      """Assembly matrices for the BEM problem

      Parameters
      ----------
      coords : ndarray, float
          Coordinates for the nodes.
      elems : ndarray, int
          Connectivity for the elements.

      Returns
      -------
      Gmat : ndarray, float
          Influence matrix for the flow.
      Fmat : ndarray, float
          Influence matrix for primary variable.
      """
      nelems = elems.shape[0]
      Gmat = np.zeros((nelems, nelems))
      Fmat = np.zeros((nelems, nelems))
      for ev_cont, elem1 in enumerate(elems):
          for col_cont, elem2 in enumerate(elems):
              pt_col = mean(coords[elem2], axis=0)
              if ev_cont == col_cont:
                  L = norm(coords[elem1[1]] - coords[elem1[0]])
                  Gmat[ev_cont, ev_cont] = - L/(2*pi)*(log(L/2) - 1)
                  Fmat[ev_cont, ev_cont] = - 0.5
              else:
                  Gij, Fij = influence_coeff(elem1, coords, pt_col)
                  Gmat[ev_cont, col_cont] = Gij
                  Fmat[ev_cont, col_cont] = Fij
      return Gmat, Fmat


  def influence_coeff(elem, coords, pt_col):
      """Compute influence coefficients

      Parameters
      ----------
      elems : ndarray, int
          Connectivity for the elements.
      coords : ndarray, float
          Coordinates for the nodes.
      pt_col : ndarray
          Coordinates of the colocation point.

      Returns
      -------
      G_coeff : float
          Influence coefficient for flows.
      F_coeff : float
          Influence coefficient for primary variable.
      """
      dcos = coords[elem[1]] - coords[elem[0]]
      dcos = dcos / norm(dcos)
      rotmat = np.array([[dcos[1], -dcos[0]],
                      [dcos[0], dcos[1]]])
      r_A = rotmat.dot(coords[elem[0]] - pt_col)
      r_B = rotmat.dot(coords[elem[1]] - pt_col)
      theta_A = arctan2(r_A[1], r_A[0])
      theta_B = arctan2(r_B[1], r_B[0])
      if norm(r_A) <= 1e-6:
          G_coeff = r_B[1]*(log(norm(r_B)) - 1) + theta_B*r_B[0]
      elif norm(r_B) <= 1e-6:
          G_coeff = -(r_A[1]*(log(norm(r_A)) - 1) + theta_A*r_A[0])
      else:
          G_coeff = r_B[1]*(log(norm(r_B)) - 1) + theta_B*r_B[0] -\
                  (r_A[1]*(log(norm(r_A)) - 1) + theta_A*r_A[0])
      F_coeff = theta_B - theta_A
      return -G_coeff/(2*pi), F_coeff/(2*pi)


  def eval_sol(ev_coords, coords, elems, u_boundary, q_boundary):
      """Evaluate the solution in a set of points

      Parameters
      ----------
      ev_coords : ndarray, float
          Coordinates of the evaluation points.
      coords : ndarray, float
          Coordinates for the nodes.
      elems : ndarray, int
          Connectivity for the elements.
      u_boundary : ndarray, float
          Primary variable in the nodes.
      q_boundary : [type]
          Flows in the nodes.

      Returns
      -------
      solution : ndarray, float
          Solution evaluated in the given points.
      """
      npts = ev_coords.shape[0]
      solution = np.zeros(npts)
      for k in range(npts):
          for ev_cont, elem in enumerate(elems):
              pt_col = ev_coords[k]
              G, F = influence_coeff(elem, coords, pt_col)
              solution[k] += u_boundary[ev_cont]*F - q_boundary[ev_cont]*G
      return solution


#%% Simulation
mesh = meshio.read("disk.msh")
elems = mesh.cells["line"]
bound_nodes = list(set(elems.flatten()))
coords = mesh.points[bound_nodes, :2]
x, y = coords.T
x_m, y_m = 0.5*(coords[elems[:, 0]] + coords[elems[:, 1]]).T
theta = np.arctan2(y_m, x_m)
u_boundary = 3*np.cos(6*theta)


#%% Assembly
Gmat, Fmat = assem(coords, elems)

#%% Solution
q_boundary = solve(Gmat, Fmat.dot(u_boundary))

#%% Evaluation
ev_coords =  mesh.points[:, :2]
ev_x, ev_y = ev_coords.T
solution = eval_sol(ev_coords, coords, elems, u_boundary, q_boundary)

#%% Visualization
tris = mesh.cells["triangle"]
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(ev_x, ev_y, solution, cmap="RdYlBu", lw=0.3,
                edgecolor="#3c3c3c")
plt.xticks([])
plt.yticks([])
ax.set_zticks([])
plt.savefig("bem_solution.png", bbox_inches="tight", transparent=True,
            dpi=300)

En este caso obtenemos el siguiente resultado.

Solución de la ecuación diferencial usando BEM.

Descargar videos de MS Stream

Esta semana un estudiante me preguntó acerca de descargar los videos de uno de los cursos de MS Stream. El problema es que si no eres propietario del video no puedes descargarlo. Entonces, voy a mostrar una opción para descargar videos sin ser propietario de los mismos.

Descargo de responsabilidad: puede ser una buena idea preguntar a tu organización sobre los derechos de autor de los videos.

Prerrequisitos

Vas a necesitar lo siguiente:

Instalación de destreamer

Después de obtener los requisitos previos, puedes descargar destreamer usando

$ git clone https://github.com/snobu/destreamer
$ cd destreamer
$ npm install
$ npm run build

en una terminal.

Si no se quiere jugar con variables de entorno, sugiero agregar ffmpeg a la misma carpeta en donde se encuentra destreamer.

Descarga

Después de eso, debe navegar a la carpeta donde descargaste destreamer y

$ ./destreamer.sh -i "https://web.microsoftstream.com/video/VIDEO_ID"

en Mac o Linux,

$ destreamer.cmd -i "https://web.microsoftstream.com/video/VIDEO_ID"

en el command prompt en Windows, y

$ destreamer.ps1 -i "https://web.microsoftstream.com/video/VIDEO_ID"

en PowerShell. VIDEO_ID se refiere al identificador del video en MS Stream.

Si deseas descargar varios archivos (como un curso completo), puedes crear un archivo con las URL y usar

$ destreamer.cmd -f filename.txt

Marcado Aleatorio de un Tetraedro

El día de ayer (junio 4 de 2020), Christian Howard publicó en Twitter la siguiente pregunta

Dado un tetraedro τ. Para cada cara triangular de τ, marcamos al azar uniformemente uno de sus aristas. ¿Cuál es el probabilidad de que exista una arista de τ que se marca dos veces?

Pensé un poco pero no pude encontrar la manera apropiada de hacer e conteo. Entonces, se me ocurrió un número de la nada: \(2/3\), pero no sé por qué. Así que decidí correr una simulación para verificar este número.

La respuesta correcta es \(51/81\), aproximadamente 63%. este cálculo está bien explicado en el blog de Christian con algunos gráficos interesantes (y memes).

El algoritmo

El algoritmo es bastante simple. Se enumeran las aristas de cada cara siguiendo una orientación antihooraria:

  • cara 0: arista 0, arista 1, arista 2

  • cara 1: arista 0, arista 3, arista 4

  • cara 2: arista 1, arista 5, arista 3

  • cara 3: arista 2, arista 4, arista 5

Luego, se toma cada cara y se elige un número al azar entre \((0, 1, 2)\) se marca la arista correspondiente, y se procede a la siguiente cara. Se repite este proceso muchas veces y se cuentan los casos favorables y se dividen por el número total de intentos para obtener un estimado de la probabilidad.

A continuación se muestra un código de Python con esta idea.

import numpy as np
import matplotlib.pyplot as plt

faces = np.array([
        [0, 1, 2],
        [0, 3, 4],
        [1, 5, 3],
        [2, 4, 5]])


def mark_edges():
    marked_edges = np.zeros((6), dtype=int)
    for face in faces:
        num = np.random.randint(0, 3)
        edge = face[num]
        marked_edges[edge] += 1
    return marked_edges


def comp_probs(N_min=1, N_max=5, ntrials=100):
    prob = []
    N_vals = np.logspace(N_min, N_max, ntrials, dtype=int)
    for N in N_vals:
        cont_marked = 0
        for cont in range(N):
            marked = mark_edges()
            if 2 in marked:
                cont_marked += 1
        prob.append(cont_marked/N)
    return N_vals, prob


#%% Cálculos
N_min = 1
N_max = 5
ntrials = 100
np.random.seed(seed=2)
N_vals, prob = comp_probs(N_min, N_max, ntrials)

#%% Gráficos
plt.figure(figsize=(4, 3))
plt.hlines(0.63, 10**N_min, 10**N_max, color="#3f3f3f")
plt.semilogx(N_vals, np.array(prob), "o", alpha=0.5)
plt.xlabel("Number of trials")
plt.ylabel("Estimated probability")
plt.savefig("prob_tet.svg", dpi=300, bbox_inches="tight")
plt.show()

Y podemos ver la evolución del estimado para diferente número de intentos.

Probabilidad estimada para diferente número de intentos.

Escritura técnica

Esta es la primera publicación sobre redacción técnica [*] de una serie que crearé poco a poco. La escritura técnica es algo con lo que la mayoría de nosotros tenemos que lidiar en diferentes contextos. Por ejemplo, en cursos universitarios, publicaciones de investigación, documentación de software. La idea principal de la serie es mencionar algunos de los trucos que he aprendido a lo largo de los años y algunas herramientas que pueden ser útiles.

Las publicaciones futuras serán (probablemente) sobre:

Esta publicación

Como se mencionó anteriormente, la escritura técnica es algo con lo que muchas personas tienen que lidiar. Esta es una habilidad que a veces se pasa por alto, pero no debería. De acuerdo con la U.S. Bureau of Labor Statistics

Los redactores técnicos preparan manuales, guías prácticas, artículos de revistas y otros documentos de respaldo para comunicar información compleja y técnica con mayor facilidad.

Y es una habilidad deseada en el lugar de trabajo. Se espera que su demanda crezca alrededor del 10% en la década actual.

Tipografía

Lo primero que debo mencionar es que escribir documentos es tipografía ya que estamos diseñando con texto (Butterick, 2019). Por lo tanto, deberíamos considerarnos tipógrafos, ya que constantemente diseñamos documentos.

Sugeriría echar un vistazo a "Butterick's Practical Typography" ya que es un libro muy bueno sobre el tema y es fácil de leer. Voy a mencionar algunos puntos importantes de acuerdo con la sección "Tipografía en diez minutos":

  1. La selección tipográfica más importante está en el cuerpo del texto. Esto se debe al hecho de que es la mayor parte del documento.

  2. Elija un tamaño de texto entre 10-12 puntos para documentos impresos y 15-25 píxeles para documentos digitales.

  3. El espacio entre líneas debe estar entre 120-145% del tamaño de la letra.

  4. La longitud de la línea debe tener entre 45 y 90 caracteres. Esto es aproximadamente 2 o 3 alfabetos en minúsculas:

    abcdefghijklmnñopqrstuvwxyzabcdefghijklmnñopqrstuvwxyzabcd

  5. Cuidado con la selección de su fuente. Intente evitar las fuentes predeterminadas como Arial, Calibri o Times New Roman.

Editores

Otro punto que quiero tocar en esta publicación es el de los editores. La primera pregunta que surge es "¿qué editor debo usar?". La respuesta corta es: usa lo que tus colegas estén usando. Ese es mi mejor consejo; de esa manera tienes personas con quienes hablar sobre tus dudas.

La respuesta larga ... es que cada editor tiene sus puntos débiles y fuertes. Yo he escrito artículos científicos en LaTeX, LibreOffice Writer y MS Word; todos se ven profesionales. Entonces, al final, puedes escribir tu documentos de varias maneras y lograr un resultado similar. Yo prefiero usar LaTeX para documentos largos, ya que se centra en la estructura del documento en lugar de la apariencia y esta es la forma en que uno debe administrar un documento largo como una disertación, en mi opinión.

Si solo quieres que elija un editor y te lo sugiera, diría que LibreOffice. Una buena referencia es "Designing with LibreOffice". Una vez que aprendas cómo usar estilos, preguntarás cómo has estado escribiendo todos los documentos hasta ahora.

Hay dos grupos de editores que voy a discutir: WYSIWYG (siglas en inglés para "Lo que ves es lo que obtienes") y editores basados en marcado.

  • WYSIWYG. Esta categoría es la que la mayoría de la gente conoce. Dos ejemplos son:

    • LibreOffice Writer; y

    • Microsoft Word.

  • Los editores basados en marcado dependen de las marcas en el "texto" para diferenciar secciones y estilos. En este caso, su texto parece código, como se ve en la siguiente imagen

    /images/rst_code.png

    Algunos ejemplos son:

Independientemente de cuál sea tu editor principal, sugiero utilizar Pandoc. Te permite convertir entre varios formatos, haciendo el proceso un poco más fácil. Incluso hay un editor basado completamente en él llamado Panwriter.

References

  1. Matthew Butterick (2019). Butterick's Practical Typography. Segunda edición, Matthew Butterick.

  2. Wikibooks contributors. (2020). LaTeX. Wikibooks, The Free Textbook Project.

  3. Bruce Byfield (2016). Designing with LibreOffice. Friends of OpenDocument, Inc.

  4. Deville, S. (2015). Writing academic papers in plain text with Markdown and Jupyter notebook. Sylvain Deville.

  5. Eric Holscher (2016). An introduction to Sphinx and Read the Docs for Technical Writers.

Escritura técnica: usando matemáticas

En una publicación anterior mencioné algunos aspectos generales de la escritura técnica. En este me gustaría hablar sobre la inclusión de expresiones matemáticas en documentos técnicos.

Hay dos formas principales de incluir matemáticas en documentos:

  • utilizando texto; y

  • utilizando una interfaz gráfica.

Usar una interfaz gráfica, como el editor de ecuaciones en LibreOffice Writer o MS Word, o MathType es conveniente. No es necesario memorizar nada y se pueden mirar las expresiones mientras se crean. Sin embargo, puede ser algo lento en comparación con el uso de entrada de texto —una vez que se está cómodo con la sintaxis—.

Hay dos tipos de ecuaciones utilizadas en Internet:

  • MathML es un estándar W3C para ecuaciones y está incluido en HTML5, por lo que funcionaría en todos los navegadores modernos. El problema con este es que no está diseñado para ser escrito a mano. Por tanto, uno puede usarlo si tiene alguna forma automática de generar el código.

  • LaTeX es mi forma sugerida de escribir ecuaciones. La curva de aprendizaje podría ser un un poco empinada al principio pero vale la pena.

Una herramienta que ayuda con las ecuaciones es MathPix Snip que genera automáticamente código LaTeX o MathML a partir de una imagen, incluso una escrita a mano. Otra herramienta que es realmente útil es Detexify que permite dibujar un símbolo y proporciona la sintaxis de LaTeX de este.

En el resto de la publicación mostraré mis sugerencias para trabajar con ecuaciones en LibreOffice y MS Word. Si estás utilizando LaTeX o MarkDown/ReStructuredText para tus documentos ya estás utilizando LaTeX para tus ecuaciones.

LibreOffice

LibreOffice tiene su propio editor de ecuaciones con su propia sintaxis y funciona bien para expresiones pequeñas, pero se complica para ecuaciones grandes o largas manipulaciones algebraicas. Para LibreOffice sugeriría usar TexMaths, es fácil de usar y funciona para el procesador de textos (Writer) y presentaciones (Impress). Supongo que también funciona para hojas de cálculo (Calc), pero no recuerdo haber usado ecuaciones en una.

MS Office

MS Office también tiene su propio editor de ecuaciones, funciona bien y es fácil de usar. Sin embargo, el mismo problema aparece cuando quieres expresiones largas. Una opción es usar directamente LaTeX en Office pero prefiero usar IguanaTex. Es un complemento que permite ingresar ecuaciones de forma similar a TexMaths en LibreOffice.

También puede pegar directamente las ecuaciones MathML en MS Word (>2013 y Windows).

Usa SymPy

Independientemente de la herramienta que use para escribir sus documentos, sugiero usar un CAS (del inglés Computer Algebra System), como Mathematica o SymPy. Estos programas permiten la generación automática de LaTeX y MathML a partir de expresiones y esto facilita mucho el proceso.

Veamos un ejemplo. Supongamos que tenemos la función

\begin{equation*} f(x) = \exp(-x^2) \sin(3*x) \end{equation*}

y queremos calcular su segunda derivada

\begin{equation*} f''(x) = \left(- 12 x \cos{\left(3 x \right)} + 2 \left(2 x^{2} - 1\right) \sin{\left(3 x \right)} - 9 \sin{\left(3 x \right)}\right) e^{- x^{2}} \end{equation*}

El siguiente bloque de código nos da el código LaTex

from sympy import *
init_session()
f = exp(-x**2)*sin(3*x)
fxx = diff(f, x, 2)
print(latex(fxx))

que es

\left(- 12 x \cos{\left(3 x \right)} + 2 \left(2 x^{2} - 1\right) \sin{\left(3 x \right)} - 9 \sin{\left(3 x \right)}\right) e^{- x^{2}}

Este corresponde con el código que usé arriba para representar la ecuación.

Si quisiéramos el código MathML de esa expresión podríamos usar el siguiente fragmento de código

from sympy import *
init_session()
f = exp(-x**2)*sin(3*x)
fxx = diff(f, x, 2)
print(mathml(fxx, printer="presentation"))

observe el argumento opcional printer = "presentation". Si queremos agregar esto a MS Word, por ejemplo, podríamos agregar la salida (que no voy a mostrar porque es realmente larga) dentro del siguiente código

<math xmlns = "http://www.w3.org/1998/Math/MathML">
</math>

Cuando se usa Jupyter Notebook, esto se puede hacer gráficamente con un clic derecho sobre la expresión. Y se muestra el siguiente menú.

/images/jupyter_export_eqs.png

Referencias

  1. “How to Insert Equations in Microsoft Word.” WikiHow, https://www.wikihow.com/Insert-Equations-in-Microsoft-Word. Fecha de acceso: Agosto 3, 2020.

  2. “Copy MathML into Word to Use as Equation.” Stack Overflow, https://stackoverflow.com/questions/25430775/copy-mathml-into-word-to-use-as-equation. Fecha de acceso: Agosto 3, 2020.

  3. “Python - Output Sympy Equation to Word Using Mathml.” Stack Overflow, https://stackoverflow.com/questions/40921128/output-sympy-equation-to-word-using-mathml. Fecha de acceso: Agosto 3, 2020.

  4. OERPUB (2016), “Mathconverter”, https://github.com/oerpub/mathconverter, Fecha de acceso: Agosto 3, 2020.

Revisión ortográfica en Jupyter Notebook

El objetivo de esta publicación es mostrar cómo tener revisión automática de ortografía en Jupyter Notebook, como se muestra a continuación.

Ejemplo de corrección ortográfica en Jupyter Notebook.

Existen varias formas de realizar esto. Sin embargo, la forma más fácil es a través del complemento (nbextension) Spellchecker.

Paso a paso

Los pasos a seguir son los siguientes:

  1. Instalar Jupyter notebook extensions (nbextensions). Este incluye Spellchecker.

  2. Ubicar los diccionarios en la carpeta donde está el complemento. Los diccionarios deben usar la codificación UTF-8.

  3. Configurar la ruta de los diccionarios. Esta puede ser una URL o una ruta relativa respecto a la carpeta en donde se encuentra el complemento.

A continuación describiremos en detalle cada paso.

Paso 1: Instalación de nbextensions

Existe una lista de complementos que agregan algunas funcionalidades comúnmente usadas a Jupyter notebook.

Escriba lo siguiente en una terminal, para instalarlo usando PIP.

pip install jupyter_contrib_nbextensions

Sin embargo, si se está usando Anaconda el método recomendado es usar conda, como se muestra a continuación.

conda install -c conda-forge jupyter_contrib_nbextensions

Esto debe instalar los complementos y también la interfaz de configuración. En el menú principal de Jupyter notebook aparecerá una nueva pestaña nombrada Nbextensions en donde se pueden elegir los complementos a usar. La apariencia es la siguiente.

Interfaz gráfica para los complementos de Jupyter.

Algunos complementos recomendados son:

  • Collapsible Headings: que permite ocultar secciones de los documentos.

  • RISE: que convierte los notebooks en presentaciones.

Paso 2: Diccionarios para español

La documentación de Spellchecker sugiere usar un script de Python para descargar diccionarios del proyecto Chromium. Sin embargo, estos tienen como codificación ISO-8859-1 (occidente) y falla para caracteres con tildes o virgulillas. Para que no haya problemas el diccionario debe tener codificación UTF-8. Pueden descargarse en este enlace.

Una vez que se tienen los diccionarios se deben ubicar en la ruta del complemento. En mi computador esta sería

~/.local/share/jupyter/nbextensions/spellchecker/

y dentro de esta los ubicaremos en

~/.local/share/jupyter/nbextensions/spellchecker/typo/dictionaries

Esta ubicación es arbitraria, lo importante es que necesitamos conocer la ruta relativa al complemento.

Paso 3: Configuración complementos

Ahora, en la pestaña Nbextensions seleccionamos el complemento y llenamos los campos con la información de nuestro diccionario:

  • language code to use with typo.js: es_ES

  • url for the dictionary .dic file to use: ./typo/dictionaries/es_ES.dic

  • url for the dictionary .aff file to use: ./typo/dictionaries/es_ES.aff

Esto se muestra a continuación.

Configuración con archivos locales.

Otra opción es usar la URL para los archivos. En https://github.com/wooorm/dictionaries están disponibles los diccionarios del proyecto hunspell en UTF-8. En este caso, la configuración sería:

  • language code to use with typo.js: es_ES

  • url for the dictionary .dic file to use: https://raw.githubusercontent.com/wooorm/dictionaries/master/dictionaries/es/index.dic

  • url for the dictionary .aff file to use: https://raw.githubusercontent.com/wooorm/dictionaries/master/dictionaries/es/index.aff

Y se muestra a continuación.

Configuración con archivos remotos.