np2ltx.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NP2LTX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from IPython.display import display, Markdown, Math\n",
    "\n",
    "fprecision = 3\n",
    "cprecision = 1\n",
    "\n",
    "\n",
    "def matrix2string(M, name):\n",
    "    # get dimensions\n",
    "    dim = M.ndim\n",
    "    if dim < 2:\n",
    "        ltx = parse_1d(M)\n",
    "    elif dim > 2:\n",
    "        raise ValueError(\"Matrix must have dimension less then 3\")\n",
    "    else:\n",
    "        ltx = parse_2d(M)\n",
    "    return f\"\"\"\n",
    "            {name} = \n",
    "            \\\\begin{{bmatrix}} \\n\n",
    "            {ltx}\n",
    "            \\\\end{{bmatrix}}\n",
    "            \"\"\"\n",
    "\n",
    "def parse_1d(M):\n",
    "    # Parse numpy matrix into latex\n",
    "    ltx = \"\"\n",
    "    n = M.shape[0]\n",
    "    if n == 0:\n",
    "        ltx = r\"0\"\n",
    "    for i in range(n):\n",
    "            ltx += parse_entry(M[i])\n",
    "            ltx += \" \\\\\\\\ \\n \"    \n",
    "    return ltx\n",
    "\n",
    "\n",
    "def parse_2d(M):\n",
    "    # Parse numpy matrix into latex\n",
    "    ltx = \"\"\n",
    "    n, m = M.shape\n",
    "    for i in range(n):\n",
    "        for j in range(m):\n",
    "            ltx += parse_entry(M[i,j])\n",
    "            # next column or next row\n",
    "            ltx += (\" & \" if j < m-1 else \" \\\\\\\\ \\n \")\n",
    "    return ltx\n",
    "\n",
    "def parse_entry(entry):\n",
    "    # format according to type\n",
    "    entry_type = type(entry)\n",
    "    if entry_type in (float, np.float64):\n",
    "        return parse_float(entry, fprecision)\n",
    "    elif entry_type in (bool, np.bool_):\n",
    "        return str(entry*1)\n",
    "    elif entry_type == np.complex128:\n",
    "        return parse_imag(entry)\n",
    "    return str(entry)\n",
    "\n",
    "def parse_imag(entry):\n",
    "    if entry.imag == 0:\n",
    "        return parse_float(entry.real,fprecision)\n",
    "    else:\n",
    "        im = parse_float(entry.imag, cprecision)\n",
    "        re = parse_float(entry.real, cprecision)\n",
    "        return f\"{re} + i{im}\"\n",
    "\n",
    "def parse_float(entry, precision):\n",
    "    if round(entry, 4).is_integer():\n",
    "        return f\"{entry:.0f}\"\n",
    "    else:\n",
    "        return f\"{entry:.{precision}f}\"\n",
    "\n",
    "def print_matrix(M, name):\n",
    "    ltx = matrix2string(M, name)\n",
    "    # Display results as latex with some padding\n",
    "    display(Math(r\"\\\\~\\\\\" + ltx + r\"\\\\~\\\\\"))\n",
    "    \n",
    "def print_math(equation):\n",
    "    display(Math(equation))\n",
    "    \n",
    "def print_text(text):\n",
    "    display(Math(r\"\\text{\" + text + r\"}\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\\\~\\\\\n",
       "            I \\in \\mathbb{Z} = \n",
       "            \\begin{bmatrix} \n",
       "\n",
       "            1 & 0 & 0 \\\\ \n",
       " 0 & 1 & 0 \\\\ \n",
       " 0 & 0 & 1 \\\\ \n",
       " \n",
       "            \\end{bmatrix}\n",
       "            \\\\~\\\\$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_matrix(np.eye(3), \"I \\in \\mathbb{Z}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\\\~\\\\\n",
       "            R \\in \\mathbb{R}^{3x3} = \n",
       "            \\begin{bmatrix} \n",
       "\n",
       "            0.462 & 0.157 & 0.885 \\\\ \n",
       " 0.529 & 0.565 & 0.567 \\\\ \n",
       " 0.475 & 0.501 & 0.514 \\\\ \n",
       " \n",
       "            \\end{bmatrix}\n",
       "            \\\\~\\\\$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_matrix(np.random.rand(3,3), \"R \\in \\mathbb{R}^{3x3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean variables are parsed to 1s and 0s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\\\~\\\\\n",
       "            M = \n",
       "            \\begin{bmatrix} \n",
       "\n",
       "            1 & 0 \\\\ \n",
       " \n",
       "            \\end{bmatrix}\n",
       "            \\\\~\\\\$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "M = np.array([[True, False]])\n",
    "\n",
    "print_matrix(M, \"M\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Latex expressions can be used as entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\\\~\\\\\n",
       "            v = \n",
       "            \\begin{bmatrix} \n",
       "\n",
       "            \\pi \\\\ \n",
       " 42 \\\\ \n",
       " \n",
       "            \\end{bmatrix}\n",
       "            \\\\~\\\\$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "v = np.array([\"\\pi\", 42])\n",
    "\n",
    "print_matrix(v,\"v\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Empty matricies are ok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\\\~\\\\\n",
       "            \\mathbb{Ø} = \n",
       "            \\begin{bmatrix} \n",
       "\n",
       "            0\n",
       "            \\end{bmatrix}\n",
       "            \\\\~\\\\$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "z = np.array([])\n",
    "\n",
    "print_matrix(z, \"\\mathbb{Ø}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And complex numbers as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\\\~\\\\\n",
       "            c \\in \\mathbb{C} = \n",
       "            \\begin{bmatrix} \n",
       "\n",
       "            0 + i2.2 \\\\ \n",
       " 3.1 + i9 \\\\ \n",
       " 4 \\\\ \n",
       " \n",
       "            \\end{bmatrix}\n",
       "            \\\\~\\\\$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from numpy.lib.scimath import sqrt\n",
    "\n",
    "c = np.array([sqrt(-5), 22/7 + 9j, 4])\n",
    "print_matrix(c, \"c \\in \\mathbb{C}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}