{
"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
}