{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 4 - Approximations and errors in computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_01 Pg No. 63"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 4.3201 has a precision of 10**-4\n",
      "\n",
      "\n",
      " 4.32 has a precision of 10**-2\n",
      "\n",
      "\n",
      " 4.320106 has a precision of 10**-6\n",
      "\n",
      "\n",
      " The number with highest precision is 4.320106\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Greatest precision\n",
    "\n",
    "a = '4.3201'\n",
    "b = '4.32'\n",
    "c = '4.320106'\n",
    "na = len(a)-(a.index('.')+1)\n",
    "print '\\n %s has a precision of 10**-%d\\n'%(a,na)\n",
    "nb = len(b)-(b.index('.')+1)\n",
    "print '\\n %s has a precision of 10**-%d\\n'%(b,nb)\n",
    "nc = len(c)-c.index('.')-1\n",
    "print '\\n %s has a precision of 10**-%d\\n'%(c,nc)\n",
    "e = max(na,nb,nc)\n",
    "if e ==na:\n",
    "    print '\\n The number with highest precision is %s\\n'%(a)\n",
    "elif e == nb:\n",
    "    print '\\n The number with highest precision is %s\\n'%(b)\n",
    "else:\n",
    "    print '\\n The number with highest precision is %s\\n'%(c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_02 Pg No. 63"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95.763 has 5 significant digits\n",
      "\n",
      "0.008472 has 7 significant digits.The leading or higher order zeros are only place holders\n",
      "\n",
      "0.0456000 has 8 significant digits\n",
      "\n",
      "36.0 has 3 significant digits\n",
      "\n",
      "3600.00 has 6 significant digits\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Accuracy of numbers\n",
    "\n",
    "def sd(x):\n",
    "    nd = x.index('.')  #position of point\n",
    "    num = [ord(c) for c in x] #str2code(x)\n",
    "    if (nd)==None and num(length(x)) == 0:\n",
    "        print 'Accuracy is not specified\\n'\n",
    "        n = 0 #\n",
    "    else:\n",
    "        if num[0]>= 1 and (nd==None):\n",
    "            n = len(x)\n",
    "        elif num[1] >= 1 and not((nd==None)):\n",
    "                n = len(x) - 1\n",
    "        else:\n",
    "            for i in range(0,len(x)):\n",
    "                if num[i] >= 1 and num[i] <= 9:\n",
    "                    break;\n",
    "                \n",
    "            \n",
    "            n = len(x)- i + 1\n",
    "    return n\n",
    "        \n",
    "    \n",
    "\n",
    "a = '95.763'\n",
    "na = sd(a)\n",
    "print '%s has %d significant digits\\n'%(a,na)\n",
    "b = '0.008472'\n",
    "nb = sd(b)\n",
    "print '%s has %d significant digits.The leading or higher order zeros are only place holders\\n'%(b,nb)\n",
    "c = '0.0456000'\n",
    "nc = sd(c)\n",
    "print '%s has %d significant digits\\n'%(c,nc)\n",
    "d = '36.0'\n",
    "nd = sd(d)\n",
    "print '%s has %d significant digits\\n'%(d,nd)\n",
    "e = '3600.0'\n",
    "sd(e)\n",
    "f = '3600.00'\n",
    "nf = sd(f)\n",
    "print '%s has %d significant digits\\n'%(f,nf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_03 Pg No. 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 0.1_10 = 0.[0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0] \n",
      " 0.4_10 = 0.[0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0] \n",
      " \n",
      "sum = 0.9921875\n",
      "Note : The answer should be 0.5, but it is not so.This is due to the error in conversion from decimal to binary form.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "from math import floor\n",
    "from numpy import arange,zeros\n",
    "a = 0.1\n",
    "b = 0.4\n",
    "afrac=[];bfrac=[];\n",
    "for i in range(0,8):\n",
    "    afrac.append(floor(a*2))\n",
    "    a = a*2 - floor(a*2)\n",
    "    bfrac.append(floor(b*2))\n",
    "    b = b*2 - floor(b*2)\n",
    "\n",
    "afrac_s = '0' + '.' +(str(afrac)) #string form binary equivalent of a i.e 0.1\n",
    "bfrac_s = '0' + '.' +(str(bfrac))\n",
    "print '\\n 0.1_10 = %s \\n 0.4_10 = %s \\n '%( afrac_s , bfrac_s)\n",
    "    \n",
    "summ=zeros(8)\n",
    "for j in arange(7,0,-1):\n",
    "    summ[j] = afrac[j] + bfrac[j]\n",
    "    if summ[j] > 1:\n",
    "        summ[j] = summ[j]-2\n",
    "        afrac[(j-1)] = afrac[(j-1)] + 1\n",
    "summ_dec = 0\n",
    "for k in arange(7,0,-1):\n",
    "    summ_dec = summ_dec + summ[k]\n",
    "    summ_dec = summ_dec*1.0/2 \n",
    "\n",
    "print 'sum =',summ_dec\n",
    "print 'Note : The answer should be 0.5, but it is not so.This is due to the error in conversion from decimal to binary form.'    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_04 Pg No. 66"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Chooping Method : \n",
      " Approximate x = 0.7526*10**3 \n",
      " Error = 0.0835 \n",
      " \n",
      "\n",
      " Symmetric Rounding :\n",
      " Approximate x = 0.7527*10**3 \n",
      " Error = -0.0165 \n",
      " \n"
     ]
    }
   ],
   "source": [
    "#Rounding-Off\n",
    "\n",
    "fx = 0.7526\n",
    "E =3\n",
    "gx = 0.835\n",
    "d = E - (-1)\n",
    "#Chopping Method\n",
    "Approx_x = fx*10**E\n",
    "Err = gx*10**(E-d)\n",
    "print '\\n Chooping Method : \\n Approximate x = %.4f*10**%d \\n Error = %.4f \\n '%(fx,E,Err)\n",
    "#Symmetric Method\n",
    "if gx >= 0.5:\n",
    "    Err = (gx -1)*10**(-1)\n",
    "    Approx_x = (fx + 10**(-d))*10**E\n",
    "else:\n",
    "    Approx_x = fx*10**E\n",
    "    Err = gx * 10**(E-d)\n",
    "\n",
    "print '\\n Symmetric Rounding :\\n Approximate x = %.4f*10**%d \\n Error = %.4f \\n '%(fx + 10**(-d),E,Err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_05 Pg No. 68"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " a) When first three terms are used \n",
      " Truncation error = 1.402756E-03 \n",
      " \n",
      "\n",
      " b) When first four terms are used \n",
      " Truncation error = 6.942222E-05 \n",
      " \n",
      "\n",
      " c) When first five terms are used \n",
      " Truncation error = 2.755556E-06 \n",
      " \n"
     ]
    }
   ],
   "source": [
    "from scipy.misc import factorial\n",
    "#Truncation Error\n",
    "\n",
    "x = 1.0/5\n",
    "#When first three terms are used\n",
    "Trunc_err = x**3/factorial(3) + x**4/factorial(4) + x**5/factorial(5) + x**6/factorial(6)\n",
    "print '\\n a) When first three terms are used \\n Truncation error = %.6E \\n '%(Trunc_err)\n",
    "\n",
    "#When four terms are used\n",
    "Trunc_err = x**4/factorial(4) + x**5/factorial(5) + x**6/factorial(6)\n",
    "print '\\n b) When first four terms are used \\n Truncation error = %.6E \\n '%(Trunc_err)\n",
    "\n",
    "#When Five terms are used\n",
    "Trunc_err = x**5/factorial(5) + x**6/factorial(6)\n",
    "print '\\n c) When first five terms are used \\n Truncation error = %.6E \\n '%(Trunc_err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_06 Pg No. 68"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " a) When first three terms are used \n",
      " Truncation error = -1.269244E-03 \n",
      " \n",
      "\n",
      " b) When first four terms are used \n",
      " Truncation error = 6.408889E-05 \n",
      " \n",
      "\n",
      " c) When first five terms are used \n",
      " Truncation error = -2.577778E-06 \n",
      " \n"
     ]
    }
   ],
   "source": [
    "from scipy.misc import factorial\n",
    "\n",
    "#Truncation Error\n",
    "\n",
    "x = -1.0/5\n",
    "#When first three terms are used\n",
    "Trunc_err = x**3/factorial(3) + x**4/factorial(4) + x**5/factorial(5) + x**6/factorial(6)\n",
    "print '\\n a) When first three terms are used \\n Truncation error = %.6E \\n '%(Trunc_err)\n",
    "\n",
    "#When four terms are used\n",
    "Trunc_err = x**4/factorial(4) + x**5/factorial(5) + x**6/factorial(6)\n",
    "print '\\n b) When first four terms are used \\n Truncation error = %.6E \\n '%(Trunc_err)\n",
    "\n",
    "#When Five terms are used\n",
    "Trunc_err = x**5/factorial(5) + x**6/factorial(6)\n",
    "print '\\n c) When first five terms are used \\n Truncation error = %.6E \\n '%(Trunc_err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_07 Pg No. 71"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " For Building : \n",
      " Absolute error,  e1 = 5 \n",
      " Relative error , e1_r = 0.17 percent \n",
      " \n",
      "\n",
      " For Beam : \n",
      " Absolute error,  e2 = 5 \n",
      " Relative error , e2_r = 17 percent \n",
      " \n"
     ]
    }
   ],
   "source": [
    "#Absolute and Relative Errors\n",
    "\n",
    "h_bu_t = 2945 #\n",
    "h_bu_a = 2950 #\n",
    "h_be_t = 30 #\n",
    "h_be_a = 35 #\n",
    "e1 = abs(h_bu_t - h_bu_a)\n",
    "e1_r = e1/h_bu_t\n",
    "e2 = abs(h_be_t - h_be_a)\n",
    "e2_r = e2/h_be_t\n",
    "print '\\n For Building : \\n Absolute error,  e1 = %d \\n Relative error , e1_r = %.2f percent \\n '%(e1,e1_r*100) \n",
    "print '\\n For Beam : \\n Absolute error,  e2 = %d \\n Relative error , e2_r = %.2G percent \\n '%(e2,e2_r*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_08 Pg No. 72"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q = 7.9 \n",
      " We can say that the computer can store numbers with 7 significant decimal digits \n",
      " \n"
     ]
    }
   ],
   "source": [
    "from math import log10\n",
    "#Machine Epsilon\n",
    "\n",
    "def Q(p):\n",
    "    q = 1 + (p-1)*log10(2)\n",
    "    return q\n",
    "p = 24\n",
    "q = Q(p)\n",
    "print 'q = %.1f \\n We can say that the computer can store numbers with %d significant decimal digits \\n '%(q,q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_09 Pg No. 75"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " |er_x| <= 0.05 o/o\n",
      " |er_y| <= 0.05o/o \n",
      " ex = 0.617 \n",
      " ey = 0.616 \n",
      " |ez| = 1.233 \n",
      " |er_z| = 61.65o/o \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Propagation of Error\n",
    "\n",
    "x = 0.1234*10**4\n",
    "y = 0.1232*10**4\n",
    "d = 4\n",
    "er_x = 10**(-d + 1)/2\n",
    "er_y = 10**(-d + 1)/2\n",
    "ex = x*er_x\n",
    "ey = y*er_y\n",
    "ez = abs(ex) + abs(ey)\n",
    "er_z = abs(ez)/abs(x-y)\n",
    "\n",
    "print '\\n |er_x| <= %.2f o/o\\n |er_y| <= %.2fo/o \\n ex = %.3f \\n ey = %.3f \\n |ez| = %.3f \\n |er_z| = %.2fo/o \\n'%(er_x *100,er_y*100,ex,ey,ez,er_z*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_10 Pg No. 77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " ex = 0.01175 \n",
      " ey = 0.03370 \n",
      " ez = 0.01725 \n",
      " exy = 0.15839 \n",
      " ew = 0.17564 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Errors in Sequence of Computations\n",
    "\n",
    "x_a = 2.35 #\n",
    "y_a = 6.74 #\n",
    "z_a = 3.45 #\n",
    "ex = abs(x_a)*10**(-3+1)/2\n",
    "ey = abs(y_a)*10**(-3+1)/2\n",
    "ez = abs(z_a)*10**(-3+1)/2\n",
    "exy = abs(x_a)*ey + abs(y_a)*ex\n",
    "ew = abs(exy) + abs(ez)\n",
    "print '\\n ex = %.5f \\n ey = %.5f \\n ez = %.5f \\n exy = %.5f \\n ew = %.5f \\n'%(ex,ey,ez,exy,ew)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_11 Pg No. 77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = 10000.0\n",
      "True w = 10444\n",
      "ew = 444.0\n",
      "er,w = 0.0425124473382\n"
     ]
    }
   ],
   "source": [
    "from math import floor\n",
    "#Addition of Chain of Numbers\n",
    "\n",
    "x = 9678 #\n",
    "y = 678 #\n",
    "z = 78 #\n",
    "d = 4 #  #length of mantissa\n",
    "fx = x/10**4\n",
    "fy = y/10**4\n",
    "fu = fx + fy\n",
    "Eu = 4\n",
    "if fu >= 1:\n",
    "    fu = fu/10\n",
    "    Eu = Eu + 1\n",
    "\n",
    "#since length of mantissa is only four we need to maintain only four places in decimal, so\n",
    "fu = floor(fu*10**4)/10**4\n",
    "u = fu * 10**Eu\n",
    "w = u + z\n",
    "n = len(str(w))\n",
    "w = floor(w/10**(n-4))*10**(n-4) #To maintain length of mantissa = 4\n",
    "print 'w =',w\n",
    "True_w = 10444\n",
    "ew = True_w - w\n",
    "er_w = (True_w - w)/True_w\n",
    "print 'True w =',True_w\n",
    "print 'ew =',ew\n",
    "print 'er,w =',er_w "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_12 Pg No. 77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = 10430.0\n",
      "True w = 10444\n",
      "ew = 14.0\n",
      "er,w = 0.00134048257373\n"
     ]
    }
   ],
   "source": [
    "#Addition of chain Numbers\n",
    "\n",
    "x = 9678 #\n",
    "y = 678 #\n",
    "z = 78 #\n",
    "d = 4 #  #length of mantissa\n",
    "n = max(len( str(y) ) , len(str(z)))\n",
    "fy = y/10**n\n",
    "fz = z/10**n\n",
    "fu = fy + fz\n",
    "Eu = n\n",
    "if fu >= 1:\n",
    "    fu = fu/10\n",
    "    Eu = Eu + 1\n",
    "\n",
    "u = fu * 10**Eu\n",
    "n = max(len( str(x) ) , len(str(u)))\n",
    "fu = u/10**4\n",
    "fx = x/10**4\n",
    "fw = fu + fx\n",
    "Ew = 4\n",
    "if fw >= 1:\n",
    "    fw = fw/10\n",
    "    Ew = Ew + 1\n",
    "\n",
    "#since length of mantissa is only four we need to maintain only four places in decimal, so\n",
    "fw = floor(fw*10**4)/10**4\n",
    "w = fw*10**Ew\n",
    "print 'w =',w\n",
    "True_w = 10444\n",
    "ew = True_w - w\n",
    "er_w = (True_w - w)/True_w\n",
    "print 'True w =',True_w\n",
    "print 'ew =',ew \n",
    "print 'er,w =',er_w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_14 Pg No. 79"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " ex = 5E-04 \n",
      " df(xa) = 1.25 \n",
      " ef = 6.26E-04 \n",
      " er,f = 1.04E-04 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "from scipy.misc import derivative\n",
    "#Absolute & Relative Errors\n",
    "\n",
    "xa = 4.000\n",
    "def f(x):\n",
    "    f = sqrt(x) + x\n",
    "    return f\n",
    "#Assuming x is correct to 4 significant digits\n",
    "ex = 0.5 * 10**(-4 + 1)\n",
    "df_xa = derivative(f,4)\n",
    "ef = ex * df_xa\n",
    "er_f = ef/f(xa)\n",
    "print '\\n ex = %.0E \\n df(xa) = %.2f \\n ef = %.2E \\n er,f = %.2E \\n'%( ex,df_xa,ef,er_f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_15 Pg No. 80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ef = 0.07\n"
     ]
    }
   ],
   "source": [
    "#Error Evaluation\n",
    "\n",
    "x = 3.00 #\n",
    "y = 4.00 #\n",
    "def f(x,y):\n",
    "    f = x**2 + y**2\n",
    "    return f\n",
    "def df_x(x):\n",
    "    df_x = 2*x\n",
    "    return df_x\n",
    "def df_y(y):\n",
    "    df_y = 2*y\n",
    "    return df_y\n",
    "ex = 0.005\n",
    "ey = 0.005\n",
    "ef = df_x(x)*ex + df_y(y)*ey\n",
    "print 'ef =',ef"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_16 Pg No. 82"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 400.0\n",
      "y = 807.0\n",
      "Changing m2 from 2.01 to 2.005\n",
      "\n",
      " x = 800 \n",
      " y = 1607 \n",
      " From the above results we can see that for small change in m2 results in almost 100 percent change in the values of x and y.Therefore, the problem is absolutely ill-conditioned \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Condition and Stability\n",
    "\n",
    "C1 = 7.00 #\n",
    "C2 = 3.00 #\n",
    "m1 = 2.00 #\n",
    "m2 = 2.01 #\n",
    "x = (C1 - C2)/(m2 - m1)\n",
    "y = m1*((C1 - C2)/(m2 - m1)) + C1\n",
    "print 'x =',x\n",
    "print 'y =',y\n",
    "print 'Changing m2 from 2.01 to 2.005'\n",
    "m2 = 2.005\n",
    "x = (C1 - C2)/(m2 - m1)\n",
    "y = m1*((C1 - C2)/(m2 - m1)) + C1\n",
    "print '\\n x = %d \\n y = %d \\n From the above results we can see that for small change in m2 results in almost 100 percent change in the values of x and y.Therefore, the problem is absolutely ill-conditioned \\n'%(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example No. 4_18 Pg No. 84"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z = sqrt(x) - sqrt(y) = 0.0\n",
      "z = ( x-y )/( sqrt(x) + sqrt(y) ) = 0.022\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt, floor\n",
    "#Difference of Square roots\n",
    "\n",
    "x = 497.0 #\n",
    "y = 496.0 #\n",
    "sqrt_x = sqrt(497)\n",
    "sqrt_y = sqrt(496)\n",
    "nx = len( str( floor( sqrt_x ) ) )\n",
    "ny = len( str( floor( sqrt_y ) ) )\n",
    "sqrt_x = floor(sqrt_x*10**(4-nx))/10**(4-nx)\n",
    "sqrt_y = floor(sqrt_y*10**(4-ny))/10**(4-ny)\n",
    "z1 = sqrt_x - sqrt_y\n",
    "print 'z = sqrt(x) - sqrt(y) =',z1\n",
    "z2 = ( x -y)/(sqrt_x + sqrt_y)\n",
    "if z2 < 0.1:\n",
    "    z2 = z2*10**4\n",
    "    nz = len(str(floor(z2)))\n",
    "    z2 = floor(z2*10**(4-nz))/10**(8-nz)\n",
    "\n",
    "print  'z = ( x-y )/( sqrt(x) + sqrt(y) ) =',z2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4_21 Pg No. 85"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Truncation Error = 0.000505399929331\n",
      "calculated e**x using roundoff = -0.000459999999793\n",
      "actual e**x =  4.53999297625e-05\n",
      "Here we can see the difference between calculated e**x and actual e**x this is due to trucation error (which is greater than final value of e**x ), so the roundoff error totally dominates the solution\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "from math import exp,floor\n",
    "x = -10\n",
    "T_act=[1]\n",
    "T_trc=[1]\n",
    "e_x_cal = 1\n",
    "TE=[]\n",
    "for i in range(0,100):\n",
    "    T_act.append(T_act[i]*x/(i+1))\n",
    "    T_trc.append(floor(T_act[i+1]*10**5)/10**5)\n",
    "    TE.append(abs(T_act[i+1]-T_trc[i+1]))\n",
    "    e_x_cal = e_x_cal + T_trc[i+1]\n",
    "e_x_act = exp(-10)\n",
    "Sum=0\n",
    "for s in TE:\n",
    "    Sum+=s\n",
    "print 'Truncation Error =',Sum\n",
    "print 'calculated e**x using roundoff =',e_x_cal\n",
    "print 'actual e**x = ',e_x_act\n",
    "print 'Here we can see the difference between calculated e**x and actual e**x this is due to trucation error (which is greater than final value of e**x ), so the roundoff error totally dominates the solution'"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}