{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3: Photoelectric Effect, Compton Effect and Bohr's Atomic Theory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 1, Page number 103"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy of photon in joules is 3.37 *10**-19 J\n",
      "energy of photon in eV is 2.1 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda=5893*10**-10;       #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "E=h*c/lamda;              #energy of photon(J)\n",
    "E_eV=E/e;                    #energy of photon(eV)\n",
    "\n",
    "#Result\n",
    "print \"energy of photon in joules is\",round(E*10**19,2),\"*10**-19 J\"\n",
    "print \"energy of photon in eV is\",round(E_eV,1),\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 2, Page number 103"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "threshold wavelength is 2566 angstrom\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "W0=4.84*e;                #work function(J)\n",
    "h=6.624*10**-34;          #planks constant(Js)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "\n",
    "#Calculations\n",
    "lamda0=h*c/W0;       #threshold wavelength(m)\n",
    "\n",
    "#Result\n",
    "print \"threshold wavelength is\",int(lamda0*10**10),\"angstrom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 3, Page number 103"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "work function is 3.943 *10**-19 J\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.624*10**-34;          #planks constant(Js)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda0=5040*10**-10;      #threshold wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "W0=h*c/lamda0;            #work function(J)\n",
    "\n",
    "#Result\n",
    "print \"work function is\",round(W0*10**19,3),\"*10**-19 J\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 4, Page number 104"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "planks constant is 6.612 *10**-34 Joule sec\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda0=5040*10**-10;      #threshold wavelength(m)\n",
    "W0=2.46*e;                #work function(J)\n",
    "\n",
    "#Calculations\n",
    "h=W0*lamda0/c;          #planks constant(Js)\n",
    "\n",
    "#Result\n",
    "print \"planks constant is\",round(h*10**34,3),\"*10**-34 Joule sec\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 5, Page number 104"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of light is 4.144 *10**-7 metre\n",
      "answer varies due to rounding of errors\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.63*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "W0=2.2;                   #work function(eV)\n",
    "Kmax=0.8;                 #work function(eV)\n",
    "\n",
    "#Calculations\n",
    "lamda=h*c/((W0+Kmax)*e);      #wavelength of light(metre)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of light is\",round(lamda*10**7,3),\"*10**-7 metre\"\n",
    "print \"answer varies due to rounding of errors\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 6, Page number 104"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "work function is 1.875 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "Kmax=3*10**-19;           #work function(J)\n",
    "lamda=3310*10**-10;       #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "W0=(h*c/lamda)-Kmax;      #work function(J)\n",
    "W0=W0/e;                  #work function(eV)\n",
    "\n",
    "#Result\n",
    "print \"work function is\",W0,\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 7, Page number 105"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy emitted is 1.679 eV\n",
      "threshold frequency is 5.317 *10**14 Hz\n",
      "answers given in the book are wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "W0=2.2;                   #work function(eV)\n",
    "lamda=3200*10**-10;       #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "Kmax=((h*c/lamda)-(W0*e))/e;           #energy emitted(eV)\n",
    "new0=W0*e/h;                #threshold frequency(Hz)\n",
    "\n",
    "#Result\n",
    "print \"energy emitted is\",round(Kmax,3),\"eV\"\n",
    "print \"threshold frequency is\",round(new0/10**14,3),\"*10**14 Hz\"\n",
    "print \"answers given in the book are wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 8, Page number 105"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum kinetic energy is 3.9 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "W0=2.3;                   #work function(J)\n",
    "lamda=2000*10**-10;        #wavelength of light(metre)\n",
    "\n",
    "#Calculations\n",
    "lamda0=h*c*10**10/(W0*e);         #wavelength of light(angstrom)\n",
    "Kmax=(h*c/(lamda*e))-W0;              #maximum kinetic energy(eV)\n",
    "\n",
    "#Result\n",
    "print \"maximum kinetic energy is\",round(Kmax,1),\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 9, Page number 106"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum kinetic energy is 1.655 eV\n",
      "stopping potential is 1.655 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "new=1.5*10**15;           #frequency(sec-1)\n",
    "new0=1.1*10**15;          #frequency(sec-1)\n",
    "\n",
    "#Calculations\n",
    "Kmax=h*(new-new0)/e;              #maximum kinetic energy(eV)\n",
    "sp=Kmax;                          #stopping potential(eV)\n",
    "\n",
    "#Result\n",
    "print \"maximum kinetic energy is\",Kmax,\"eV\"\n",
    "print \"stopping potential is\",sp,\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 10, Page number 106"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "velocity of electrons is 5.41 *10**5 m/sec\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "W0=2.27*e;                #work function(J)\n",
    "lamda=4000*10**-10;       #wavelength of light(metre)\n",
    "m=9.1*10**-31;\n",
    "\n",
    "#Calculations\n",
    "E=(h*c/lamda)-W0;\n",
    "v=math.sqrt(2*E/m);        #velocity of electrons(m/sec)\n",
    "\n",
    "#Result\n",
    "print \"velocity of electrons is\",round(v/10**5,2),\"*10**5 m/sec\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 11, Page number 107"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plancks constant is 6.57 *10**-34 J-s\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda1=800*10**-10;       #wavelength of light(metre)\n",
    "lamda2=700*10**-10;       #wavelength of light(metre)\n",
    "E1=1.8;                   #energy(eV)\n",
    "E2=4;                     #energy(eV)\n",
    "\n",
    "#Calculations\n",
    "lamda=(1/lamda2)-(1/lamda1);\n",
    "h=(E2-E1)*e/(c*lamda);    #plancks constant(J s)\n",
    "\n",
    "#Result\n",
    "print \"plancks constant is\",round(h*10**34,2),\"*10**-34 J-s\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 12, Page number 107"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum energy of photo electrons is 1.495 eV\n",
      "answer given in the book is wrong\n",
      "work function of tungsten is 5.38 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "c=3*10**8;               #velocity(m/sec)\n",
    "lamda=1800*10**-10;      #wavelength of light(metre)\n",
    "lamda0=2300*10**-10;     #wavelength of light(metre)\n",
    "\n",
    "#Calculations\n",
    "Emax=h*c*((1/lamda)-(1/lamda0))/e;    #maximum energy of photo electrons(eV)\n",
    "W0=h*c/(e*lamda0);           #work function of tungsten(eV)         \n",
    "\n",
    "#Result\n",
    "print \"maximum energy of photo electrons is\",round(Emax,3),\"eV\"\n",
    "print \"answer given in the book is wrong\"\n",
    "print \"work function of tungsten is\",round(W0,2),\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 13, Page number 108"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "threshold frequency is 0.44 *10**15 Hz\n",
      "work function is 1.82 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.6*10**-34;          #planks constant(Js)\n",
    "c=3*10**8;              #velocity(m/sec)\n",
    "lamda0=6800*10**-10;    #threshold wavelength(m)\n",
    "e=1.6*10**-19;          #charge(coulomb)\n",
    "\n",
    "#Calculations\n",
    "new0=c/lamda0;          #threshold frequency(Hz)\n",
    "W0=h*c/(e*lamda0);          #work function(eV)\n",
    "\n",
    "#Result\n",
    "print \"threshold frequency is\",round(new0/10**15,2),\"*10**15 Hz\"\n",
    "print \"work function is\",round(W0,2),\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 14, Page number 109"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stopping potential is 1.404 volt\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.626*10**-34;          #planks constant(Js)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda=2*10**-7;           #wavelength(m)\n",
    "e=1.602*10**-19;          #charge(coulomb)\n",
    "W0=4.8*e;                 #work function(eV)\n",
    "\n",
    "#Calculations\n",
    "V0=(h*c/(lamda*e))-(W0/e);    #stopping potential(volt)\n",
    "\n",
    "#Result\n",
    "print \"stopping potential is\",round(V0,3),\"volt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 15, Page number 109"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stopping potential is 57.146 V\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.63*10**-34;          #planks constant(Js)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda=20*10**-9;           #wavelength(m)\n",
    "e=1.6*10**-19;          #charge(coulomb)\n",
    "W0=5.01*e;                 #work function(eV)\n",
    "\n",
    "#Calculations\n",
    "V0=(h*c/(lamda*e))-(W0/e);    #stopping potential(volt)\n",
    "\n",
    "#Result\n",
    "print \"stopping potential is\",round(V0,3),\"V\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 16, Page number 109"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "work function is 1.75 eV\n",
      "threshold frequency is 4.22 *10**14 cycles/sec\n",
      "answers given in the book are wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.625*10**-34;          #planks constant(Js)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "lamda=5893*10**-10;       #wavelength(m)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "Kmax=0.36;                #energy(eV)\n",
    "\n",
    "#Calculations\n",
    "W0=(h*c/(lamda*e))-Kmax;    #work function(eV)\n",
    "new0=W0*e/h;                #threshold frequency(cycles/sec)\n",
    "\n",
    "#Result\n",
    "print \"work function is\",round(W0,2),\"eV\"\n",
    "print \"threshold frequency is\",round(new0*10**-14,2),\"*10**14 cycles/sec\"\n",
    "print \"answers given in the book are wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 17, Page number 110"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum velocity of electrons is 9.761 *10**5 m/sec\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.62*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;            #charge(coulomb)\n",
    "c=3*10**8;                #velocity(m/sec)\n",
    "W0=5*e;                   #work function(J)\n",
    "lamda=161*10**-9;         #wavelength of light(metre)\n",
    "m=9.1*10**-31;            #mass(kg)\n",
    "\n",
    "#Calculations\n",
    "E=(h*c/lamda)-W0;\n",
    "vmax=math.sqrt(2*E/m);        #velocity of electrons(m/sec)\n",
    "\n",
    "#Result\n",
    "print \"maximum velocity of electrons is\",round(vmax/10**5,3),\"*10**5 m/sec\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 18, Page number 110"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "velocity of photo-electrons is 7.497 *10**5 m/sec\n",
      "retarding potential is 1.598 V\n",
      "answers given in the book are wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "c=3*10**8;               #velocity(m/sec)\n",
    "W0=1.24*e;               #work function(J)\n",
    "lamda=4.36*10**-7;       #wavelength of light(metre)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "\n",
    "#Calculations\n",
    "E=(h*c/lamda)-W0;\n",
    "v=math.sqrt(2*E/m);        #velocity of photo-electrons(m/sec)\n",
    "V0=m*v**2/(2*e);           #retarding potential(V)\n",
    "\n",
    "#Result\n",
    "print \"velocity of photo-electrons is\",round(v/10**5,3),\"*10**5 m/sec\"\n",
    "print \"retarding potential is\",round(V0,3),\"V\"\n",
    "print \"answers given in the book are wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 19, Page number 111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plancks constant is 6.85 *10**-34 J-s\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "c=3*10**8;               #velocity(m/sec)\n",
    "lamda=0.257*10**-10;     #wavelength of light(metre)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "V=50*10**3;              #voltage(V)\n",
    "\n",
    "#Calculations\n",
    "h=e*V*lamda/c;           #plancks constant(J-s)\n",
    "\n",
    "#Result\n",
    "print \"plancks constant is\",round(h*10**34,2),\"*10**-34 J-s\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 20, Page number 111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plancks constant is 6.61 *10**-34 J-s\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "V01=6.6;                   #reverse potential(V) \n",
    "V02=16.5;                  #reverse potential(V) \n",
    "e=1.602*10**-19;           #charge(coulomb)\n",
    "new1=2.2*10**15;           #frequency(sec-1)\n",
    "new2=4.6*10**15;           #frequency(sec-1)\n",
    "\n",
    "#Calculations\n",
    "h=(V02-V01)*e/(new2-new1);   #plancks constant(J-s)\n",
    "\n",
    "#Result\n",
    "print \"plancks constant is\",round(h*10**34,2),\"*10**-34 J-s\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 21, Page number 112"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plancks constant is 6.62 *10**-34 J-s\n",
      "threshold frequency is 4.532 *10**14 sec-1\n",
      "threshold wavelength is 6620.0 angstrom\n",
      "answer for threshold wavelength given in the book varies due to rounding off errors\n",
      "work function is 1.875 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;                 #velocity of light(m/sec)\n",
    "lamda=3310*10**-10;        #wavelength(m)\n",
    "lamda1=5000*10**-10;       #wavelength(m)\n",
    "e=1.6*10**-19;             #charge(coulomb)\n",
    "Emax=3*10**-19;            #energy(J)\n",
    "E1=0.972*10**-19;          #energy(J)\n",
    "\n",
    "#Calculations\n",
    "h=lamda*lamda1*(Emax-E1)/(c*(lamda1-lamda));    #plancks constant(J-s)\n",
    "new0=(c/lamda)-((Emax/h));                      #threshold frequency(sec-1)\n",
    "lamda0=c*10**10/new0;                           #threshold wavelength(angstrom)\n",
    "W=h*new0/e;                                     #work function(eV)\n",
    "\n",
    "#Result\n",
    "print \"plancks constant is\",round(h*10**34,2),\"*10**-34 J-s\"\n",
    "print \"threshold frequency is\",round(new0*10**-14,3),\"*10**14 sec-1\"\n",
    "print \"threshold wavelength is\",lamda0,\"angstrom\"\n",
    "print \"answer for threshold wavelength given in the book varies due to rounding off errors\"\n",
    "print \"work function is\",W,\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 22, Page number 113"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "velocity of electrons is 3.6 *10**5 m/sec\n",
      "work function is 2.106 eV\n",
      "answer for work function given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "v1=1.0*10**6;            #velocity(m/sec)\n",
    "lamda1=2.5*10**-7;       #wavelength(m)\n",
    "lamda2=5.0*10**-7;       #wavelength(m)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "\n",
    "#Calculations\n",
    "x=2*h*c*(lamda1-lamda2)/(m*lamda1*lamda2);\n",
    "v2=math.sqrt(x+(v1**2));     #velocity of electrons(m/sec)\n",
    "W=((h*c/lamda1)-(m*v1**2/2))/e;  #work function(eV)\n",
    "\n",
    "#Result\n",
    "print \"velocity of electrons is\",round(v2*10**-5,1),\"*10**5 m/sec\"\n",
    "print \"work function is\",round(W,3),\"eV\"\n",
    "print \"answer for work function given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 23, Page number 114"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength is 3.003 angstrom\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "lamda=3*10**-10;         #wavelength(m)\n",
    "theta=30*math.pi/180;    #angle(radian)\n",
    "\n",
    "#Calculations\n",
    "lamda_dash=lamda+(2*h*(math.sin(theta/2)**2)/(m0*c));    #wavelength(m)\n",
    "\n",
    "#Result\n",
    "print \"wavelength is\",round(lamda_dash*10**10,3),\"angstrom\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 24, Page number 115"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength is 0.039 angstrom\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "lamda_dash=0.022*10**-10;   #wavelength(m)\n",
    "theta=45*math.pi/180;    #angle(radian)\n",
    "\n",
    "#Calculations\n",
    "lamda=lamda_dash-(h*(1-math.cos(theta)/(m0*c)));    #wavelength(m)\n",
    "\n",
    "#Result\n",
    "print \"wavelength is\",round(lamda*10**10,3),\"angstrom\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 25, Page number 115"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy of electron after interaction is 0.51 MeV\n",
      "energy of photon after interaction is 0.51 MeV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.62*10**-34;          #planks constant(Js)\n",
    "E=1.02;                  #energy(MeV)\n",
    "theta=90*math.pi/180;    #angle(radian)\n",
    "\n",
    "#Calculations\n",
    "delta_lamda=2*h*(math.sin(theta/2)**2)/(m0*c);    #wavelength(m)\n",
    "delta_new=c/delta_lamda;                          #change in frequency(Hz)\n",
    "deltaE=h*delta_new*10**-6/e;                               #change in energy of photon(MeV)\n",
    "Ep=E-deltaE;                                      #energy of photon after interaction(MeV) \n",
    "\n",
    "#Result\n",
    "print \"energy of electron after interaction is\",round(deltaE,2),\"MeV\"\n",
    "print \"energy of photon after interaction is\",round(Ep,2),\"MeV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 26, Page number 116"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength is 0.0485 angstrom\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m=9.1*10**-31;          #mass(kg)\n",
    "h=6.624*10**-34;           #planks constant(Js)\n",
    "theta=180*math.pi/180;    #angle(radian)\n",
    "\n",
    "#Calculations\n",
    "delta_lamda=2*h*math.sin(theta/2)**2/(m0*c);    #change in wavelength(m)\n",
    "\n",
    "#Result\n",
    "print \"wavelength is\",round(delta_lamda*10**10,4),\"angstrom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 27, Page number 116"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frequency after collision is 2.414 *10**19 Hz\n",
      "answer in the book varies due to rounding off errors\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.624*10**-34;         #planks constant(Js)\n",
    "new=3*10**19;            #frequency(Hz)\n",
    "\n",
    "#Calculations\n",
    "delta_lamda=h/(m0*c);    #change in wavelength(m)\n",
    "newdash=(1/new)+(delta_lamda/c);    \n",
    "new_dash=1/newdash;      #frequency after collision(Hz)\n",
    "\n",
    "#Result\n",
    "print \"frequency after collision is\",round(new_dash*10**-19,3),\"*10**19 Hz\"\n",
    "print \"answer in the book varies due to rounding off errors\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 28, Page number 116"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of scattered ray is 1.0485 angstrom\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.624*10**-34;         #planks constant(Js)\n",
    "lamda=1;                 #wavelength(angstrom)\n",
    "\n",
    "#Calculations\n",
    "delta_lamda=2*h*10**10/(m0*c);    #change in wavelength(angstrom)\n",
    "lamda=lamda+delta_lamda;   #wavelength of scattered ray(angstrom)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of scattered ray is\",round(lamda,4),\"angstrom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 29, Page number 117"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength is 0.024 angstrom\n",
      "energy of photon is 81 *10**-15 joule\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.624*10**-34;         #planks constant(Js)\n",
    "\n",
    "#Calculations\n",
    "delta_lamda=h*10**10/(m0*c);    #wavelength(angstrom)\n",
    "E=m0*c**2;                      #energy of photon(joule)\n",
    "\n",
    "#Result\n",
    "print \"wavelength is\",round(delta_lamda,3),\"angstrom\"\n",
    "print \"energy of photon is\",int(E*10**15),\"*10**-15 joule\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 30, Page number 117"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of scattered radiation is 1.83 angstrom\n",
      "velocity of recoil electron is 1.98 *10**6 m/sec\n",
      "answer for velocity given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.62*10**-34;         #planks constant(Js)\n",
    "theta=30*math.pi/180;    #angle(radian)\n",
    "lamda=1.827*10**-10;                 #wavelength(angstrom)\n",
    "\n",
    "#Calculations\n",
    "lamda_sr=h/(m0*c);   \n",
    "lamda_dash=lamda+(lamda_sr*(1-math.cos(theta)));   #wavelength of scattered radiation(m)    \n",
    "lamda_dash=round(lamda_dash*10**10,2)*10**-10;     #wavelength of scattered radiation(m)\n",
    "E=h*c*(lamda_dash-lamda)/(lamda*lamda_dash);       #energy(joule)\n",
    "x=1+(E/(m0*c**2));\n",
    "v=c*math.sqrt(1-((1/x)**2));                       #velocity of recoil electron(m/sec)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of scattered radiation is\",lamda_dash*10**10,\"angstrom\"\n",
    "print \"velocity of recoil electron is\",round(v/10**6,2),\"*10**6 m/sec\"\n",
    "print \"answer for velocity given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 31, Page number 118"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of radiation is 4.844 *10**-12 m\n",
      "answer varies due to rounding of errors\n",
      "energy is 4.0725 *10**-14 joule\n",
      "direction of recoil electron is 26 degrees 36 minutes\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "theta=90*math.pi/180;    #angle(radian)\n",
    "E=510*10**3;             #energy(eV)\n",
    "\n",
    "#Calculations\n",
    "lamda=h*c/(E*e);   \n",
    "lamda_dash=lamda+(h*(1-math.cos(theta))/(m0*c));   #wavelength of radiation(m)    \n",
    "E=h*c*(lamda_dash-lamda)/(lamda*lamda_dash);       #energy(joule)\n",
    "x=h/(lamda*m0*c);\n",
    "tanphi=1/(math.tan(theta/2)*(1+x));\n",
    "phi=math.atan(tanphi);                             #direction of recoil electron(radian)\n",
    "phi=phi*180/math.pi;                               #direction of recoil electron(degrees)\n",
    "phim=60*(phi-int(phi));                            #angle(minutes)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of radiation is\",round(lamda_dash*10**12,3),\"*10**-12 m\"\n",
    "print \"answer varies due to rounding of errors\"\n",
    "print \"energy is\",round(E*10**14,4),\"*10**-14 joule\"\n",
    "print \"direction of recoil electron is\",int(phi),\"degrees\",int(phim),\"minutes\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 32, Page number 119"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of photon is 2.024 angstrom\n",
      "energy of recoil electron is 1.182 *10**-17 joule\n",
      "answer varies due to rounding of errors\n",
      "angle is 44 degrees 39 minutes\n",
      "answer for angle given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "theta=90*math.pi/180;    #angle(radian)\n",
    "lamda=2*10**-10;                 #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "lamda_dash=lamda+(h*(1-math.cos(theta))/(m0*c));    #wavelength of photon(m)\n",
    "K=h*c*(lamda_dash-lamda)/(lamda*lamda_dash);       #energy of recoil electron(joule)\n",
    "tanphi=lamda*math.sin(theta)/(lamda_dash-(lamda*math.cos(theta)));                   \n",
    "phi=math.atan(tanphi)*180/math.pi;                             #angle(degrees)\n",
    "phim=60*(phi-int(phi));                            #angle(minutes)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of photon is\",round(lamda_dash*10**10,3),\"angstrom\"\n",
    "print \"energy of recoil electron is\",round(K*10**17,3),\"*10**-17 joule\"\n",
    "print \"answer varies due to rounding of errors\"                  \n",
    "print \"angle is\",int(phi),\"degrees\",int(phim),\"minutes\"\n",
    "print \"answer for angle given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 33, Page number 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compton shift is 1.255 angstrom\n",
      "energy of radiation is 0.0099 MeV\n",
      "angle of recoil of electron is 44 degrees\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.63*10**-34;          #planks constant(Js)\n",
    "theta=60*math.pi/180;    #angle(radian)\n",
    "E=0.01*10**6;            #energy(eV)\n",
    "\n",
    "#Calculations\n",
    "lamda=h*c/(E*e);         #wavelength of photon(m)\n",
    "lamda_dash=lamda+(h*(1-math.cos(theta))/(m0*c));    #compton shift(m)\n",
    "E_sp=h*c/(10**6*e*lamda_dash); #energy of radiation(MeV)\n",
    "tanphi=lamda/lamda_dash;                   \n",
    "phi=math.atan(tanphi)*180/math.pi;   #angle of recoil of electron(degrees)\n",
    "\n",
    "#Result\n",
    "print \"compton shift is\",round(lamda_dash*10**10,3),\"angstrom\"\n",
    "print \"energy of radiation is\",round(E_sp,4),\"MeV\"\n",
    "print \"angle of recoil of electron is\",int(phi),\"degrees\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 34, Page number 121"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of scattered beam is 1.024 angstrom\n",
      "kinetic energy of recoiling electron is 291.1 eV\n",
      "answer for energy given in the book varies due to rounding off errors\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m0=9.1*10**-31;          #mass(kg)\n",
    "h=6.624*10**-34;         #planks constant(Js)\n",
    "theta=90*math.pi/180;    #angle(radian)\n",
    "lamda=1*10**-10;         #wavelength of photon(m)\n",
    "\n",
    "#Calculations\n",
    "lamda_dash=lamda+(h*(1-math.cos(theta))/(m0*c));    #wavelength of scattered beam(m)\n",
    "lamda_dash=round(lamda_dash*10**10,3)*10**-10;\n",
    "K=h*c*(lamda_dash-lamda)/(e*lamda*lamda_dash);      #kinetic energy of recoiling electron(eV)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of scattered beam is\",lamda_dash*10**10,\"angstrom\"\n",
    "print \"kinetic energy of recoiling electron is\",round(K,1),\"eV\"\n",
    "print \"answer for energy given in the book varies due to rounding off errors\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 35, Page number 122"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "velocity of electron is 2.19 *10**6 m/sec\n",
      "radius of bohr's orbit is 0.5273 angstrom\n",
      "time taken by electron is 1.51 *10**-16 sec\n",
      "rydberg constant is 1.101 *10**7 m-1\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "epsilon0=8.86*10**-12;   #permittivity of free space(coulomb**2/nt-m**2)\n",
    "\n",
    "#Calculations\n",
    "v=e**2/(2*h*epsilon0);   #velocity of electron(m/sec)\n",
    "r1=h**2*epsilon0/(math.pi*m*e**2);     #radius of bohr's orbit(m)\n",
    "T=2*math.pi*r1/v;                      #time taken by electron(sec)\n",
    "R=m*e**4/(8*epsilon0**2*c*h**3);       #rydberg constant(m-1)\n",
    "\n",
    "#Result\n",
    "print \"velocity of electron is\",round(v/10**6,2),\"*10**6 m/sec\"\n",
    "print \"radius of bohr's orbit is\",round(r1*10**10,4),\"angstrom\"\n",
    "print \"time taken by electron is\",round(T*10**16,2),\"*10**-16 sec\"\n",
    "print \"rydberg constant is\",round(R/10**7,3),\"*10**7 m-1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 36, Page number 122"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "radius of second bohr orbit is 2.1094 angstrom\n",
      "energy of electron is -3.406 eV\n",
      "answer given in the book varies due to rounding off errors\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n=2;\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "epsilon0=8.86*10**-12;   #permittivity of free space(coulomb**2/nt-m**2)\n",
    "\n",
    "#Calculations\n",
    "rn=n**2*h**2*epsilon0/(math.pi*m*e**2);      #radius of second bohr orbit(m)\n",
    "En=-m*e**4/(e*8*n**2*h**2*epsilon0**2);      #energy of electron(eV)\n",
    "\n",
    "#Result\n",
    "print \"radius of second bohr orbit is\",round(rn*10**10,4),\"angstrom\"\n",
    "print \"energy of electron is\",round(En,3),\"eV\"\n",
    "print \"answer given in the book varies due to rounding off errors\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 37, Page number 123"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "velocity in hydrogen atom is 1/ 137 c\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)                    \n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "epsilon0=8.85*10**-12;   #permittivity of free space(coulomb**2/nt-m**2)\n",
    "\n",
    "#Calculations\n",
    "v=e**2/(2*h*epsilon0*c);    #velocity in hydrogen atom\n",
    "\n",
    "#Result\n",
    "print \"velocity in hydrogen atom is 1/\",int(round(1/v)),\"c\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 38, Page number 123"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "difference in energy levels is 2.1 eV\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "c=3*10**8;               #velocity of light(m/sec)                    \n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "lamda=590*10**-9;        #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "E=h*c/(e*lamda);         #difference in energy levels(eV)\n",
    "   \n",
    "#Result\n",
    "print \"difference in energy levels is\",round(E,1),\"eV\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 39, Page number 124"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy of electron is 10.24 eV\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n1=1;\n",
    "n2=2;\n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "epsilon0=8.85*10**-12;   #permittivity of free space(coulomb**2/nt-m**2)\n",
    "\n",
    "#Calculations\n",
    "E=3*m*e**4/(e*32*h**2*epsilon0**2);      #energy of electron(eV)\n",
    "\n",
    "#Result\n",
    "print \"energy of electron is\",round(E,2),\"eV\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 40, Page number 124"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy of electron is -13.626 eV\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "h=6.6*10**-34;           #planks constant(Js)\n",
    "epsilon0=8.86*10**-12;   #permittivity of free space(coulomb**2/nt-m**2)\n",
    "rn=0.528*10**-10;        #radius of orbit(m)\n",
    "\n",
    "#Calculations\n",
    "n2=rn*math.pi*m*e**2/(h**2*epsilon0);\n",
    "n=math.sqrt(n2);\n",
    "E1=-m*e**4/(e*8*h**2*epsilon0**2);      #energy of electron(eV)\n",
    "\n",
    "#Result\n",
    "print \"energy of electron is\",round(E1,3),\"eV\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Example number 41, Page number 125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "speed of electron is 2.18 *10**6 m/s\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "epsilon0=8.86*10**-12;   #permittivity of free space(coulomb**2/nt-m**2)\n",
    "r=0.53*10**-10;          #radius of orbit(m)\n",
    "\n",
    "#Calculations\n",
    "v=math.sqrt(1/(4*math.pi*epsilon0))*e/math.sqrt(m*r);     #speed of electron(m/s)\n",
    "\n",
    "#Result\n",
    "print \"speed of electron is\",round(v/10**6,2),\"*10**6 m/s\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 42, Page number 125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength is 4861 *10**-10 m\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n1=2;\n",
    "n2=3;\n",
    "n3=4;\n",
    "R=1;                     #assume\n",
    "lamda1=6563*10**-10;     #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "new1=R*((1/n1**2)-(1/n2**2));\n",
    "new2=R*((1/n1**2)-(1/n3**2));\n",
    "lamda2=new1*lamda1/new2;        #wavelength(m)\n",
    "\n",
    "#Result\n",
    "print \"wavelength is\",int(lamda2*10**10),\"*10**-10 m\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 43, Page number 125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength of 1st member is 1215.37 angstrom\n",
      "answer given in the book varies due to rounding off errors\n",
      "wavelength of 2nd member is 1025.5 angstrom\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n1=1;\n",
    "n2=2;\n",
    "n3=3;\n",
    "R=1;                     #assume\n",
    "lamda1=6563;             #wavelength(angstrom)\n",
    "\n",
    "#Calculations\n",
    "new1=R*((1/n2**2)-(1/n3**2));\n",
    "new2=R*((1/n1**2)-(1/n2**2));\n",
    "lamda2=new1*lamda1/new2;        #wavelength of 1st member(angstrom)\n",
    "new3=R*((1/n1**2)-(1/n3**2));\n",
    "lamda3=new1*lamda1/new3;        #wavelength of 2nd member(angstrom)\n",
    "\n",
    "#Result\n",
    "print \"wavelength of 1st member is\",round(lamda2,2),\"angstrom\"\n",
    "print \"answer given in the book varies due to rounding off errors\"\n",
    "print \"wavelength of 2nd member is\",round(lamda3,1),\"angstrom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 44, Page number 126"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rydberg constant is 109.76 *10**5 per m\n",
      "answer given in the book varies due to rounding off errors\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n1=2;\n",
    "n2=3;\n",
    "lamda=6560*10**-10;             #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "x=(1/n1**2)-(1/n2**2);\n",
    "R=(1/(x*lamda));                #rydberg constant(per m)\n",
    "\n",
    "#Result\n",
    "print \"rydberg constant is\",round(R/10**5,2),\"*10**5 per m\"\n",
    "print \"answer given in the book varies due to rounding off errors\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 45, Page number 126"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rydberg constant is 109.7 *10**5 metre -1\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n1=2;\n",
    "n2=4;\n",
    "lamda=4861*10**-10;             #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "x=(1/n1**2)-(1/n2**2);\n",
    "R=(1/(x*lamda));                #rydberg constant(per m)\n",
    "\n",
    "#Result\n",
    "print \"rydberg constant is\",round(R/10**5,1),\"*10**5 metre -1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 46, Page number 127"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavelength is 3646 angstrom\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n=2;\n",
    "R=1.097*10**7;                #rydberg constant(per m)\n",
    "\n",
    "#Calculations\n",
    "lamda=n**2*10**10/R;                 #wavelength(angstrom)\n",
    "\n",
    "#Result\n",
    "print \"wavelength is\",int(lamda),\"angstrom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 47, Page number 127"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frequency of electron is 6540 *10**12 Hz\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "e=1.6*10**-19;           #charge(coulomb)\n",
    "m=9.1*10**-31;           #mass(kg)\n",
    "h=6.625*10**-34;         #planks constant(Js)\n",
    "epsilon0=8.854*10**-12;  #permittivity of free space(coulomb**2/nt-m**2)\n",
    "n=1;\n",
    "\n",
    "#Calculations\n",
    "new=m*e**4/(4*epsilon0**2*n**3*h**3);      #frequency of electron(Hz)\n",
    "\n",
    "#Result\n",
    "print \"frequency of electron is\",int(new/10**12),\"*10**12 Hz\"\n",
    "print \"answer given in the book is wrong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 48, Page number 127"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rydberg constant is 1.097 *10**7 metre -1\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n=2;\n",
    "lamda=3646*10**-10;                 #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "R=n**2/lamda;                       #rydberg constant(metre -1)\n",
    "\n",
    "#Result\n",
    "print \"rydberg constant is\",round(R/10**7,3),\"*10**7 metre -1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example number 49, Page number 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rydberg constant is 1.0971 *10**7 metre -1\n",
      "answer given in the book is wrong\n"
     ]
    }
   ],
   "source": [
    "#importing modules\n",
    "import math\n",
    "from __future__ import division\n",
    "\n",
    "#Variable declaration  \n",
    "n1=3;\n",
    "n2=4;\n",
    "lamda=1.875*10**-6;                 #wavelength(m)\n",
    "\n",
    "#Calculations\n",
    "x=(1/n1**2)-(1/n2**2);\n",
    "R=(1/(x*lamda));                #rydberg constant(per m)\n",
    "\n",
    "#Result\n",
    "print \"rydberg constant is\",round(R/10**7,4),\"*10**7 metre -1\"\n",
    "print \"answer given in the book is wrong\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}