Chapter 1 - Computing with Formulas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.1 The First Programming Encounter: a Formula"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1.1 Using a Program as a Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "print(5*0.6 - 0.5*9.81*0.6**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1.5 Warning About Typing Program Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "# Code (illegal):\n",
    "\"\"\"\n",
    "write 5*0.6 - 0.5*9.81*0.6^2\n",
    "\"\"\"\n",
    "\n",
    "# Result:\n",
    "\"\"\"\n",
    "File \"<ipython-input-3-a4896c6d3f86>\", line 1\n",
    "    write 5*0.6 - 0.5*9.81*0.6^2\n",
    "          ^\n",
    "SyntaxError: invalid syntax\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1.7 Using Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "v0 = 5\n",
    "g = 9.81\n",
    "t = 0.6\n",
    "y = v0*t - 0.5*g*t**2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1.8 Names of Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "initial_velocity = 5\n",
    "acceleration_of_gravity = 9.81\n",
    "TIME = 0.6\n",
    "VerticalPositionOfBall = initial_velocity*TIME - \\\n",
    "                         0.5*acceleration_of_gravity*TIME**2\n",
    "print(VerticalPositionOfBall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1.10 Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "# Program for computing the height of a ball in vertical motion.\n",
    "v0 = 5   # initial velocity\n",
    "g = 9.81 # acceleration of gravity\n",
    "t = 0.6  # time\n",
    "y = v0*t - 0.5*g*t**2  # vertical position\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# -*- coding: ASCII -*-\n",
    "# halløchen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "scheint trotzdem zu klappen... sonst:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1.11 Formatting Text and Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.6 s, the height of the ball is 1.23 m.\n"
     ]
    }
   ],
   "source": [
    "print('At t=%g s, the height of the ball is %.2f m.' % (t, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Format string syntax*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.6 s, the height of the ball is 1.23 m.\n"
     ]
    }
   ],
   "source": [
    "print(\"At t={t:g} s, the height of the ball is {y:.2f} m.\".format(t=t, y=y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "At t=0.600000 s, a ball with\n",
      "initial velocity v0=5.000E+00 m/s\n",
      "is located at the height 1.23 m.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"\n",
    "At t={t:f} s, a ball with\n",
    "initial velocity v0={v0:.3E} m/s\n",
    "is located at the height {y:.2f} m.\n",
    "\"\"\".format(t=t, v0=v0, y=y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1.23457e+09\n"
     ]
    }
   ],
   "source": [
    "# Meiner Meinung nach eine schönere Alternative\n",
    "x = 1234567890\n",
    "print(f\"x = {x:g}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 1.2 Computer Science Glossary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.034199999999999786\n"
     ]
    }
   ],
   "source": [
    "v0 = 3; g = 9.81; t = 0.6\n",
    "y = v0*t - 0.5*g*t**2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# mathematically false, but in programming just an assignment:\n",
    "y = y + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "7\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "y = 3\n",
    "print(y)\n",
    "y = y + 4\n",
    "print(y)\n",
    "y = y*y\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.034199999999999786\n"
     ]
    }
   ],
   "source": [
    "v0=3;g=9.81;t=0.6;y=v0*t-0.5*g*t**2;print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.3 Another Formula: Celsius-Fahrenheit Conversion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3.1 Potential Error: Integer Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "53\n",
      "53\n"
     ]
    }
   ],
   "source": [
    "C = 21\n",
    "F = (9//5)*C + 32\n",
    "print(F)\n",
    "# or:\n",
    "print(9//5*C + 32)\n",
    "\n",
    "# adjusted for python 3: now // remains floor (integer) division, and / is always float division\n",
    "# floor division (a//b) calculates the largest integer c so that c*b <= a (\"how many times does b fit into a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3.3 Avoiding Integer Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "69.80000000000001\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "print(9/5*C + 32)\n",
    "# wow it works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(float(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.4 Evaluating Standard Mathematical Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4.1 Example: Using the Square Root Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.0417064 s and 0.977662 s, the height is 0.2 m.\n"
     ]
    }
   ],
   "source": [
    "v0 = 5\n",
    "g = 9.81\n",
    "yc = 0.2\n",
    "import math\n",
    "t1 = (v0 - math.sqrt(v0**2 - 2*g*yc))/g\n",
    "t2 = (v0 + math.sqrt(v0**2 - 2*g*yc))/g\n",
    "print(\"At t=%g s and %g s, the height is %g m.\" % (t1, t2, yc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.637346500400129\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "# m is now the name of the math module\n",
    "v = m.sin(m.pi)\n",
    "from math import log as ln\n",
    "v = ln(5)\n",
    "from math import sin as s, cos as c, log as ln\n",
    "x = 1234\n",
    "v = s(x)*c(x) + ln(x)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.637346500400129\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "m = math\n",
    "ln = m.log\n",
    "s = m.sin\n",
    "c = m.cos\n",
    "v = s(x)*c(x) + ln(x)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4.2 Example: Computing with $\\text{sinh}(x)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "267.74489404101644 267.74489404101644 267.7448940410163\n"
     ]
    }
   ],
   "source": [
    "from math import sinh, exp, e, pi\n",
    "x = 2*pi\n",
    "r1 = sinh(x)\n",
    "r2 = 0.5*(exp(x) - exp(-x))\n",
    "r3 = 0.5*(e**x - e**(-x))\n",
    "print(r1, r2, r3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4.3 A First Glimpse of Rounding Errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "267.7448940410164369 267.7448940410164369 267.7448940410163232\n"
     ]
    }
   ],
   "source": [
    "print(\"%.16f %.16f %.16f\" % (r1,r2,r3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.5 Interactive Computing    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5.2 Type Conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123.9999 <class 'float'>\n",
      "123 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "X = 123.9999\n",
    "print(X, type(X))\n",
    "X = int(X)\n",
    "print(X, type(X))\n",
    "# Decimals are truncated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5.3 IPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 21\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_ / 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "__ + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# !command für system-befehle. (in der ipython-konsole) like:\n",
    "# !fortune\n",
    "# !date\n",
    "# !ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.6 Complex Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6.1 Complex Arithmetics in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.5+3j)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = 2.5 + 3j\n",
    "u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "# Code (illegal):\n",
    "\"\"\"\n",
    "u = 2.5 + j3\n",
    "\"\"\"\n",
    "\n",
    "# Result:\n",
    "\"\"\"\n",
    "---------------------------------------------------------------------------\n",
    "NameError                                 Traceback (most recent call last)\n",
    "<ipython-input-31-a2fc771f4bd2> in <module>()\n",
    "----> 1 u = 2.5 + j3\n",
    "      2 u\n",
    "\n",
    "NameError: name 'j3' is not defined\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5+6j)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = 2\n",
    "u * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0846166182505192e-05+3.446647537619421e-05j)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u**-6/7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2+3j)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 2; b = 3\n",
    "c = complex(a, b)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Re(c) = 2.0, Im(c) = 3.0, c* = (2-3j)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Re(c) = {c.real}, Im(c) = {c.imag}, c* = {c.conjugate()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6.2 Complex Functions in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "# Code (illegal):\n",
    "\"\"\"\n",
    "from math import sin\n",
    "r = sin(c)\n",
    "\"\"\"\n",
    "\n",
    "# Result:\n",
    "\"\"\"\n",
    "---------------------------------------------------------------------------\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "<ipython-input-51-771d0302db05> in <module>()\n",
    "      1 from math import sin\n",
    "----> 2 r = sin(c)\n",
    "\n",
    "TypeError: can't convert complex to float\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.1545-4.16891j\n",
      "-1.0000+0.0000j\n"
     ]
    }
   ],
   "source": [
    "# Korrekte implementierung mit cmath:\n",
    "from cmath import sin, exp, pi\n",
    "print(f\"{sin(c):g}\")\n",
    "print(f\"{exp(pi*1j):.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6.3 Unified Treatment of Complex and Real Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für Berechnungen, wo komlexe und reelle Zahlen gemischt vorkommen, kann man eine andere Library benutzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from numpy.lib.scimath import sqrt # bzw. from numpy.lib.scimath import * für alle funktionen.\n",
    "\n",
    "# Die gleichen Funktionen die hier enthalten sind, sind auch in scipy und scitools.std enthalten:\n",
    "# from scipy import *\n",
    "# from scitools.std import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `math` (float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "sqrt(4)    # float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "# Code (illegal):\n",
    "\"\"\"\n",
    "sqrt(-1)\n",
    "\"\"\"\n",
    "\n",
    "# Result: \n",
    "\"\"\"\n",
    "---------------------------------------------------------------------------\n",
    "ValueError                                Traceback (most recent call last)\n",
    "<ipython-input-79-75be91ddb76a> in <module>()\n",
    "----> 1 sqrt(-1)\n",
    "\n",
    "ValueError: math domain error\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `cmath` (complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2+0j)\n",
      "1j\n"
     ]
    }
   ],
   "source": [
    "from cmath import sqrt\n",
    "\n",
    "print(sqrt(4))     # complex\n",
    "print(sqrt(-1))    # complex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `numpy.lib.scimath` (mixed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "1j\n"
     ]
    }
   ],
   "source": [
    "from numpy.lib.scimath import sqrt\n",
    "\n",
    "\n",
    "print(sqrt(4))     # float\n",
    "print(sqrt(-1))    # complex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Roots of a quadratic funtion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-1+9.94987437107j) (-1-9.94987437107j)\n"
     ]
    }
   ],
   "source": [
    "a = 1; b = 2; c = 100    # polynomial coefficients\n",
    "from numpy.lib.scimath import sqrt\n",
    "r1 = (-b + sqrt(b**2 - 4*a*c))/(2*a)\n",
    "r2 = (-b - sqrt(b**2 - 4*a*c))/(2*a)\n",
    "print(r1, r2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.58257569496 -5.58257569496\n"
     ]
    }
   ],
   "source": [
    "c = -20    # updated coefficient\n",
    "r1 = (-b + sqrt(b**2 - 4*a*c))/(2*a)\n",
    "r2 = (-b - sqrt(b**2 - 4*a*c))/(2*a)\n",
    "print(r1, r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.7 Symbolic Computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7.1 Basic Differentiation and Integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-g*t + v0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sympy import (\n",
    "    symbols,      # define symbols for symbolic math\n",
    "    diff,         # differentiate expressions\n",
    "    integrate,    # integrate expressions\n",
    "    Rational,     # define rational numbers\n",
    "    lambdify,     # turn symbolic expr. into Python functions\n",
    "    )\n",
    "\n",
    "t, v0, g = symbols('t v0 g')\n",
    "y = v0*t - Rational(1,2)*g*t**2\n",
    "dydt = diff(y, t)\n",
    "dydt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acceleration: -g\n"
     ]
    }
   ],
   "source": [
    "print(\"acceleration:\", diff(y, t, t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-g*t**2/2 + t*v0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y2 = integrate(dydt, t)\n",
    "y2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lambdify:\n",
    "v = lambdify((t, v0, g),       # arguments in v\n",
    "             dydt,             # symbolic expression\n",
    "             dummify=False)    # damit argumente genannt werden dürfen, ohne dies geht nur v(a,b,c) nicht v(t=a,v0=b,g=c)\n",
    "\n",
    "v(t = 0, v0 = 5, g = 9.81)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7.2 Equation Solving"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2*v0/g]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# solve(e, x): solve expression e to x (for e = 0)\n",
    "from sympy import solve\n",
    "roots = solve(y, t)\n",
    "roots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "# inserting values with subs:\n",
    "y1 = y.subs(t, roots[0])\n",
    "y2 = y.subs(t, roots[1])\n",
    "print(y1, y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7.3 Taylor Series and More"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 + t + t**2/2 + O(t**3)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sympy import exp, sin, cos\n",
    "\n",
    "# taylor series of e^t of order 3 around t=0\n",
    "f = exp(t)\n",
    "f.series(t, 0, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + t + \\frac{t^{2}}{2} + \\frac{t^{3}}{6} + \\frac{t^{4}}{24} + \\frac{t^{5}}{120} + \\frac{t^{6}}{720} + \\mathcal{O}\\left(t^{7}\\right)\n"
     ]
    }
   ],
   "source": [
    "# latex encoding\n",
    "from sympy import latex\n",
    "print(latex(f.series(t, 0, 7)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Result:\n",
    "$$1 + t + \\frac{t^{2}}{2} + \\frac{t^{3}}{6} + \\frac{t^{4}}{24} + \\frac{t^{5}}{120} + \\frac{t^{6}}{720} + \\mathcal{O}\\left(t^{7}\\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cos(x + y)\n",
      "sin(x)*cos(y) + sin(y)*cos(x)\n"
     ]
    }
   ],
   "source": [
    "# expanding and simplifying expressions\n",
    "\n",
    "from sympy import symbols, sin, cos, simplify, expand\n",
    "x, y = symbols('x y')\n",
    "f = -sin(x)*sin(y) + cos(x)*cos(y)\n",
    "print(simplify(f))\n",
    "print(expand(sin(x+y), trig=True)) # requires a trigonometric hint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # 1.8 Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.8.2 : Example: Trajectory of a Ball"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution: Onno Eberhard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y1 = 1.5835 m\n"
     ]
    }
   ],
   "source": [
    "from sympy import Symbol, lambdify, tan, cos, pi\n",
    "\n",
    "# Symbols and constants\n",
    "x = Symbol('x')            # horizontal coordinate [m]\n",
    "v0 = Symbol('v0')          # initial velocity [km / h]\n",
    "theta = Symbol('theta')    # angle to x-axis of initial velocity [degrees]\n",
    "y0 = Symbol('y0')          # initial height [m]\n",
    "g = 9.81                   # acceleration of gravity [m / s^2]\n",
    "\n",
    "# Unit conversions\n",
    "theta = theta * pi / 180    # theta: [degrees] -> [rad]\n",
    "v0 = v0 * 1000 / 60 / 60    # v0: [km / h] -> [m / s]\n",
    "\n",
    "# The formula\n",
    "y = x*tan(theta) - (g * x**2)/(2 * v0**2 * cos(theta)**2) + y0\n",
    "f = lambdify('x, v0, theta, y0', y, dummify = False)\n",
    "\n",
    "# Result\n",
    "y1 = f(x = 0.5, v0 = 15, theta = 60, y0 = 1)\n",
    "print(f\"y1 = {y1:g} m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution: Book"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v0    = 15.0 km/h\n",
      "theta = 60 degrees \n",
      "y0    = 1.0 m\n",
      "x     = 0.5 m\n",
      "y     = 1.6 m\n"
     ]
    }
   ],
   "source": [
    "g = 9.81    # m/s**2\n",
    "v0 = 15     # km/h\n",
    "theta = 60  # degrees\n",
    "x = 0.5     # m\n",
    "y0 = 1      # m\n",
    "\n",
    "print(\"\"\"\\\n",
    "v0    = %.1f km/h\n",
    "theta = %d degrees \n",
    "y0    = %.1f m\n",
    "x     = %.1f m\\\n",
    "\"\"\" % (v0, theta, y0, x))\n",
    "\n",
    "from math import pi, tan, cos\n",
    "# Convert v0 to m/s and theta to radians\n",
    "v0 = v0/3.6\n",
    "theta = theta*pi/180\n",
    "\n",
    "y = x*tan(theta) - 1/(2*v0**2)*g*x**2/((cos(theta))**2) + y0\n",
    "\n",
    "print('y     = %.1f m' % y)"
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}