Pint-Usage-Fast.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pint Python Library\n",
    "\n",
    "> Pint is a Python package to define, operate and manipulate physical quantities: the product of a numerical value and a unit of measurement. It allows arithmetic operations between them and conversions from and to different units.\n",
    "\n",
    "http://pint.readthedocs.io/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add these x3 lines whenever to use pint <b>FASTLY</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pint\n",
    "unt = pint.UnitRegistry(autoconvert_offset_to_baseunit = True)\n",
    "Q_ = unt.Quantity\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3.04 meter"
      ],
      "text/latex": [
       "$3.04\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "3.04 <Unit('meter')>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * unt('m') + 4 * unt('cm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><tbody><tr><th>Magnitude</th><td style='text-align:left;'><pre>[3.04 4.03]</pre></td></tr><tr><th>Units</th><td style='text-align:left;'>meter</td></tr></tbody></table>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}3.04 & 4.03\\end{pmatrix}\\ \\mathrm{meter}$"
      ],
      "text/plain": [
       "array([3.04, 4.03]) <Unit('meter')>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([3, 4]) * unt('m') + np.array([4, 3]) * unt('cm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'> <b> Offset units 'HANDLE WITH CARE' </b></font> \n",
    "https://pint.readthedocs.io/en/0.7.2/nonmult.html#:~:text=OffsetUnitCalculusError: Ambiguous operation with offset unit (degC, kelvin).&text=In contrast to subtraction, the,283.15 K + 373.15 K)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp1 = 50*unt('degC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "60 degree_Celsius"
      ],
      "text/latex": [
       "$60\\ \\mathrm{degree\\_Celsius}$"
      ],
      "text/plain": [
       "60 <Unit('degree_Celsius')>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp1 + 10*unt('delta_degC')\n",
    "#delta is important when ADDING or SUBSTRACTING\n",
    "#temp1 + 10*unt('degC')  ...GIVES ERROR\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "55.55555555555556 degree_Celsius"
      ],
      "text/latex": [
       "$55.55555555555556\\ \\mathrm{degree\\_Celsius}$"
      ],
      "text/plain": [
       "55.55555555555556 <Unit('degree_Celsius')>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#adding substracting offset scales; use delta_degF, delta_degC\n",
    "temp1 + 10*unt('delta_degF')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List cumbersome to manipulate than arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30 <Unit('degree_Celsius')>,\n",
       " 40 <Unit('degree_Celsius')>,\n",
       " 50 <Unit('degree_Celsius')>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multitemps=[30,40,50]\n",
    "multitemps=list(map(lambda x:x*unt('degC'),multitemps))\n",
    "multitemps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[85.99999999999993 <Unit('degree_Fahrenheit')>,\n",
       " 103.99999999999993 <Unit('degree_Fahrenheit')>,\n",
       " 121.99999999999993 <Unit('degree_Fahrenheit')>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#bcz list cannot be converted to another unit using .to \n",
    "[x.to('degF') for x in multitemps]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays more easy to manipulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><tbody><tr><th>Magnitude</th><td style='text-align:left;'><pre>[[  10  100 1000]]</pre></td></tr><tr><th>Units</th><td style='text-align:left;'>kilogram</td></tr></tbody></table>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}10 & 100 & 1000\\end{pmatrix}\\ \\mathrm{kilogram}$"
      ],
      "text/plain": [
       "array([[  10,  100, 1000]]) <Unit('kilogram')>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multimass=np.array([ [10,100,1000] ])*unt('kg')\n",
    "multimass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><tbody><tr><th>Magnitude</th><td style='text-align:left;'><pre>[[10000.0 100000.0 1000000.0]]</pre></td></tr><tr><th>Units</th><td style='text-align:left;'>gram</td></tr></tbody></table>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}10000.0 & 100000.0 & 1000000.0\\end{pmatrix}\\ \\mathrm{gram}$"
      ],
      "text/plain": [
       "array([[  10000.,  100000., 1000000.]]) <Unit('gram')>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multimass.to(unt('g'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'><b> Base Units aren't automatically recasted to Compounded Units. But can be recasted to base units </b></font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><tbody><tr><th>Magnitude</th><td style='text-align:left;'><pre>[[0.5 0.05 0.005]]</pre></td></tr><tr><th>Units</th><td style='text-align:left;'>newton/kilogram</td></tr></tbody></table>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}0.5 & 0.05 & 0.005\\end{pmatrix}\\ \\frac{\\mathrm{newton}}{\\mathrm{kilogram}}$"
      ],
      "text/plain": [
       "array([[0.5  , 0.05 , 0.005]]) <Unit('newton / kilogram')>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#in place conversion\n",
    "accel= 5*unt('N') / multimass\n",
    "accel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><tbody><tr><th>Magnitude</th><td style='text-align:left;'><pre>[[0.5 0.05 0.005]]</pre></td></tr><tr><th>Units</th><td style='text-align:left;'>meter/second<sup>2</sup></td></tr></tbody></table>"
      ],
      "text/latex": [
       "$\\begin{pmatrix}0.5 & 0.05 & 0.005\\end{pmatrix}\\ \\frac{\\mathrm{meter}}{\\mathrm{second}^{2}}$"
      ],
      "text/plain": [
       "array([[0.5  , 0.05 , 0.005]]) <Unit('meter / second ** 2')>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accel.to_base_units()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "50 ampere second"
      ],
      "text/latex": [
       "$50\\ \\mathrm{ampere} \\cdot \\mathrm{second}$"
      ],
      "text/plain": [
       "50 <Unit('ampere * second')>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Current=5*unt('A')\n",
    "Duration=10*unt('s')\n",
    "Charge=Current*Duration\n",
    "Charge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In place unit conversion using <b>.ito()</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "50.0 coulomb"
      ],
      "text/latex": [
       "$50.0\\ \\mathrm{coulomb}$"
      ],
      "text/plain": [
       "50.0 <Unit('coulomb')>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Charge.ito(unt('C'))\n",
    "Charge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Quantity.to_base_units of <Quantity(50.0, 'coulomb')>>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Charge.to_base_units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ideal gas law: mixed unit conversion\n",
    "$$\\rho = \\frac{MP}{R_gT}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0007750322039243355 delta_degree_Celsius * kilogram * mole * standard_atmosphere / kelvin / kilomole / liter / torr\n",
      "0.5890244749824949 kilogram / meter ** 3\n",
      "0.03677159670259146 pound / foot ** 3\n"
     ]
    }
   ],
   "source": [
    "M  = 29     * unt('kg/kmol')\n",
    "P  = 1      * unt('atm')\n",
    "T  = 600    * unt('degK')\n",
    "Rg = 62.363 * unt('L*torr/mol/delta_degC')\n",
    "\n",
    "ρ = M*P/Rg/T\n",
    "\n",
    "print(ρ)\n",
    "print(ρ.to_base_units())    # function \"to_base_units\"   \n",
    "print(ρ.to(unt('lb/ft**3')))   # some other desired units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another syntax way but cumbersome especially when declaring rate units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "25.4 degree_Celsius"
      ],
      "text/latex": [
       "$25.4\\ \\mathrm{degree\\_Celsius}$"
      ],
      "text/plain": [
       "25.4 <Unit('degree_Celsius')>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Teasy=25.4 * unt.degC; Teasy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "35.4 degree_Celsius"
      ],
      "text/latex": [
       "$35.4\\ \\mathrm{degree\\_Celsius}$"
      ],
      "text/plain": [
       "35.4 <Unit('degree_Celsius')>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Teasy + 10*unt.delta_degC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "59.709999999999994 kelvin/second"
      ],
      "text/latex": [
       "$59.709999999999994\\ \\frac{\\mathrm{kelvin}}{\\mathrm{second}}$"
      ],
      "text/plain": [
       "59.709999999999994 <Unit('kelvin / second')>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Teasy/(5*unt.s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'> <b> Be careful, here rate is in delta but shown in kelvin </b></font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "59.709999999999994 kelvin/meter"
      ],
      "text/latex": [
       "$59.709999999999994\\ \\frac{\\mathrm{kelvin}}{\\mathrm{meter}}$"
      ],
      "text/plain": [
       "59.709999999999994 <Unit('kelvin / meter')>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Teasy/(5*unt.m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "59.709999999999994 delta_degree_Celsius/meter"
      ],
      "text/latex": [
       "$59.709999999999994\\ \\frac{\\mathrm{delta\\_degree\\_Celsius}}{\\mathrm{meter}}$"
      ],
      "text/plain": [
       "59.709999999999994 <Unit('delta_degree_Celsius / meter')>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rate=Teasy/(5*unt.m)\n",
    "rate.ito(unt.delta_degC/unt.m)\n",
    "# rate.ito(unt('delta_degC/m')) ...FASTER\n",
    "rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a new unit on the go..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n"
     ]
    }
   ],
   "source": [
    "#check if exists\n",
    "print('acre' in unt, 'marla' in unt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unt.define('marla = 25.2929 * m**2')\n",
    "'marla' in unt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.1976839350173369 marla"
      ],
      "text/latex": [
       "$0.1976839350173369\\ \\mathrm{marla}$"
      ],
      "text/plain": [
       "0.1976839350173369 <Unit('marla')>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5*unt('m**2').to(unt('marla'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "131.4645 meter<sup>2</sup>"
      ],
      "text/latex": [
       "$131.4645\\ \\mathrm{meter}^{2}$"
      ],
      "text/plain": [
       "131.4645 <Unit('meter ** 2')>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5*unt('m**2') + 5*unt('marla')"
   ]
  },
  {
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}