Lec_02_Python_intro_II.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Physics 300 \n",
    "## Computational Physics I (Fall 2018)\n",
    "## BPB-248, Mon/Wed 02:30 - 03:45 pm \n",
    "\n",
    "|Instructor| Prof. Qiang Zhu|\n",
    "|--|-------------------------------|\n",
    "|Email | qiang.zhu@unlv.edu|\n",
    "|Website|http://www.physics.unlv.edu/~qzhu/|\n",
    "|Office| BPB 232|\n",
    "|Office hours | Mon/Wed 03:45 - 05:00 pm |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 Python Basics\n",
    "## 2.1 User inputs\n",
    "input( ) accepts input and stores it as a string. Hence, if the user inputs a integer, the code should convert the string to an integer and then proceed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type a value for x: 4\n",
      "type a value for y: 9\n",
      "x+y= 49\n"
     ]
    }
   ],
   "source": [
    "x=input(\"type a value for x: \")\n",
    "y=input(\"type a value for y: \")\n",
    "print('x+y=',x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "print(4+9)\n",
    "print('4'+'9')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type a value for x: 4\n",
      "type a value for y: 9\n",
      "x+y= 13\n"
     ]
    }
   ],
   "source": [
    "#Is there anything wrong, how to fix it?\n",
    "x=int(input(\"type a value for x: \"))\n",
    "y=int(input(\"type a value for y: \"))\n",
    "print('x+y=',x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "Let us revisit the program which we wrote for the Rydberg equation\n",
    "\n",
    "$$\\frac{1}{\\lambda} = R (\\frac{1}{m^2} - \\frac{1}{n^2})$$\n",
    "\n",
    "Where $R$ is the Rydberg constant = 1.097 $\\times$ $10^{-2} \\text{nm}^{-1}$, $m$ and $n$ are positive integers. \n",
    "For a given value of $m$, $\\lambda$ is given for this formula for all $n>m$ series, \n",
    "Can we write a program to let the user define m and n from the terminal?\n",
    "\n",
    "```python\n",
    "R = 1.097e-2\n",
    "for m in [1,2,3]:\n",
    "    print \"Series for m = \", m\n",
    "    for k in [1,2,3,4,5]:\n",
    "        n = m + k\n",
    "        invlambda = R*(1.0/m**2 - 1/n**2)\n",
    "        print(\"n=\",n, \"  \", 1/invlambda, \"nm\")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type a value for m: 3\n",
      "type a value for n: 2\n",
      "n has to be greater than m, try again\n"
     ]
    }
   ],
   "source": [
    "# A program to calculate the wavelength from m,n series proived by the user\n",
    "R = 1.097e-2\n",
    "m=int(input(\"type a value for m: \"))\n",
    "n=int(input(\"type a value for n: \"))\n",
    "\n",
    "if n>m:     \n",
    "    invlambda = R*(1.0/m**2 - 1/n**2)\n",
    "    print(\"m=\",m, \", n=\",n, ', wavelength is', 1/invlambda, \"nm\") \n",
    "else:\n",
    "    print('n has to be greater than m, try again')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Quiz:\n",
    "Here you can actually assign any values to m and n.\n",
    "\n",
    "But the definition says that n must be greater than m! \n",
    "\n",
    "Can we make something to remind the user to retype it if the value is wrong?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type a positive integer value for m: 5\n",
      "type positive integer value greater than m for n: 3\n",
      "n must be greater than  5 ,  please enter another number:\n",
      "type positive integer value greater than m for n: 5\n",
      "n must be greater than  5 ,  please enter another number:\n",
      "type positive integer value greater than m for n: 8\n",
      "m= 5 , n= 8 , wavelength is 3739.8031928569753 nm\n"
     ]
    }
   ],
   "source": [
    "# Try to add something here to remind the user not to assign ridiculus numbers!\n",
    "R = 1.097e-2\n",
    "good_m = False\n",
    "while good_m is False:\n",
    "    m=int(input(\"type a positive integer value for m: \"))\n",
    "    if m <= 0:\n",
    "        print(\"m must be positive integer, please enter another number:\")\n",
    "    else:\n",
    "        good_m = True\n",
    "\n",
    "good_n = False\n",
    "while good_n is False:        \n",
    "    n=int(input(\"type positive integer value greater than m for n: \"))\n",
    "    if n<=m:\n",
    "        print(\"n must be greater than \", m, \",  please enter another number:\")\n",
    "    else:\n",
    "        good_n = True\n",
    "invlambda = R*(1.0/m**2 - 1/n**2)\n",
    "print(\"m=\",m, \", n=\",n, ', wavelength is', 1/invlambda, \"nm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Control Flow Statements\n",
    "## If\n",
    "```python\n",
    "if some_condition:\n",
    "    do something\n",
    "```\n",
    "\n",
    "## If-else\n",
    "```python\n",
    "if some_condition:\n",
    "    do something\n",
    "else:\n",
    "    do something else\n",
    "```\n",
    "    \n",
    "## if-elif-else\n",
    "```python\n",
    "if some_condition:\n",
    "    do case 1\n",
    "elif some_condition:\n",
    "    do case 2\n",
    "else:\n",
    "    do case 3\n",
    "```\n",
    "    \n",
    "## for loop\n",
    "```python\n",
    "for variable in something:\n",
    "    do something\n",
    "```\n",
    "    \n",
    "## While\n",
    "```python\n",
    "while some_condition:\n",
    "    algorithm\n",
    "```\n",
    "## Break\n",
    "\n",
    "    As the name says. It is used to break out of a loop when a condition becomes true when executing the loop.\n",
    "\n",
    "## Continue\n",
    "    This continues the rest of the loop. Sometimes when a condition is satisfied there are chances of the loop getting terminated. This can be avoided using continue statement.\n",
    "    \n",
    "## Tips\n",
    "1, Be aware that you must end up with : sign, when you write the sentence of condition\n",
    "\n",
    "2, Indentation is required by python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Quiz:\n",
    "What is the key diffrence between for and while?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Complete your code on the calculation of wave length!\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Function\n",
    "\n",
    "Most of the times, In a algorithm the statements keep repeating and __it will be a tedious job to execute the same statements again and again__ and will consume a lot of memory and is not efficient. \n",
    "\n",
    "In order to avoid this, we can define a function here\n",
    "\n",
    "This is the basic syntax of a function\n",
    "\n",
    "```python\n",
    "def funcname(arg1, arg2,... argN):\n",
    "\n",
    "    ''' Document String'''\n",
    "\n",
    "    statements\n",
    "\n",
    "    return <value>\n",
    "```\n",
    "Read the above syntax as, A function by name \"funcname\" is defined, which accepts arguements \"arg1,arg2,....argN\". The function is documented and it is '''Document String'''. The function after executing the statements returns a \"value\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 5]\n"
     ]
    }
   ],
   "source": [
    "#indexing\n",
    "a = [1, 2, 4, 5, 5, 6, 8]\n",
    "#print(a[0])\n",
    "print(a[3:-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def my_max(lists):\n",
    "    \"calculate the maximum element from the given list\"\n",
    "    ans = lists[0]\n",
    "    for i in lists:\n",
    "        if ans<i:\n",
    "            ans=i\n",
    "    return ans\n",
    "print(a)\n",
    "print(my_max(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type a value for m: 3\n",
      "type a value for n: 4\n",
      "m= 3 , n= 4 , wavelength is 820.419325433 nm\n"
     ]
    }
   ],
   "source": [
    "# Try to add something here to remind the user not to assign ridiculus numbers!\n",
    "\n",
    "R = 1.097e-2\n",
    "\n",
    "def calc_lambda(m,n):\n",
    "    '''This is a function to calculate lambda based on m and n'''\n",
    "    return 1/(R*(1.0/m**2 - 1/n**2))\n",
    "\n",
    "\n",
    "good_m = False\n",
    "while good_m is False:\n",
    "    m=int(input(\"type a value for m: \"))\n",
    "    if m <= 0:\n",
    "        print(\"m must be positive integer, please enter another number:\")\n",
    "    else:\n",
    "        good_m = True\n",
    "\n",
    "good_n = False\n",
    "while good_n is False:        \n",
    "    n=int(input(\"type a value for n: \"))\n",
    "    if n<=m:\n",
    "        print \"n must be greater than \", m, \"please enter another number:\"\n",
    "    else:\n",
    "        good_n = True\n",
    "\n",
    "lambda_w = calc_lambda(m,n)\n",
    "print \"m=\",m, \", n=\",n, ', wavelength is', lambda_w, \"nm\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5, 5, 6, 8]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(a)\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fibonacci number\n",
    "In mathematics, the Fibonacci numbers are the numbers in the following integer sequence, called the Fibonacci sequence, and characterized by the fact that every number after the first two is the sum of the two preceding ones:\n",
    "\n",
    "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[1]\n",
      "[1, 1]\n",
      "[1, 1, 2]\n",
      "[1, 1, 2, 3]\n",
      "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]\n"
     ]
    }
   ],
   "source": [
    "#Write a function here to compute fibonacci number\n",
    "def Fibonacci(N):\n",
    "    '''\n",
    "    This program is to calculate fibonacci number\n",
    "    Input: N (must be a positive integer number) \n",
    "    output: the Fibonacci series\n",
    "    '''\n",
    "\n",
    "    Fib_series = []\n",
    "    \n",
    "    for i in range(1,N+1):\n",
    "        if len(Fib_series)<=1:\n",
    "            Fib_series.append(1)\n",
    "        else:\n",
    "            Fib_series.append(Fib_series[-1] + Fib_series[-2])\n",
    "    return Fib_series\n",
    "\n",
    "print(Fibonacci(-1))\n",
    "print(Fibonacci(1))\n",
    "print(Fibonacci(2))\n",
    "print(Fibonacci(3))\n",
    "print(Fibonacci(4))\n",
    "print(Fibonacci(200))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda Functions\n",
    "These are small functions which are not defined with any name and carry a single expression whose result is returned. Lambda functions comes very handy when operating with lists. These function are defined by the keyword lambda followed by the variables, a colon and the respective expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = lambda x: x * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Exercise \n",
    "### Combinatorics and Two-state systems\n",
    "\n",
    "Suppose we are flipping three coins. How many possible outcomes are there?\n",
    "\n",
    "|Coin 1 | Coin 2| Coin 3|\n",
    "|:-----:|:-----:|:-----:|\n",
    "|H|H|H|\n",
    "|H|H|T|\n",
    "|H|T|H|\n",
    "|T|H|H|\n",
    "|H|T|T|\n",
    "|T|T|H|\n",
    "|T|H|T|\n",
    "|T|H|T|\n",
    "\n",
    "Since all coins are indistinguishable, we are more interested in how many heads are there in all outcomes?\n",
    "By simply counting the number from the above table, we know\n",
    "\n",
    "3 heads, HHH \n",
    "\n",
    "2 heads, HHT, HTH, THH\n",
    "\n",
    "1 head, HTT, TTH, THT\n",
    "\n",
    "0 head, TTT\n",
    "\n",
    "each state is called _microstate_.\n",
    "\n",
    "_microstate_: Each of the eight different outcomes\n",
    "\n",
    "_macrostate_: How many heads are there in all outcomes\n",
    "\n",
    "Although each microstate is equal to exist, but macrostates have different probabilies to explored. Clearly,\n",
    "2 heads is more likely to be found than 3 heads. Here we introduce another quantity,\n",
    "\n",
    "_multiplicity_ ($\\Omega$): the number of microstates in a given macrostate.\n",
    "\n",
    "In the context of coin games, let's define $\\Omega(n)$ as the number of cases when we get $n$ heads. If the total number\n",
    "of coins is $N$, we can derive the equations as follows,\n",
    "\n",
    "$$\\Omega(N,n) = = \\frac{N!}{n!\\cdot(N-n)!} = \\binom{N}{n}$$\n",
    "\n",
    "What will happen if we increase $N$. Let's try $N$ with different numbers (say 5, 10, 20) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type a value for N: 5\n",
      "when n= 0 ;  the multiplicity is 1\n",
      "when n= 1 ;  the multiplicity is 5\n",
      "when n= 2 ;  the multiplicity is 10\n",
      "when n= 3 ;  the multiplicity is 10\n",
      "when n= 4 ;  the multiplicity is 5\n",
      "when n= 5 ;  the multiplicity is 1\n"
     ]
    }
   ],
   "source": [
    "#Multiplicity calculation\n",
    "def factor(N):\n",
    "    if N == 0 or N == 1:\n",
    "        return 1\n",
    "    else: \n",
    "        total = 1\n",
    "        for i in range(2,N+1):\n",
    "            total *= i\n",
    "        return total     \n",
    "\n",
    "def Multiplicity(N,n):\n",
    "    return factor(N)/factor(n)/factor(N-n)\n",
    "    \n",
    "N=int(raw_input(\"type a value for N: \"))\n",
    "    \n",
    "    \n",
    "for n in range(N+1):\n",
    "    print 'when n=', n, ';  the multiplicity is',  Multiplicity(N,n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2.5 Homework\n",
    "### The Einstein Model of a Solid\n",
    "\n",
    "A solid crystal is composed of atoms. Einstein proposed that a model that each atom is pretty much a harmonic oscillator \n",
    "because it is attached by some springs to the adjacent atoms in the crystal lattice.\n",
    "![Image of Einstein solid](https://github.com/qzhu2017/2017-cmp/blob/master/img/einsteins-solid.jpg?raw=true)\n",
    "\n",
    "In each oscillator, the energy has quantized separation (0,1,2,.....)\n",
    "Suppose there are only 3 oscillators, the energy could be\n",
    "\n",
    "|Oscillator | 1| 2|\n",
    "|:-----:|:-----:|:-----:|\n",
    "|Energy|0|0|\n",
    "| |1|0|\n",
    "| |0|1|\n",
    "| |1|1|\n",
    "| |2|0|\n",
    "| |0|2|\n",
    "Namely,\n",
    "\n",
    "   When the total energy ($q$) is 0, $\\Omega$=1 \n",
    "\n",
    "   When the total energy ($q$) is 1, $\\Omega$=2 \n",
    "\n",
    "   When the total energy ($q$) is 2, $\\Omega$=3\n",
    "\n",
    "The generalized form is\n",
    " $$\\Omega(N, q) = \\binom{q+N-1}{q} = \\frac{(q+N-1)!}{q!(N-1)!}$$\n",
    " \n",
    " \n",
    "Try to prove this formula and write a code to compute $\\Omega$ for any ($N$, $q$)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Fibonacci(N):\n",
    "    '''\n",
    "    This program is to calculate fibonacci number using return\n",
    "    Input: N (must be a positive integer number) \n",
    "    output: the Fibonacci series\n",
    "    '''\n",
    "\n",
    "    Fib_series = []\n",
    "    for i in range(1,N+1):\n",
    "        if len(Fib_series)<=1:\n",
    "            return 1\n",
    "        else:\n",
    "            Fib_series.append(b)\n",
    "            a, b = b, a + b\n",
    "    return Fib_series[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "530 ns ± 35.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit(Fibonacci(10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Fibonacci2(N):\n",
    "    '''\n",
    "    This program is to calculate fibonacci number using yield\n",
    "    Input: N (must be a positive integer number) \n",
    "    output: the Fibonacci series\n",
    "    '''\n",
    "\n",
    "    Fib_series = []\n",
    "    a = b = 1\n",
    "    for i in range(1,N+1):\n",
    "        if len(Fib_series)<=1:\n",
    "            yield 1\n",
    "        else:\n",
    "            yield a\n",
    "            a, b = b, a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225 ns ± 5.18 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit(Fibonacci2(10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "328350"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(x ** 2 for x in range(100)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "328350"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([x ** 2 for x in range(100)]) "
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}