es/Units.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que otros lenguajes, los lenguajes de .NET aceptan decoradores o atributos sobre los tipos de datos, que se expresan usando `[<AttributeName>]`. Uno de los más convenientes el `[<Measure>]` que permite definir unidades de medida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.6261e-34\n"
     ]
    }
   ],
   "source": [
    "[<Measure>]\n",
    "type J \n",
    "\n",
    "[<Measure>]\n",
    "type s \n",
    "\n",
    "[<Measure>]\n",
    "type m \n",
    "\n",
    "[<Measure>]\n",
    "type nm \n",
    "\n",
    "let nmTom (a: float<nm>) = a*1e-9<m/nm>  \n",
    "\n",
    "let c = 299792458.0<m/s>\n",
    "\n",
    "let h = 6.6261E-34<J*s> \n",
    "\n",
    "printfn \"%A\" h"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Planck formula\n",
    "$$\n",
    "E = \\frac {h c}{\\lambda}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lambda[m]: 1,0000000000000001E-07\n",
      "E[J]: 1,9864548059538E-18\n"
     ]
    }
   ],
   "source": [
    "let lambda = 100.0<nm>\n",
    "\n",
    "printfn $\"lambda[m]: {nmTom lambda}\"\n",
    "\n",
    "let energy (lambda: float<nm>) = \n",
    "    h*c/(nmTom lambda) \n",
    "\n",
    "printfn $\"E[J]: {energy lambda}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "[<Measure>]\n",
    "type eV \n",
    "\n",
    "let joulesToeV (a:float<J>) = 6.242e+18<eV/J>*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E[eV]: 12,39945089876362\n"
     ]
    }
   ],
   "source": [
    "printfn $\"E[eV]: {energy lambda |> joulesToeV}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 C son  32 F\n",
      " 10 C son  50 F\n",
      " 20 C son  68 F\n",
      " 30 C son  86 F\n",
      " 40 C son 104 F\n",
      " 50 C son 122 F\n",
      " 60 C son 140 F\n",
      " 70 C son 158 F\n",
      " 80 C son 176 F\n",
      " 90 C son 194 F\n",
      "100 C son 212 F\n"
     ]
    }
   ],
   "source": [
    "[<Measure>] type C // temperature, Celsius/Centigrade\n",
    "[<Measure>] type F // temperature, Fahrenheit\n",
    "\n",
    "let convertCtoF ( temp : float<C> ) = 9.0<F> / 5.0<C> * temp + 32.0<F>\n",
    "let convertFtoC ( temp: float<F> ) = 5.0<C> / 9.0<F> * ( temp - 32.0<F>)\n",
    "\n",
    "// Define conversion functions from dimensionless floating point values.\n",
    "let degreesFahrenheit temp = temp * 1.0<F>\n",
    "let degreesCelsius temp = temp * 1.0<C>\n",
    "\n",
    "[0..10..100]\n",
    "|> List.map float \n",
    "|> List.map degreesCelsius \n",
    "|> List.map (fun t -> (t,convertCtoF t))\n",
    "|> List.iter (fun (tc,tf)-> printfn $\"%3.0f{tc} C son %3.0f{tf} F\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 F son -18 C\n",
      " 10 F son -12 C\n",
      " 20 F son  -7 C\n",
      " 30 F son  -1 C\n",
      " 40 F son   4 C\n",
      " 50 F son  10 C\n",
      " 60 F son  16 C\n",
      " 70 F son  21 C\n",
      " 80 F son  27 C\n",
      " 90 F son  32 C\n",
      "100 F son  38 C\n"
     ]
    }
   ],
   "source": [
    "[0..10..100]\n",
    "|> List.map float \n",
    "|> List.map degreesFahrenheit \n",
    "|> List.map (fun t -> (t,convertFtoC t))\n",
    "|> List.iter (fun (tf,tc)-> printfn $\"%3.0f{tf} F son %3.0f{tc} C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "ename": "Error",
     "evalue": "input.fsx (4,6)-(4,8) typecheck error The unit of measure 'C' does not match the unit of measure 'F'\ninput.fsx (4,4)-(4,5) typecheck error The unit of measure 'C' does not match the unit of measure 'F'",
     "output_type": "error",
     "traceback": [
      "input.fsx (4,6)-(4,8) typecheck error The unit of measure 'C' does not match the unit of measure 'F'\n",
      "input.fsx (4,4)-(4,5) typecheck error The unit of measure 'C' does not match the unit of measure 'F'"
     ]
    }
   ],
   "source": [
    "let t1 = 44<F>\n",
    "let t2 = 32<C>\n",
    "\n",
    "t1 + t2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>76</pre></div><style>\r\n",
       ".dni-code-hint {\r\n",
       "    font-style: italic;\r\n",
       "    overflow: hidden;\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview {\r\n",
       "    white-space: nowrap;\r\n",
       "}\r\n",
       ".dni-treeview td {\r\n",
       "    vertical-align: top;\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "details.dni-treeview {\r\n",
       "    padding-left: 1em;\r\n",
       "}\r\n",
       "table td {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "table tr { \r\n",
       "    vertical-align: top; \r\n",
       "    margin: 0em 0px;\r\n",
       "}\r\n",
       "table tr td pre \r\n",
       "{ \r\n",
       "    vertical-align: top !important; \r\n",
       "    margin: 0em 0px !important;\r\n",
       "} \r\n",
       "table th {\r\n",
       "    text-align: start;\r\n",
       "}\r\n",
       "</style>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "let t1 = 44<F>\n",
    "let t2 = 32<F>\n",
    "\n",
    "t1 + t2 "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uno puede querer usar los valores sin la unidad de medida, para lo cual es necesario _castearlos_  usando `float`."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}