a-students-guide-to-the-mathematics-of-astronomy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *A Student's Guide to the Mathematics of Astronomy*\n",
    "\n",
    "This is an F# notebook implementing the concepts found in the book [*A Student's Guide to the Mathematics of Astronomy* by Daniel Fleisch and Julia Kregenow](https://www.danfleisch.com/sgmoa/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9ab509f0",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "open FSharp.Data.UnitSystems.SI.UnitSymbols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will define all units of measure here. See [Units of Measure](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/units-of-measure)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f8b5840f",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "[<Measure>] type inch\n",
    "[<Measure>] type feet\n",
    "[<Measure>] type hour\n",
    "[<Measure>] type minute\n",
    "[<Measure>] type lightyear\n",
    "[<Measure>] type parsec\n",
    "[<Measure>] type cm\n",
    "[<Measure>] type km\n",
    "[<Measure>] type mile\n",
    "[<Measure>] type arcmin\n",
    "[<Measure>] type arcsec\n",
    "[<Measure>] type degree\n",
    "[<Measure>] type second\n",
    "[<Measure>] type year\n",
    "[<Measure>] type day"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `ConversionRelation` type is defined simply as a name for a tuple of floats of the two units. Generic units of measure types are used in this type definition. See [Names of Tuple Types](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/tuples#names-of-tuple-types) and [Generics](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/generics/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "31a60df8",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "/// Represents a conversion relation that relates a value in one unit\n",
    "/// of measure to an equivalent value in another unit of measure\n",
    "type ConversionRelation<[<Measure>] 'Unit1, [<Measure>] 'Unit2> =\n",
    "    float<'Unit1> * float<'Unit2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is now easy to build conversion factors from a conversion relation and functions to convert from unit to the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "946605ca",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "/// Returns a conversion factor than can be used to multiply a value in `Unit1` to\n",
    "/// convert it to a value in `Unit2`\n",
    "let getUnit1ToUnit2ConversionFactor<[<Measure>] 'Unit1, [<Measure>]'Unit2> (conversionRelation: ConversionRelation<'Unit1, 'Unit2>) =\n",
    "    let (a, b) = conversionRelation\n",
    "    b / a\n",
    "\n",
    "/// Returns a conversion factor than can be used to multiply a value in `Unit2` to\n",
    "/// convert it to a value in `Unit1`\n",
    "let getUnit2ToUnit1ConversionFactor<[<Measure>] 'Unit1, [<Measure>]'Unit2> (conversionRelation: ConversionRelation<'Unit1, 'Unit2>) =\n",
    "    let (a, b) = conversionRelation\n",
    "    a / b\n",
    "\n",
    "/// Given a conversion relation, convert any value in `Unit1` to a value in `Unit2`\n",
    "let convertUnit1ToUnit2<[<Measure>] 'Unit1, [<Measure>]'Unit2> (conversionRelation: ConversionRelation<'Unit1, 'Unit2>) (value: float<'Unit1>) =\n",
    "    value * (getUnit1ToUnit2ConversionFactor conversionRelation)\n",
    "\n",
    "/// Given a conversion relation, convert any value in `Unit2` to a value in `Unit1`\n",
    "let convertUnit2ToUnit1<[<Measure>] 'Unit1, [<Measure>]'Unit2> (conversionRelation: ConversionRelation<'Unit1, 'Unit2>) (value: float<'Unit2>) =\n",
    "    value * (getUnit2ToUnit1ConversionFactor conversionRelation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "467c0fce",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "let inchAndFeetConversionRelation = (12.0<inch>, 1.0<feet>)\n",
    "let hourAndMinuteConversionRelation = (1.0<hour>, 60.0<minute>)\n",
    "let lightyearAndParsecConversionRelation = (3.26<lightyear>, 1.0<parsec>)\n",
    "\n",
    "let convertInchesToFeet inches =\n",
    "    convertUnit1ToUnit2<inch, feet> inchAndFeetConversionRelation inches\n",
    "\n",
    "let convertFeetToInches feet =\n",
    "    convertUnit2ToUnit1<inch, feet> inchAndFeetConversionRelation feet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1.1\n",
    "\n",
    "Write the following equivalence relations as fractional conversion factors:\n",
    "* 1 in <-> 2.54 cm\n",
    "* 1.6 km <-> 1 mile\n",
    "* 60 arcmin <-> 3,600 arcsec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e5087837",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "let inchAndCentimetersConversionRelation = (1.0<inch>, 2.54<cm>)\n",
    "let kmAndMileConversionRelation = (1.6<km>, 1.0<mile>)\n",
    "let arcminAndArcsecConversionRelation = (60.0<arcmin>, 3_600.0<arcsec>)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See [Plain text formatting](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/plaintext-formatting)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example: Convert 1,000 minutes to hours.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9d4ed23d",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.2054 light years\n"
     ]
    }
   ],
   "source": [
    "convertUnit2ToUnit1 lightyearAndParsecConversionRelation 1.29<parsec>\n",
    "|> printfn \"%A light years\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example: Convert 1.29 parsecs, the distance of the closest star beyond our\n",
    "Sun, to light years.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "42ac9901",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.66666667 hours\n"
     ]
    }
   ],
   "source": [
    "convertUnit2ToUnit1 hourAndMinuteConversionRelation 1_000.0<minute>\n",
    "|> printfn \"%A hours\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1.2\n",
    "\n",
    "<ol type=\"a\">\n",
    "    <li>Express 12 inches in centimeters.</li>\n",
    "    <li>Express 100 cm in inches.</li>\n",
    "    <li>Express 380,000 km in miles (this is roughly the distance from the\n",
    "Earth to the Moon).</li>\n",
    "    <li>Express 93,000,000 miles in kilometers (this is roughly the distance\n",
    "from the Earth to the Sun).</li>\n",
    "    <li>Express 0.5 degrees in arcseconds (this is roughly the angular size of\n",
    "the full Moon viewed from Earth).</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "73dd4724",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(a) 30.48 cm\n",
      "(b) 39.37007874 inches\n",
      "(c) 237500.0 miles\n",
      "(d) 148800000.0 km\n",
      "(e) 1800.0 arcseconds\n"
     ]
    }
   ],
   "source": [
    "// (a)\n",
    "convertUnit1ToUnit2 inchAndCentimetersConversionRelation 12.0<inch>\n",
    "|> printfn \"(a) %A cm\"\n",
    "\n",
    "// (b)\n",
    "convertUnit2ToUnit1 inchAndCentimetersConversionRelation 100.0<cm>\n",
    "|> printfn \"(b) %A inches\"\n",
    "\n",
    "// (c)\n",
    "convertUnit1ToUnit2 kmAndMileConversionRelation 380_000.0<km>\n",
    "|> printfn \"(c) %A miles\"\n",
    "\n",
    "// (d)\n",
    "convertUnit2ToUnit1 kmAndMileConversionRelation 93_000_000.0<mile>\n",
    "|> printfn \"(d) %A km\"\n",
    "\n",
    "// (e)\n",
    "let degreeAndArcsecondConversionRelation = (1.0<degree>, 3_600.0<arcsec>)\n",
    "convertUnit1ToUnit2 degreeAndArcsecondConversionRelation 0.5<degree>\n",
    "|> printfn \"(e) %A arcseconds\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1.3\n",
    "\n",
    "How do you know that your answers to each of the unit\n",
    "conversion problems in the previous exercise make sense? Give a brief\n",
    "explanation for each.\n",
    "\n",
    "**Answer**: Because this is F#, and it makes unit conversions nearly trivial. :) A more thorough answer is that we have defined units of measure as types in F#, then conversion relations as ordered tuples of units of measure, and then defined F# functions that allow us to easily build conversion factors for the conversion relations and functions that convert from unit to the other. F# keeps track of the units, and so it would warn us if we tried to convert using the wrong units. F# effectively ensures the checks described in Sections **1.1.2 Setting up a conversion problem** and **1.1.3 Checking your answer** via its type system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example: Convert from kilometers per hour to meters per second.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0469a9de",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"dni-plaintext\"><pre>0.2777777777777778</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": [
    "(convertUnit1ToUnit2 (1.0<km>, 1000.0<m>) 1.0<km>)\n",
    "/ (convertUnit1ToUnit2 (1.0<hour>, 3_600.0<second>) 1.0<hour>)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example: How many seconds old were you on your first birthday?*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "95e80779",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 year is 31536000.0 seconds\n",
      "30 years is 946080000.0 seconds\n"
     ]
    }
   ],
   "source": [
    "let convertYearsToSeconds years =\n",
    "    convertUnit1ToUnit2 (1.0<year>, 365.0<day>) years\n",
    "    |> convertUnit1ToUnit2 (1.0<day>, 24.0<hour>)\n",
    "    |> convertUnit1ToUnit2 (1.0<hour>, 60.0<minute>)\n",
    "    |> convertUnit1ToUnit2 (1.0<minute>, 60.0<second>)\n",
    "\n",
    "convertYearsToSeconds 1.0<year>\n",
    "|> printfn \"1 year is %A seconds\"\n",
    "\n",
    "convertYearsToSeconds 30.0<year>\n",
    "|> printfn \"30 years is %A seconds\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1.4. Perform the following unit conversions.\n",
    "\n",
    "<ol type=\"a\">\n",
    "    <li>Convert 60 mph (miles per hour) to meters per second.</li>\n",
    "    <li>Convert 1 day to seconds.</li>\n",
    "    <li>Convert dollars per kilogram to cents per gram (100 cents ↔ 1 dollar).</li>\n",
    "    <li>Convert 1 mile to steps, assuming 1 step ↔ 30 inches (there are 1,760\n",
    "    yards in 1 mile, 3 ft in 1 yard, and 12 inches in 1 ft).</li>\n",
    "</ol>"
   ]
  }
 ],
 "metadata": {
  "kernelInfo": {
   "defaultKernelName": null,
   "items": [
    {
     "aliases": [
      "c#",
      "cs"
     ],
     "languageName": "C#",
     "name": "csharp"
    },
    {
     "aliases": [
      "f#",
      "fs"
     ],
     "languageName": "F#",
     "name": "fsharp"
    },
    {
     "aliases": [
      "powershell"
     ],
     "languageName": "PowerShell",
     "name": "pwsh"
    },
    {
     "aliases": [
      "js"
     ],
     "languageName": "JavaScript",
     "name": "javascript"
    },
    {
     "languageName": "HTML",
     "name": "html"
    },
    {
     "languageName": "SQL",
     "name": "sql"
    },
    {
     "languageName": "KQL",
     "name": "kql"
    },
    {
     "languageName": "Mermaid",
     "name": "mermaid"
    },
    {
     "languageName": "HTTP",
     "name": "http"
    },
    {
     "name": "value"
    }
   ]
  },
  "language_info": {
   "name": "python"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "fsharp",
    "items": [
     {
      "aliases": [],
      "languageName": "fsharp",
      "name": "fsharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}