pax_global_header 0000666 0000000 0000000 00000000064 12544046010 0014506 g ustar 00root root 0000000 0000000 52 comment=23f01cbdf1496000fa6e5d0a2f6be91dd5c03cf6
pycode-browser-1.02/ 0000775 0000000 0000000 00000000000 12544046010 0014374 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/ 0000775 0000000 0000000 00000000000 12544046010 0015246 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/ 0000775 0000000 0000000 00000000000 12544046010 0016322 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Arrays/ 0000775 0000000 0000000 00000000000 12544046010 0017563 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Arrays/cross.py 0000775 0000000 0000000 00000000144 12544046010 0021270 0 ustar 00root root 0000000 0000000 #Example cross.py
from numpy import *
a = array([1,2,3])
b = array([4,5,6])
c = cross(a,b)
print c
pycode-browser-1.02/Code/Maths/Arrays/fileio.py 0000775 0000000 0000000 00000000161 12544046010 0021405 0 ustar 00root root 0000000 0000000 #Example fileio.py
from numpy import *
a = arange(10)
a.tofile('myfile.dat')
b = fromfile('myfile.dat')
print b
pycode-browser-1.02/Code/Maths/Arrays/inv.py 0000775 0000000 0000000 00000000223 12544046010 0020731 0 ustar 00root root 0000000 0000000 #Example inv.py
from numpy import *
a = array([ [4,1,-2], [2,-3,3], [-6,-2,1] ], dtype='float')
ainv = linalg.inv(a)
print ainv
print dot(a,ainv)
pycode-browser-1.02/Code/Maths/Arrays/numpy1.py 0000775 0000000 0000000 00000000146 12544046010 0021372 0 ustar 00root root 0000000 0000000 #Example numpy1.py
from numpy import *
x = array( [1,2] ) # Make array from list
print x , type(x)
pycode-browser-1.02/Code/Maths/Arrays/numpy2.py 0000775 0000000 0000000 00000000313 12544046010 0021367 0 ustar 00root root 0000000 0000000 #Example numpy2.py
from numpy import *
a = arange(1.0, 2.0, 0.1) # start, stop & step
print a
b = linspace(1,2,11)
print b
c = ones(5)
print c
d = zeros(5)
print d
e = random.rand(5)
print e
pycode-browser-1.02/Code/Maths/Arrays/numpy3.py 0000775 0000000 0000000 00000000207 12544046010 0021372 0 ustar 00root root 0000000 0000000 #Example numpy3.py
from numpy import *
a = [ [1,2] , [3,4] ] # make a list of lists
x = array(a) # and convert to an array
print a
pycode-browser-1.02/Code/Maths/Arrays/numpy4.py 0000775 0000000 0000000 00000000161 12544046010 0021372 0 ustar 00root root 0000000 0000000 #Example numpy4.py
from numpy import *
a = arange(10)
print a
a = a.reshape(5,2) # 5 rows and 2 columns
print a
pycode-browser-1.02/Code/Maths/Arrays/numpy5.py 0000775 0000000 0000000 00000000220 12544046010 0021367 0 ustar 00root root 0000000 0000000 #Example numpy5.py
from numpy import *
a = array([ [1.0, 2.0] , [3.0, 4.0] ]) # make a numpy array
print a
print a * 5
print a * a
print a / a
pycode-browser-1.02/Code/Maths/Arrays/oper.py 0000775 0000000 0000000 00000000162 12544046010 0021104 0 ustar 00root root 0000000 0000000 #Example oper.py
from numpy import *
a = array([[2,3], [4,5]])
b = array([[1,2], [3,0]])
print a + b
print a * b
pycode-browser-1.02/Code/Maths/Arrays/reshape.py 0000775 0000000 0000000 00000000126 12544046010 0021566 0 ustar 00root root 0000000 0000000 #Example reshape.py
from numpy import *
a = arange(20)
b = reshape(a, [4,5])
print b
pycode-browser-1.02/Code/Maths/Calculus/ 0000775 0000000 0000000 00000000000 12544046010 0020075 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Calculus/compareEuRK4.py 0000775 0000000 0000000 00000001163 12544046010 0022714 0 ustar 00root root 0000000 0000000 '''
Sine function is calculated using its derivative, cosine.
Using Euler and RK4 method, with
'''
import math
def rk4(x, y, yprime, dx = 0.01): # x, y , derivative, stepsize
k1 = dx * yprime(x)
k2 = dx * yprime(x + dx/2.0)
k3 = dx * yprime(x + dx/2.0)
k4 = dx * yprime(x + dx)
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0 # for Euler
z = 0.0 # for RK4
while x < math.pi:
print x, y - math.sin(x), z - math.sin(x) # errors
y = y + h * math.cos(x) # Euler method
z = rk4(x,z,math.cos,h) # Runge-Kutta method
x = x + h
pycode-browser-1.02/Code/Maths/Calculus/diff.py 0000775 0000000 0000000 00000000277 12544046010 0021370 0 ustar 00root root 0000000 0000000 #Example diff.py
def f(x):
return x**3
def deriv(x,dx=0.005):
df = f(x+dx/2)-f(x-dx/2)
return df/dx
print deriv(2.0)
print deriv(2.0, 0.1)
print deriv(2.0, 0.0001)
pycode-browser-1.02/Code/Maths/Calculus/diff1.py 0000775 0000000 0000000 00000000742 12544046010 0021446 0 ustar 00root root 0000000 0000000 from pylab import *
dx = 0.1 # value of x increment
x = arange(0,10, dx)
y = sin(x)
yprime = [] # empty list
for k in range(99): # from 100 points we get 99 diference values
dy = y[k+1]-y[k]
yprime.append(dy/dx)
x1 = x[:-1] # A new array without the last element
x1 = x1 + dx/2 # The derivative corresponds to the middle point
plot(x1, yprime, '+')
plot(x1, cos(x1)) # Cross check with the analitic value
show()
pycode-browser-1.02/Code/Maths/Calculus/euler.py 0000775 0000000 0000000 00000000273 12544046010 0021570 0 ustar 00root root 0000000 0000000 import math
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0
while x < math.pi:
print x, y, math.sin(x)
y = y + h * math.cos(x) # Euler method
x = x + h
pycode-browser-1.02/Code/Maths/Calculus/fit1.py 0000775 0000000 0000000 00000000737 12544046010 0021324 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
from scipy.optimize import leastsq
def err_func(p,y,x):
A,k,theta = p
return y - A*sin(2*pi*k*x+theta)
def evaluate(x,p):
return p[0] * sin(2*pi*p[1]*x+p[2])
ax = arange(0, 0.2, 0.001)
A,k,theta = 5, 50.0, pi/3
y_true = A*sin(2*pi*k*ax+theta)
y_meas = y_true + 0.2*randn(len(ax))
p0 = [6, 50.0, pi/3]
plsq = leastsq(err_func,p0,args=(y_meas,ax))
print plsq
plot(ax,y_true)
plot(ax,y_meas,'o')
plot(ax,evaluate(ax,plsq[0]))
show()
pycode-browser-1.02/Code/Maths/Calculus/fit2.py 0000775 0000000 0000000 00000000737 12544046010 0021325 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
from scipy.optimize import leastsq
def err_func(p,y,x):
A,k,theta = p
return y - A*sin(2*pi*k*x+theta)
def evaluate(x,p):
return p[0] * sin(2*pi*p[1]*x+p[2])
ax = arange(0, 0.2, 0.001)
A,k,theta = 5, 50.0, pi/3
y_true = A*sin(2*pi*k*ax+theta)
y_meas = y_true + 0.2*randn(len(ax))
p0 = [6, 50.0, pi/3]
plsq = leastsq(err_func,p0,args=(y_meas,ax))
print plsq
plot(ax,y_true)
plot(ax,y_meas,'o')
plot(ax,evaluate(ax,plsq[0]))
show()
pycode-browser-1.02/Code/Maths/Calculus/rk4.py 0000775 0000000 0000000 00000001040 12544046010 0021145 0 ustar 00root root 0000000 0000000 '''
Solving initial value problem using 4th order Runge-Kutta method.
Sine function is calculated using its derivative, cosine.
'''
import math
def rk4(x, y, yprime, dx = 0.01): # x, y , derivative, stepsize
k1 = dx * yprime(x)
k2 = dx * yprime(x + dx/2.0)
k3 = dx * yprime(x + dx/2.0)
k4 = dx * yprime(x + dx)
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0
while x < math.pi:
print x, y, math.sin(x)
y = rk4(x,y,math.cos) # Runge-Kutta method
x = x + h
pycode-browser-1.02/Code/Maths/Calculus/rk_sin.py 0000775 0000000 0000000 00000001131 12544046010 0021733 0 ustar 00root root 0000000 0000000 from pylab import *
def func(t):
return cos(t)
def rk4(s,t):
k1 = dt * func(t)
k2 = dt * func(t + dt/2.0)
k3 = dt * func(t + dt/2.0)
k4 = dt * func(t + dt)
return s + ( k1/6 + k2/3 + k3/3 + k4/6 )
t = 0.0 # Stating angle
dt = 0.01 # value of angle increment
val = 0.0 # value of the 'sine' function at t = 0
tm = [0.0] # List to store theta values
res = [0.0] # RK4 results
while t < 2*pi:
val = rk4(val,t) # get the new value
t = t + dt
tm.append(t)
res.append(val)
plot(tm, res,'+')
plot(tm, sin(tm)) # compare with actual curve
show()
pycode-browser-1.02/Code/Maths/Calculus/trapez.py 0000775 0000000 0000000 00000000447 12544046010 0021764 0 ustar 00root root 0000000 0000000 from math import *
def sqr(a):
return a**2
def trapez(f, a, b, n):
h = (b-a) / n
sum = f(a)
for i in range (1,n):
sum = sum + 2 * f(a + h * i)
sum = sum + f(b)
return 0.5 * h * sum
print trapez(sin,0.,pi,100)
print trapez(sqr,0.,2.,100)
print trapez(sqr,0,2,100) # Why the error ?
pycode-browser-1.02/Code/Maths/Calculus/vdiff.py 0000775 0000000 0000000 00000000407 12544046010 0021551 0 ustar 00root root 0000000 0000000 #Example vdiff.py
from pylab import *
def f(x):
return sin(x)
def deriv(x,dx=0.005):
df = f(x+dx/2)-f(x-dx/2)
return df/dx
vecderiv = vectorize(deriv)
x = linspace(-2*pi, 2*pi, 200)
y = vecderiv(x)
plot(x,y,'+')
plot(x,cos(x))
show()
pycode-browser-1.02/Code/Maths/FamousCurves/ 0000775 0000000 0000000 00000000000 12544046010 0020744 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/FamousCurves/archi.py 0000775 0000000 0000000 00000000173 12544046010 0022410 0 ustar 00root root 0000000 0000000 #Example archi.py
from pylab import *
a = 2
th= linspace(0, 10*pi,200)
r = a*th
polar(th,r)
axis([0, 2*pi, 0, 70])
show()
pycode-browser-1.02/Code/Maths/FamousCurves/archi.txt 0000775 0000000 0000000 00000001612 12544046010 0022576 0 ustar 00root root 0000000 0000000 This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.
pycode-browser-1.02/Code/Maths/FamousCurves/astro.py 0000775 0000000 0000000 00000000175 12544046010 0022454 0 ustar 00root root 0000000 0000000 #Example astro.py
from pylab import *
a = 2
x = linspace(0,a,100)
y = ( a**(2.0/3) - x**(2.0/3) )**(3.0/2)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/FamousCurves/astropar.py 0000775 0000000 0000000 00000000200 12544046010 0023144 0 ustar 00root root 0000000 0000000 #Example astropar.py
from pylab import *
a = 2
t = linspace(-2*a,2*a,101)
x = a * cos(t)**3
y = a * sin(t)**3
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/FamousCurves/cover.py 0000775 0000000 0000000 00000000176 12544046010 0022443 0 ustar 00root root 0000000 0000000 from pylab import *
th = linspace(0, 10*pi,1000)
r = 4* sin(8*th)
polar(th,r)
r = sqrt(th)
polar(th,r)
polar(th, -r)
show()
pycode-browser-1.02/Code/Maths/FamousCurves/ellipse.py 0000775 0000000 0000000 00000000210 12544046010 0022747 0 ustar 00root root 0000000 0000000 #Example ellipse.py
from pylab import *
a = 2
b = 3
t = linspace(0, 2 * pi, 100)
x = a * sin(t)
y = b * cos(t)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/FamousCurves/fermat.py 0000775 0000000 0000000 00000000176 12544046010 0022603 0 ustar 00root root 0000000 0000000 #Example fermat.py
from pylab import *
a = 2
th= linspace(0, 10*pi,200)
r = sqrt(a**2 * th)
polar(th,r)
polar(th, -r)
show()
pycode-browser-1.02/Code/Maths/FamousCurves/lissa.py 0000775 0000000 0000000 00000000261 12544046010 0022433 0 ustar 00root root 0000000 0000000 #Example lissa.py
from pylab import *
a = 2
b = 3
t= linspace(0, 2*pi,100)
x = a * sin(2*t)
y = b * cos(t)
plot(x,y)
x = a * sin(3*t)
y = b * cos(2*t)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Functions/ 0000775 0000000 0000000 00000000000 12544046010 0020272 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Functions/bes1.py 0000775 0000000 0000000 00000000323 12544046010 0021477 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import special
def vj0(xarray):
y = []
for x in xarray:
val = special.j0(x) # Compute Jo
y.append(val)
return y
a = linspace(0,10,100)
b = vj0(a)
plot(a,b)
show()
pycode-browser-1.02/Code/Maths/Functions/bes2.py 0000775 0000000 0000000 00000000353 12544046010 0021503 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
def vjn(n,xarray):
y = []
for x in xarray:
val = special.jn(n,x) # Compute Jn(x)
y.append(val)
return y
a = linspace(0,10,100)
for n in range(5):
b = vjn(n,a)
plot(a,b)
show()
pycode-browser-1.02/Code/Maths/Functions/bes3.py 0000775 0000000 0000000 00000001130 12544046010 0021476 0 ustar 00root root 0000000 0000000 from scipy import *
from scipy import special
import pylab
def jn(n,x):
jn = 0.0
for k in range(30):
num = (-1)**k * (x/2)**(2*k)
den = factorial(k)*factorial(n+k)
jn = jn + num/den
return jn * (x/2)**n
def vjn_local(n,xarray):
y = []
for x in xarray:
val = jn(n,x) # Jn(x) using our function
y.append(val)
return y
def vjn(n,xarray):
y = []
for x in xarray:
val = special.jn(n,x) # Compute Jn(x)
y.append(val)
return y
a = linspace(0,10,100)
for n in range(2):
b = vjn(n,a)
c = vjn_local(n,a)
pylab.plot(a,b)
pylab.plot(a,c,marker = '+')
pylab.show()
pycode-browser-1.02/Code/Maths/Functions/legen1.py 0000775 0000000 0000000 00000000244 12544046010 0022022 0 ustar 00root root 0000000 0000000 from scipy import linspace, special
import pylab
x = linspace(-1,1,100)
for n in range(1,6):
leg = special.legendre(n)
y = leg(x)
pylab.plot(x,y)
pylab.show()
pycode-browser-1.02/Code/Maths/Graphs/ 0000775 0000000 0000000 00000000000 12544046010 0017546 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Graphs/arcs.py 0000775 0000000 0000000 00000000251 12544046010 0021051 0 ustar 00root root 0000000 0000000 #Example arcs.py
from pylab import *
a = 10.0
for a in range(5,21,5):
th = linspace(0, pi * a/10, 200)
x = a * cos(th)
y = a * sin(th)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Graphs/circ.py 0000775 0000000 0000000 00000000245 12544046010 0021044 0 ustar 00root root 0000000 0000000 #Example circ.py
from pylab import *
a = 10.0
x = linspace(-a, a , 200)
yupper = sqrt(a**2 - x**2)
ylower = -sqrt(a**2 - x**2)
plot(x,yupper)
plot(x,ylower)
show()
pycode-browser-1.02/Code/Maths/Graphs/circpar.py 0000775 0000000 0000000 00000000177 12544046010 0021553 0 ustar 00root root 0000000 0000000 #Example circpar.py
from pylab import *
a = 10.0
th = linspace(0, 2*pi, 200)
x = a * cos(th)
y = a * sin(th)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Graphs/julia.py 0000775 0000000 0000000 00000002106 12544046010 0021226 0 ustar 00root root 0000000 0000000 '''
Region of a complex plane ranging from -1 to +1 in both real
and imaginary axes is rpresented using a 2 dimensional matrix
having X x Y elements.For X and Y equal to 200, the stepsize
in the complex plane is 2.0/200 = 0.01.
The nature of the pattern depends very much on the value of c.
'''
from pylab import *
X = 200
Y = 200
rlim = 1.0
ilim = 1.0
rscale = 2*rlim / X
iscale = 2*ilim / Y
MAXIT = 100
MAXABS = 2.0
c = 0.02 - 0.8j # The constant in equation z**2 + c
m = zeros([X,Y],dtype=uint8) # A two dimensional array
def numit(x,y): # number of iterations to diverge
z = complex(x,y)
for k in range(MAXIT):
if abs(z) <= MAXABS:
z = z**2 + c
else:
return k # diverged after k trials
return MAXIT # did not diverge,
for x in range(X):
for y in range(Y):
re = rscale * x - rlim # complex number represented
im = iscale * y - ilim # by the (x,y) coordinate
m[x][y] = numit(re,im) # get the color for (x,y)
imshow(m) # Colored plot using the two dimensional matrix
show()
pycode-browser-1.02/Code/Maths/Graphs/npsin.py 0000775 0000000 0000000 00000000200 12544046010 0021242 0 ustar 00root root 0000000 0000000 #Example npsin.py
from pylab import *
x = linspace(-pi, pi , 200)
y = sin(x)
y1 = sin(x*x)
plot(x,y)
plot(x,y1,'r')
show()
pycode-browser-1.02/Code/Maths/Graphs/plot1.py 0000775 0000000 0000000 00000000065 12544046010 0021163 0 ustar 00root root 0000000 0000000 from pylab import *
x = range(10)
plot(x)
show()
pycode-browser-1.02/Code/Maths/Graphs/plot2.py 0000775 0000000 0000000 00000000172 12544046010 0021163 0 ustar 00root root 0000000 0000000 from pylab import *
x = range(10,20)
y = range(40,50)
plot(x,y, marker = '+', color = 'red', markersize = 10)
show()
pycode-browser-1.02/Code/Maths/Graphs/plot3.py 0000775 0000000 0000000 00000000302 12544046010 0021157 0 ustar 00root root 0000000 0000000 from pylab import *
x = [] # empty lists
y = []
for k in range(100):
ang = 0.1 * k
sang = sin(ang)
x.append(ang)
y.append(sang)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Graphs/plot4.py 0000775 0000000 0000000 00000000206 12544046010 0021163 0 ustar 00root root 0000000 0000000 #Example plot4.py
from pylab import *
t = arange(0.0, 5.0, 0.2)
plot(t, t**2,'x') # t^{2}
plot(t, t**3,'ro') # t^{3}
show()
pycode-browser-1.02/Code/Maths/Graphs/polar.py 0000775 0000000 0000000 00000000213 12544046010 0021234 0 ustar 00root root 0000000 0000000 #Example polar.py
from pylab import *
th = linspace(0,2*pi,100)
r = 5 * ones(100) # radius = 5
axis([0, 2*pi, 0, 10])
polar(th,r)
show()
pycode-browser-1.02/Code/Maths/Graphs/sine.py 0000775 0000000 0000000 00000000146 12544046010 0021062 0 ustar 00root root 0000000 0000000 #Example sine.py
import math
x = 0.0
while x < math.pi * 4:
print x , math.sin(x)
x = x + 0.1 pycode-browser-1.02/Code/Maths/Polynomials/ 0000775 0000000 0000000 00000000000 12544046010 0020630 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Polynomials/poly.py 0000775 0000000 0000000 00000000260 12544046010 0022166 0 ustar 00root root 0000000 0000000 #Example poly.py
from pylab import *
a = poly1d([3,4,5])
b = poly1d([6,7])
c = a * b + 5
d = c/a
print a
print b
print a * b
print d[0], d[1]
print a.deriv()
print a.integ()
pycode-browser-1.02/Code/Maths/Polynomials/poly1.py 0000775 0000000 0000000 00000000443 12544046010 0022252 0 ustar 00root root 0000000 0000000 import scipy
import pylab
a = scipy.poly1d([3,4,5])
print a, ' is the polynomial'
print a*a, 'is its square'
print a.deriv(), ' is its derivative'
print a.integ(), ' is its integral'
print a(0.5), 'is its value at x = 0.5'
x = scipy.linspace(0,5,100)
b = a(x)
pylab.plot(x,b)
pylab.show()
pycode-browser-1.02/Code/Maths/Polynomials/polyplot.py 0000775 0000000 0000000 00000000220 12544046010 0023061 0 ustar 00root root 0000000 0000000 #Example polyplot.py
from pylab import *
x = linspace(-pi, pi, 100)
a = poly1d([-1.0/5040,0,1.0/120,0,-1.0/6,0,1,0])
y = a(x)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Series/ 0000775 0000000 0000000 00000000000 12544046010 0017554 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/Series/fourier_sawtooth.py 0000775 0000000 0000000 00000000327 12544046010 0023536 0 ustar 00root root 0000000 0000000 #Example fourier_sawtooth.py
from pylab import *
N = 100 # number of points
x = linspace(-pi, pi, N)
y = zeros(N)
for n in range(1,10):
term = (-1)**(n+1) * sin(n*x) / n
y = y + term
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Series/fourier_square.py 0000775 0000000 0000000 00000000327 12544046010 0023166 0 ustar 00root root 0000000 0000000 #Example fourier_square.py
from pylab import *
N = 100 # number of points
x = linspace(0.0, 2 * pi, N)
y = zeros(N)
for n in range(5):
term = sin((2*n+1)*x) / (2*n+1)
y = y + term
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/Series/series_cos.py 0000775 0000000 0000000 00000000504 12544046010 0022266 0 ustar 00root root 0000000 0000000 import scipy, pylab
def mycos(x):
res = 0.0
for n in range(18):
res = res + (-1)**n * (x ** (2*n)) / scipy.factorial(2*n)
return res
def vmycos(ax):
y = []
for x in ax:
y.append(mycos(x))
return y
x = scipy.linspace(0,4*scipy.pi,100)
y = vmycos(x)
pylab.plot(x,y)
pylab.plot(x,scipy.cos(x),'+')
pylab.show()
pycode-browser-1.02/Code/Maths/Series/series_sin.py 0000775 0000000 0000000 00000000463 12544046010 0022277 0 ustar 00root root 0000000 0000000 #Example series_sin.py
from pylab import *
from scipy import factorial
x = linspace(-pi, pi, 50)
y = zeros(50)
for n in range(5):
term = (-1)**(n) * (x**(2*n+1)) / factorial(2*n+1)
y = y + term
plot(x,term)
plot(x, y, '+b')
plot(x, sin(x),'xr') # compare with the real one
show()
pycode-browser-1.02/Code/Maths/archi.py 0000775 0000000 0000000 00000000173 12544046010 0017766 0 ustar 00root root 0000000 0000000 #Example archi.py
from pylab import *
a = 2
th= linspace(0, 10*pi,200)
r = a*th
polar(th,r)
axis([0, 2*pi, 0, 70])
show()
pycode-browser-1.02/Code/Maths/archi.txt 0000775 0000000 0000000 00000001612 12544046010 0020154 0 ustar 00root root 0000000 0000000 This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.This is the description of archi.py file. You can add description to any python file by adding a .txt file with the description. The file name should be the same as the python file.
pycode-browser-1.02/Code/Maths/arcs.py 0000775 0000000 0000000 00000000251 12544046010 0017625 0 ustar 00root root 0000000 0000000 #Example arcs.py
from pylab import *
a = 10.0
for a in range(5,21,5):
th = linspace(0, pi * a/10, 200)
x = a * cos(th)
y = a * sin(th)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/area.py 0000775 0000000 0000000 00000000160 12544046010 0017604 0 ustar 00root root 0000000 0000000 #Example: area.py
pi = 3.1416
r = input('Enter Radius ')
a = pi * r ** 2 #A=\pi r^{2}
print 'Area = ', a
pycode-browser-1.02/Code/Maths/astro.py 0000775 0000000 0000000 00000000175 12544046010 0020032 0 ustar 00root root 0000000 0000000 #Example astro.py
from pylab import *
a = 2
x = linspace(0,a,100)
y = ( a**(2.0/3) - x**(2.0/3) )**(3.0/2)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/astropar.py 0000775 0000000 0000000 00000000200 12544046010 0020522 0 ustar 00root root 0000000 0000000 #Example astropar.py
from pylab import *
a = 2
t = linspace(-2*a,2*a,101)
x = a * cos(t)**3
y = a * sin(t)**3
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/badtable.py 0000775 0000000 0000000 00000000123 12544046010 0020431 0 ustar 00root root 0000000 0000000 #Example: badtable.py
print 1 * 8
print 2 * 8
print 3 * 8
print 4 * 8
print 5 * 8
pycode-browser-1.02/Code/Maths/big.py 0000775 0000000 0000000 00000000233 12544046010 0017436 0 ustar 00root root 0000000 0000000 #Example: big.py
x = input('Enter a number ')
if x > 10:
print 'Bigger Number'
elif x < 10:
print 'Smaller Number'
else:
print 'Same Number'
pycode-browser-1.02/Code/Maths/big2.py 0000775 0000000 0000000 00000000176 12544046010 0017526 0 ustar 00root root 0000000 0000000 #Example: big2.py
x = 1
while x < 11:
if x < 5:
print 'Samll ', x
else:
print 'Big ', x
print 'Done'
pycode-browser-1.02/Code/Maths/big3.py 0000775 0000000 0000000 00000000206 12544046010 0017521 0 ustar 00root root 0000000 0000000 #Example: big3.py
x = 1
while x < 100:
print x
if x > 10:
print 'Enough of this'
break
x = x + 1
print 'Done'
pycode-browser-1.02/Code/Maths/circ.py 0000775 0000000 0000000 00000000245 12544046010 0017620 0 ustar 00root root 0000000 0000000 #Example circ.py
from pylab import *
a = 10.0
x = linspace(-a, a , 200)
yupper = sqrt(a**2 - x**2)
ylower = -sqrt(a**2 - x**2)
plot(x,yupper)
plot(x,ylower)
show()
pycode-browser-1.02/Code/Maths/circpar.py 0000775 0000000 0000000 00000000177 12544046010 0020327 0 ustar 00root root 0000000 0000000 #Example circpar.py
from pylab import *
a = 10.0
th = linspace(0, 2*pi, 200)
x = a * cos(th)
y = a * sin(th)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/cloth.py 0000775 0000000 0000000 00000000470 12544046010 0020011 0 ustar 00root root 0000000 0000000 class clothing:
def __init__(self,colour, rate):
self.colour = colour
self.rate = rate
def getcolour(self):
return self.colour
cheapblue = clothing('blue', 20.0)
costlyred = clothing('red', 100.0)
print cheapblue.rate
print costlyred pycode-browser-1.02/Code/Maths/cloth2.py 0000775 0000000 0000000 00000000574 12544046010 0020100 0 ustar 00root root 0000000 0000000 class clothing:
def __init__(self,colour, rate):
self.colour = colour
self.rate = rate
def getcolour(self):
return self.colour
def __str__(self):
return '%s Cloth at Rs. %6.2f per sqmtr'%(self.colour, self.rate)
cheapblue = clothing('blue', 20.0)
costlyred = clothing('red', 100.0)
print cheapblue.rate
print costlyred pycode-browser-1.02/Code/Maths/clothbill.py 0000775 0000000 0000000 00000002224 12544046010 0020653 0 ustar 00root root 0000000 0000000 class clothing:
def __init__(self,colour, rate):
self.colour = colour
self.rate = rate
def getcolour(self):
return self.colour
def __str__(self):
return '%s Cloth at Rs. %6.2f per sqmtr'%(self.colour, self.rate)
class pants(clothing):
def __init__(self, cloth, size, labour):
self.labour = labour
self.size = size
clothing.__init__(self,cloth.colour, cloth.rate)
def __str__(self):
return '%-10s Pants'%(self.colour)
def getcost(self):
return self.rate * self.size + self.labour
class shirt(clothing):
def __init__(self, cloth, size, labour):
self.labour = labour
self.size = size
clothing.__init__(self,cloth.colour, cloth.rate)
def __str__(self):
return '%-10s Shirt'%(self.colour)
def getcost(self):
return self.rate * self.size + self.labour
cheapblue = clothing('blue', 20.0)
costlyred = clothing('red', 100.0)
items = []
items.append(pants(cheapblue, 2.0, 150.0) )
items.append(shirt(costlyred, 1.5, 130.0) )
for k in items:
print k, k.getcost()
pycode-browser-1.02/Code/Maths/compareEuRK4.py 0000775 0000000 0000000 00000001163 12544046010 0021141 0 ustar 00root root 0000000 0000000 '''
Sine function is calculated using its derivative, cosine.
Using Euler and RK4 method, with
'''
import math
def rk4(x, y, yprime, dx = 0.01): # x, y , derivative, stepsize
k1 = dx * yprime(x)
k2 = dx * yprime(x + dx/2.0)
k3 = dx * yprime(x + dx/2.0)
k4 = dx * yprime(x + dx)
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0 # for Euler
z = 0.0 # for RK4
while x < math.pi:
print x, y - math.sin(x), z - math.sin(x) # errors
y = y + h * math.cos(x) # Euler method
z = rk4(x,z,math.cos,h) # Runge-Kutta method
x = x + h
pycode-browser-1.02/Code/Maths/conflict.py 0000775 0000000 0000000 00000000365 12544046010 0020504 0 ustar 00root root 0000000 0000000 #Example conflict.py
from numpy import *
x = linspace(0, 5, 10) # make a 10 element array
print sin(x) # sin of scipy can handle arrays
from math import * # sin of math will be called now
print sin(x) # will give ERROR
pycode-browser-1.02/Code/Maths/cover.py 0000775 0000000 0000000 00000000176 12544046010 0020021 0 ustar 00root root 0000000 0000000 from pylab import *
th = linspace(0, 10*pi,1000)
r = 4* sin(8*th)
polar(th,r)
r = sqrt(th)
polar(th,r)
polar(th, -r)
show()
pycode-browser-1.02/Code/Maths/cross.py 0000775 0000000 0000000 00000000144 12544046010 0020027 0 ustar 00root root 0000000 0000000 #Example cross.py
from numpy import *
a = array([1,2,3])
b = array([4,5,6])
c = cross(a,b)
print c
pycode-browser-1.02/Code/Maths/diff.py 0000775 0000000 0000000 00000000277 12544046010 0017615 0 ustar 00root root 0000000 0000000 #Example diff.py
def f(x):
return x**3
def deriv(x,dx=0.005):
df = f(x+dx/2)-f(x-dx/2)
return df/dx
print deriv(2.0)
print deriv(2.0, 0.1)
print deriv(2.0, 0.0001)
pycode-browser-1.02/Code/Maths/ellipse.py 0000775 0000000 0000000 00000000210 12544046010 0020325 0 ustar 00root root 0000000 0000000 #Example ellipse.py
from pylab import *
a = 2
b = 3
t = linspace(0, 2 * pi, 100)
x = a * sin(t)
y = b * cos(t)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/euler.py 0000775 0000000 0000000 00000000273 12544046010 0020015 0 ustar 00root root 0000000 0000000 import math
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0
while x < math.pi:
print x, y, math.sin(x)
y = y + h * math.cos(x) # Euler method
x = x + h
pycode-browser-1.02/Code/Maths/factor.py 0000775 0000000 0000000 00000000244 12544046010 0020155 0 ustar 00root root 0000000 0000000 #Example factor.py
def factorial(n): # a recursive function
if n == 0:
return 1
else:
return n * factorial(n-1)
print factorial(10)
pycode-browser-1.02/Code/Maths/fermat.py 0000775 0000000 0000000 00000000176 12544046010 0020161 0 ustar 00root root 0000000 0000000 #Example fermat.py
from pylab import *
a = 2
th= linspace(0, 10*pi,200)
r = sqrt(a**2 * th)
polar(th,r)
polar(th, -r)
show()
pycode-browser-1.02/Code/Maths/fileio.py 0000775 0000000 0000000 00000000161 12544046010 0020144 0 ustar 00root root 0000000 0000000 #Example fileio.py
from numpy import *
a = arange(10)
a.tofile('myfile.dat')
b = fromfile('myfile.dat')
print b
pycode-browser-1.02/Code/Maths/filelist.html 0000775 0000000 0000000 00000002711 12544046010 0021027 0 ustar 00root root 0000000 0000000
pycode-browser-1.02/Code/Maths/first.py 0000775 0000000 0000000 00000000544 12544046010 0020031 0 ustar 00root root 0000000 0000000
#Example: first.py
'''
This is Python program starting with a multi-line
comment, enclosed within triple quotes.
In a single line, anything after a # sign is a comment
'''
x = 10
print x, type(x) #print x and its type
y = 10.4
print y, type(y)
z = 3 + 4j
print z, type(z)
s1 = 'I am a String '
s2 = 'me too'
print s1, s2, type(s1)
pycode-browser-1.02/Code/Maths/forloop.py 0000775 0000000 0000000 00000000174 12544046010 0020361 0 ustar 00root root 0000000 0000000 #Example: forloop.py
a = 'my name'
for ch in a:
print ch
b = ['hello', 3.4, 2345, 3+5j]
for item in b:
print item
pycode-browser-1.02/Code/Maths/forloop2.py 0000775 0000000 0000000 00000000132 12544046010 0020435 0 ustar 00root root 0000000 0000000 #Example: forloop2.py
mylist = range(5)
print mylist
for item in mylist:
print item
pycode-browser-1.02/Code/Maths/forloop3.py 0000775 0000000 0000000 00000000121 12544046010 0020434 0 ustar 00root root 0000000 0000000 #Example: forloop3.py
mylist = range(5,51,5)
for item in mylist:
print item
pycode-browser-1.02/Code/Maths/forloop4.py 0000775 0000000 0000000 00000000142 12544046010 0020440 0 ustar 00root root 0000000 0000000 a = [2, 5, -3, 4, -2, 12]
size = len(a)
for k in range(size):
if a[k] < 0:
a[k] = 0
print a
pycode-browser-1.02/Code/Maths/format.py 0000775 0000000 0000000 00000000130 12544046010 0020161 0 ustar 00root root 0000000 0000000 #Example: format.py
a = 2.0 /3
print a
print 'a = %5.3f' %(a) # upto 3 decimal places
pycode-browser-1.02/Code/Maths/format2.py 0000775 0000000 0000000 00000000314 12544046010 0020247 0 ustar 00root root 0000000 0000000 #Example: format2.py
a = 'justify as you like'
print '%30s'%a
print '%-30s'%a # minus sign for left justification
for k in range(1,11): # A good looking table
print '5 x %2d = %2d' %(k, k*5) pycode-browser-1.02/Code/Maths/fourier_sawtooth.py 0000775 0000000 0000000 00000000327 12544046010 0022304 0 ustar 00root root 0000000 0000000 #Example fourier_sawtooth.py
from pylab import *
N = 100 # number of points
x = linspace(-pi, pi, N)
y = zeros(N)
for n in range(1,10):
term = (-1)**(n+1) * sin(n*x) / n
y = y + term
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/fourier_square.py 0000775 0000000 0000000 00000000327 12544046010 0021734 0 ustar 00root root 0000000 0000000 #Example fourier_square.py
from pylab import *
N = 100 # number of points
x = linspace(0.0, 2 * pi, N)
y = zeros(N)
for n in range(5):
term = sin((2*n+1)*x) / (2*n+1)
y = y + term
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/func.py 0000775 0000000 0000000 00000000132 12544046010 0017626 0 ustar 00root root 0000000 0000000 #Example func.py
def sum(a,b): # a trivial function
return a + b
print sum(3, 4)
pycode-browser-1.02/Code/Maths/inv.py 0000775 0000000 0000000 00000000223 12544046010 0017470 0 ustar 00root root 0000000 0000000 #Example inv.py
from numpy import *
a = array([ [4,1,-2], [2,-3,3], [-6,-2,1] ], dtype='float')
ainv = linalg.inv(a)
print ainv
print dot(a,ainv)
pycode-browser-1.02/Code/Maths/julia.py 0000775 0000000 0000000 00000002106 12544046010 0020002 0 ustar 00root root 0000000 0000000 '''
Region of a complex plane ranging from -1 to +1 in both real
and imaginary axes is rpresented using a 2 dimensional matrix
having X x Y elements.For X and Y equal to 200, the stepsize
in the complex plane is 2.0/200 = 0.01.
The nature of the pattern depends very much on the value of c.
'''
from pylab import *
X = 200
Y = 200
rlim = 1.0
ilim = 1.0
rscale = 2*rlim / X
iscale = 2*ilim / Y
MAXIT = 100
MAXABS = 2.0
c = 0.02 - 0.8j # The constant in equation z**2 + c
m = zeros([X,Y],dtype=uint8) # A two dimensional array
def numit(x,y): # number of iterations to diverge
z = complex(x,y)
for k in range(MAXIT):
if abs(z) <= MAXABS:
z = z**2 + c
else:
return k # diverged after k trials
return MAXIT # did not diverge,
for x in range(X):
for y in range(Y):
re = rscale * x - rlim # complex number represented
im = iscale * y - ilim # by the (x,y) coordinate
m[x][y] = numit(re,im) # get the color for (x,y)
imshow(m) # Colored plot using the two dimensional matrix
show()
pycode-browser-1.02/Code/Maths/kin.py 0000775 0000000 0000000 00000000242 12544046010 0017456 0 ustar 00root root 0000000 0000000 #Example: kin.py
x = input('Enter an integer ')
y = input('Enter one more ')
print 'The sum is ', x + y
s = raw_input('Enter a String ')
print 'You entered ', s
pycode-browser-1.02/Code/Maths/kin2.py 0000775 0000000 0000000 00000000305 12544046010 0017540 0 ustar 00root root 0000000 0000000 #Example: kin2.py
x,y = input('Enter x and y separated by comma ')
print 'The sum is ', x + y
s = raw_input('Enter a decimal number ')
print 'Your input string x 2 = ', s
a = float(s)
print a * 2
pycode-browser-1.02/Code/Maths/lissa.py 0000775 0000000 0000000 00000000261 12544046010 0020011 0 ustar 00root root 0000000 0000000 #Example lissa.py
from pylab import *
a = 2
b = 3
t= linspace(0, 2*pi,100)
x = a * sin(2*t)
y = b * cos(t)
plot(x,y)
x = a * sin(3*t)
y = b * cos(2*t)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/mathlocal.py 0000775 0000000 0000000 00000000132 12544046010 0020637 0 ustar 00root root 0000000 0000000 #Example mathlocal.py
from math import sin # sin is imported as local
print sin(0.5)
pycode-browser-1.02/Code/Maths/mathlocal2.py 0000775 0000000 0000000 00000000133 12544046010 0020722 0 ustar 00root root 0000000 0000000 #Example mathlocal2.py
from math import * # import everything from math
print sin(0.5)
pycode-browser-1.02/Code/Maths/mathsin.py 0000775 0000000 0000000 00000000116 12544046010 0020340 0 ustar 00root root 0000000 0000000 #Example math.py
import math
print math.sin(0.5) # module_name.method_name
pycode-browser-1.02/Code/Maths/mathsin2.py 0000775 0000000 0000000 00000000154 12544046010 0020424 0 ustar 00root root 0000000 0000000 #Example math2.py
import math as m # Give another madule name
print m.sin(0.5) # Refer by the new name
pycode-browser-1.02/Code/Maths/max.py 0000775 0000000 0000000 00000000242 12544046010 0017462 0 ustar 00root root 0000000 0000000 #Example: max.py
max = 0
while 1: # Infinite loop
x = input('Enter a number ')
if x > max:
max = x
if x == 0:
print max
break
pycode-browser-1.02/Code/Maths/npsin.py 0000775 0000000 0000000 00000000200 12544046010 0020016 0 ustar 00root root 0000000 0000000 #Example npsin.py
from pylab import *
x = linspace(-pi, pi , 200)
y = sin(x)
y1 = sin(x*x)
plot(x,y)
plot(x,y1,'r')
show()
pycode-browser-1.02/Code/Maths/numpy1.py 0000775 0000000 0000000 00000000146 12544046010 0020131 0 ustar 00root root 0000000 0000000 #Example numpy1.py
from numpy import *
x = array( [1,2] ) # Make array from list
print x , type(x)
pycode-browser-1.02/Code/Maths/numpy2.py 0000775 0000000 0000000 00000000313 12544046010 0020126 0 ustar 00root root 0000000 0000000 #Example numpy2.py
from numpy import *
a = arange(1.0, 2.0, 0.1) # start, stop & step
print a
b = linspace(1,2,11)
print b
c = ones(5)
print c
d = zeros(5)
print d
e = random.rand(5)
print e
pycode-browser-1.02/Code/Maths/numpy3.py 0000775 0000000 0000000 00000000207 12544046010 0020131 0 ustar 00root root 0000000 0000000 #Example numpy3.py
from numpy import *
a = [ [1,2] , [3,4] ] # make a list of lists
x = array(a) # and convert to an array
print a
pycode-browser-1.02/Code/Maths/numpy4.py 0000775 0000000 0000000 00000000161 12544046010 0020131 0 ustar 00root root 0000000 0000000 #Example numpy4.py
from numpy import *
a = arange(10)
print a
a = a.reshape(5,2) # 5 rows and 2 columns
print a
pycode-browser-1.02/Code/Maths/numpy5.py 0000775 0000000 0000000 00000000220 12544046010 0020126 0 ustar 00root root 0000000 0000000 #Example numpy5.py
from numpy import *
a = array([ [1.0, 2.0] , [3.0, 4.0] ]) # make a numpy array
print a
print a * 5
print a * a
print a / a
pycode-browser-1.02/Code/Maths/oper.py 0000775 0000000 0000000 00000000162 12544046010 0017643 0 ustar 00root root 0000000 0000000 #Example oper.py
from numpy import *
a = array([[2,3], [4,5]])
b = array([[1,2], [3,0]])
print a + b
print a * b
pycode-browser-1.02/Code/Maths/pants.py 0000775 0000000 0000000 00000001226 12544046010 0020025 0 ustar 00root root 0000000 0000000 class clothing:
def __init__(self,colour, rate):
self.colour = colour
self.rate = rate
def getcolour(self):
return self.colour
def __str__(self):
return '%s Cloth at Rs. %6.2f per sqmtr'%(self.colour, self.rate)
class pants(clothing):
def __init__(self, cloth, size, labour):
self.labour = labour
self.size = size
clothing.__init__(self,cloth.colour, cloth.rate)
def getcost(self):
return self.rate * self.size + self.labour
costlyred = clothing('red', 100.0)
smallpant = pants(costlyred, 1.5, 100)
print smallpant.getcost()
print smallpant pycode-browser-1.02/Code/Maths/pickledump.py 0000775 0000000 0000000 00000000161 12544046010 0021032 0 ustar 00root root 0000000 0000000 #Example pickle.py
import pickle
f = open('test.pck' , 'w')
pickle.dump(12.3, f) # write a float type
f.close()
pycode-browser-1.02/Code/Maths/pickleload.py 0000775 0000000 0000000 00000000222 12544046010 0021002 0 ustar 00root root 0000000 0000000 #Example pickle2.py
import pickle
f = open('test.pck' , 'r')
x = pickle.load(f)
print x , type(x) # check the type of data read
f.close()
pycode-browser-1.02/Code/Maths/plot1.py 0000775 0000000 0000000 00000000110 12544046010 0017726 0 ustar 00root root 0000000 0000000 #Example plot1.py
from pylab import *
data = [1,2,5]
plot(data)
show()
pycode-browser-1.02/Code/Maths/plot2.py 0000775 0000000 0000000 00000000120 12544046010 0017730 0 ustar 00root root 0000000 0000000 #Example plot2.py
from pylab import *
x = [1,2,5]
y = [4,5,6]
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/plot3.py 0000775 0000000 0000000 00000000207 12544046010 0017737 0 ustar 00root root 0000000 0000000 #Example plot3.py
from pylab import *
x = [1,2,5]
y = [4,5,6]
plot(x,y,'ro')
xlabel('x-axis')
ylabel('y-axis')
axis([0,6,1,7])
show()
pycode-browser-1.02/Code/Maths/plot4.py 0000775 0000000 0000000 00000000206 12544046010 0017737 0 ustar 00root root 0000000 0000000 #Example plot4.py
from pylab import *
t = arange(0.0, 5.0, 0.2)
plot(t, t**2,'x') # t^{2}
plot(t, t**3,'ro') # t^{3}
show()
pycode-browser-1.02/Code/Maths/polar.py 0000775 0000000 0000000 00000000213 12544046010 0020010 0 ustar 00root root 0000000 0000000 #Example polar.py
from pylab import *
th = linspace(0,2*pi,100)
r = 5 * ones(100) # radius = 5
axis([0, 2*pi, 0, 10])
polar(th,r)
show()
pycode-browser-1.02/Code/Maths/poly.py 0000775 0000000 0000000 00000000260 12544046010 0017660 0 ustar 00root root 0000000 0000000 #Example poly.py
from pylab import *
a = poly1d([3,4,5])
b = poly1d([6,7])
c = a * b + 5
d = c/a
print a
print b
print a * b
print d[0], d[1]
print a.deriv()
print a.integ()
pycode-browser-1.02/Code/Maths/polyplot.py 0000775 0000000 0000000 00000000220 12544046010 0020553 0 ustar 00root root 0000000 0000000 #Example polyplot.py
from pylab import *
x = linspace(-pi, pi, 100)
a = poly1d([-1.0/5040,0,1.0/120,0,-1.0/6,0,1,0])
y = a(x)
plot(x,y)
show()
pycode-browser-1.02/Code/Maths/power.py 0000775 0000000 0000000 00000000133 12544046010 0020030 0 ustar 00root root 0000000 0000000 def power(mant, exp = 2.0):
return mant ** exp
print power(5., 3)
print power(4.)
pycode-browser-1.02/Code/Maths/reshape.py 0000775 0000000 0000000 00000000126 12544046010 0020325 0 ustar 00root root 0000000 0000000 #Example reshape.py
from numpy import *
a = arange(20)
b = reshape(a, [4,5])
print b
pycode-browser-1.02/Code/Maths/rfile.py 0000775 0000000 0000000 00000000107 12544046010 0017776 0 ustar 00root root 0000000 0000000 #Example rfile.py
f = open('test.dat' , 'r')
print f.read()
f.close()
pycode-browser-1.02/Code/Maths/rfile2.py 0000775 0000000 0000000 00000000231 12544046010 0020056 0 ustar 00root root 0000000 0000000 #Example rfile2.py
f = open('test.dat' , 'r')
print f.read(7) # get first seven characters
print f.read() # get the remaining ones
f.close()
pycode-browser-1.02/Code/Maths/rfile3.py 0000775 0000000 0000000 00000000404 12544046010 0020061 0 ustar 00root root 0000000 0000000 #Example rfile3.py
f = open('data.dat' , 'r')
while 1: # infinite loop
s = f.readline()
if s == '' : # Empty string means end of file
break # terminate the loop
m = int(s) # Convert to integer
print m * 5
f.close()
pycode-browser-1.02/Code/Maths/rk4.py 0000775 0000000 0000000 00000001040 12544046010 0017372 0 ustar 00root root 0000000 0000000 '''
Solving initial value problem using 4th order Runge-Kutta method.
Sine function is calculated using its derivative, cosine.
'''
import math
def rk4(x, y, yprime, dx = 0.01): # x, y , derivative, stepsize
k1 = dx * yprime(x)
k2 = dx * yprime(x + dx/2.0)
k3 = dx * yprime(x + dx/2.0)
k4 = dx * yprime(x + dx)
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0
while x < math.pi:
print x, y, math.sin(x)
y = rk4(x,y,math.cos) # Runge-Kutta method
x = x + h
pycode-browser-1.02/Code/Maths/second.py 0000775 0000000 0000000 00000000310 12544046010 0020144 0 ustar 00root root 0000000 0000000 #Example: second.py
s = 'My name'
print s[0] # will print M
print s[3]
print s[-1] # will print the last element
a = [12, 3.4, 'haha'] # List type
print a, type(a)
print a[0]
pycode-browser-1.02/Code/Maths/series_sin.py 0000775 0000000 0000000 00000000463 12544046010 0021045 0 ustar 00root root 0000000 0000000 #Example series_sin.py
from pylab import *
from scipy import factorial
x = linspace(-pi, pi, 50)
y = zeros(50)
for n in range(5):
term = (-1)**(n) * (x**(2*n+1)) / factorial(2*n+1)
y = y + term
plot(x,term)
plot(x, y, '+b')
plot(x, sin(x),'xr') # compare with the real one
show()
pycode-browser-1.02/Code/Maths/sine.py 0000775 0000000 0000000 00000000146 12544046010 0017636 0 ustar 00root root 0000000 0000000 #Example sine.py
import math
x = 0.0
while x < math.pi * 4:
print x , math.sin(x)
x = x + 0.1 pycode-browser-1.02/Code/Maths/table.py 0000775 0000000 0000000 00000000107 12544046010 0017764 0 ustar 00root root 0000000 0000000 #Example: table.py
x = 1
while x <= 10:
print x * 8
x = x + 1
pycode-browser-1.02/Code/Maths/test.pck 0000775 0000000 0000000 00000000000 12544046010 0017771 0 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Maths/third.py 0000775 0000000 0000000 00000000355 12544046010 0020014 0 ustar 00root root 0000000 0000000 #Example: third.py
s = [3, 3.5, 234] # make a list
s[2] = 'haha' # Change an element
a = (4, 3.2, 'hi') # Tuple type
a[0] = 6 # Will give ERROR
x = 'myname' # String type
x[1] = 2 # Will give ERROR
pycode-browser-1.02/Code/Maths/trapez.py 0000775 0000000 0000000 00000000447 12544046010 0020211 0 ustar 00root root 0000000 0000000 from math import *
def sqr(a):
return a**2
def trapez(f, a, b, n):
h = (b-a) / n
sum = f(a)
for i in range (1,n):
sum = sum + 2 * f(a + h * i)
sum = sum + f(b)
return 0.5 * h * sum
print trapez(sin,0.,pi,100)
print trapez(sqr,0.,2.,100)
print trapez(sqr,0,2,100) # Why the error ?
pycode-browser-1.02/Code/Maths/vdiff.py 0000775 0000000 0000000 00000000407 12544046010 0017776 0 ustar 00root root 0000000 0000000 #Example vdiff.py
from pylab import *
def f(x):
return sin(x)
def deriv(x,dx=0.005):
df = f(x+dx/2)-f(x-dx/2)
return df/dx
vecderiv = vectorize(deriv)
x = linspace(-2*pi, 2*pi, 200)
y = vecderiv(x)
plot(x,y,'+')
plot(x,cos(x))
show()
pycode-browser-1.02/Code/Maths/wfile.py 0000775 0000000 0000000 00000000130 12544046010 0017777 0 ustar 00root root 0000000 0000000 #Example wfile.py
f = open('test.dat' , 'w')
f.write ('This is a test file')
f.close()
pycode-browser-1.02/Code/Maths/wfile2.py 0000775 0000000 0000000 00000000167 12544046010 0020073 0 ustar 00root root 0000000 0000000 #Example wfile2.py
f = open('data.dat' , 'w')
for k in range(1,4):
s = '%3d\n' %(k)
f.write(s)
f.close()
pycode-browser-1.02/Code/Physics/ 0000775 0000000 0000000 00000000000 12544046010 0016670 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Physics/Mechanics/ 0000775 0000000 0000000 00000000000 12544046010 0020562 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/Physics/Mechanics/cf3d.py 0000775 0000000 0000000 00000001110 12544046010 0021747 0 ustar 00root root 0000000 0000000 import math
from visual import *
base = box (pos=(0,-5,0), length=15, height=0.01, width=0.01, color=color.black)
m1 = sphere (pos=(0,0,0), radius=1.0, color=color.blue)
m2 = sphere (pos=(4,0,0), radius=0.3, color=color.red)
G = -1.0
M = 1000.0
m = 1.0
dt = 0.01
x = math.sqrt(12.5)
y = x
vx = 10.0
vy = -vx+2
a = []
b = []
while 1:
rate(50)
r = sqrt(x**2 + y**2)
v = sqrt(vx**2 + vy**2)
F = G*M*m/r**2 + 0.7 * v
Fx = F * x/r
Fy = F * y/r
vx = vx + Fx/m * dt
vy = vy + Fy/m * dt
x = x + vx * dt
y = y + vy * dt
m2.pos=(x,y,0)
a.append(x)
b.append(y)
pycode-browser-1.02/Code/Physics/Mechanics/spring1.py 0000775 0000000 0000000 00000001151 12544046010 0022520 0 ustar 00root root 0000000 0000000 #spring1.py
from pylab import *
t = 0.0 # Stating time
dt = 0.01 # value of time increment
x = 10.0 # initial position
v = 0.0 # initial velocity
k = 10.0 # spring constant
m = 2.0 # mass of the oscillating object
tm = [] # Empty lists to store time, velocity and displacement
vel = []
dis = []
while t < 5:
f = -k * x # Try (-k*x - 0.5 * v) to add damping
v = v + (f/m ) * dt # dv = a.dt
x = x + v * dt # dS = v.dt
t = t + dt
tm.append(t)
vel.append(v)
dis.append(x)
plot(tm,vel)
plot(tm,dis)
show()
pycode-browser-1.02/Code/Physics/Mechanics/spring2.py 0000775 0000000 0000000 00000003370 12544046010 0022526 0 ustar 00root root 0000000 0000000 """
spring2.py
The rk4_two() routine in this program does a two step integration using
an array method. The current x and xprime values are kept in a global
list named 'val'.
val[0] = current position; val[1] = current velocity
The results are compared with analytically calculated values.
"""
from pylab import *
def accn(t, val):
force = -spring_const * val[0] - damping * val[1]
return force/mass
def vel(t, val):
return val[1]
def rk4_two(t, h): # Time and Step value
global xxp # x and xprime values in a 'xxp'
k1 = [0,0] # initialize 5 empty lists.
k2 = [0,0]
k3 = [0,0]
k4 = [0,0]
tmp= [0,0]
k1[0] = vel(t,xxp)
k1[1] = accn(t,xxp)
for i in range(2): # value of functions at t + h/2
tmp[i] = xxp[i] + k1[i] * h/2
k2[0] = vel(t + h/2, tmp)
k2[1] = accn(t + h/2, tmp)
for i in range(2): # value of functions at t + h/2
tmp[i] = xxp[i] + k2[i] * h/2
k3[0] = vel(t + h/2, tmp)
k3[1] = accn(t + h/2, tmp)
for i in range(2): # value of functions at t + h
tmp[i] = xxp[i] + k3[i] * h
k4[0] = vel(t+h, tmp)
k4[1] = accn(t+h, tmp)
for i in range(2): # value of functions at t + h
xxp[i] = xxp[i] + ( k1[i] + \
2.0*k2[i] + 2.0*k3[i] + k4[i]) * h/ 6.0
t = 0.0 # Stating time
h = 0.01 # Runge-Kutta step size, time increment
xxp = [2.0, 0.0] # initial position & velocity
spring_const = 100.0 # spring constant
mass = 2.0 # mass of the oscillating object
damping = 0.0
tm = [0.0] # Lists to store time, position & velocity
x = [xxp[0]]
xp = [xxp[1]]
xth = [xxp[0]]
while t < 5:
rk4_two(t,h) # Do one step RK integration
t = t + h
tm.append(t)
xp.append(xxp[1])
x.append(xxp[0])
th = 2.0 * cos(sqrt(spring_const/mass)* (t))
xth.append(th)
plot(tm,x)
plot(tm,xth,'+')
show()
pycode-browser-1.02/Code/Physics/Mechanics/spring3d.py 0000775 0000000 0000000 00000001606 12544046010 0022673 0 ustar 00root root 0000000 0000000 #spring3d.py
from visual import *
base = box (pos=(0,-1,0), length=16, height=0.1, width=4, color=color.blue)
wall = box (pos=(0,0,0), length=0.1, height=2, width=4, color=color.white)
ball = sphere (pos=(4,0,0), radius=1, color=color.red)
spring = helix(pos=(0,0,0), axis=(4,0,0), radius=0.5, color=color.red)
ball2 = sphere (pos=(-4,0,0), radius=1, color=color.green)
spring2 = helix(pos=(0,0,0), axis=(-4,0,0), radius=0.5, color=color.green)
t = 0.0
dt = 0.01
x1 = 2.0
x2 = -2.0
v1 = 0.0
v2 = 0.0
k = 1000.0
m = 1.0
while 1:
rate(20)
f1 = -k * x1
v1 = v1 + (f1/m ) * dt # Acceleration = Force / mass ; dv = a.dt
f2 = -k * x2 - v2 # damping proportional to velocity
v2 = v2 + (f2/m ) * dt # Acceleration = Force / mass ; dv = a.dt
x1 = x1 + v1 * dt
x2 = x2 + v2 * dt
t = t + dt
spring.length = 4 + x1
ball.x = x1 + 4
spring2.length = 4 - x2
ball2.x = x2 - 4
pycode-browser-1.02/Code/Physics/bes1.py 0000775 0000000 0000000 00000000315 12544046010 0020076 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
def vj0(xarray):
y = []
for x in xarray:
val = special.j0(x) # Compute Jo
y.append(val)
return y
a = linspace(0,10,100)
b = vj0(a)
plot(a,b)
show()
pycode-browser-1.02/Code/Physics/bes2.py 0000775 0000000 0000000 00000000353 12544046010 0020101 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
def vjn(n,xarray):
y = []
for x in xarray:
val = special.jn(n,x) # Compute Jn(x)
y.append(val)
return y
a = linspace(0,10,100)
for n in range(5):
b = vjn(n,a)
plot(a,b)
show()
pycode-browser-1.02/Code/Physics/bes3.py 0000775 0000000 0000000 00000001130 12544046010 0020074 0 ustar 00root root 0000000 0000000 from scipy import *
from scipy import special
import pylab
def jn(n,x):
jn = 0.0
for k in range(30):
num = (-1)**k * (x/2)**(2*k)
den = factorial(k)*factorial(n+k)
jn = jn + num/den
return jn * (x/2)**n
def vjn_local(n,xarray):
y = []
for x in xarray:
val = jn(n,x) # Jn(x) using our function
y.append(val)
return y
def vjn(n,xarray):
y = []
for x in xarray:
val = special.jn(n,x) # Compute Jn(x)
y.append(val)
return y
a = linspace(0,10,100)
for n in range(2):
b = vjn(n,a)
c = vjn_local(n,a)
pylab.plot(a,b)
pylab.plot(a,c,marker = '+')
pylab.show()
pycode-browser-1.02/Code/Physics/cf3d.py 0000775 0000000 0000000 00000001110 12544046010 0020055 0 ustar 00root root 0000000 0000000 import math
from visual import *
base = box (pos=(0,-5,0), length=15, height=0.01, width=0.01, color=color.black)
m1 = sphere (pos=(0,0,0), radius=1.0, color=color.blue)
m2 = sphere (pos=(4,0,0), radius=0.3, color=color.red)
G = -1.0
M = 1000.0
m = 1.0
dt = 0.01
x = math.sqrt(12.5)
y = x
vx = 10.0
vy = -vx+2
a = []
b = []
while 1:
rate(50)
r = sqrt(x**2 + y**2)
v = sqrt(vx**2 + vy**2)
F = G*M*m/r**2 + 0.7 * v
Fx = F * x/r
Fy = F * y/r
vx = vx + Fx/m * dt
vy = vy + Fy/m * dt
x = x + vx * dt
y = y + vy * dt
m2.pos=(x,y,0)
a.append(x)
b.append(y)
pycode-browser-1.02/Code/Physics/cp_em.py 0000775 0000000 0000000 00000001705 12544046010 0020333 0 ustar 00root root 0000000 0000000 #cp_em.py -- Motion of charged particle in E & M fields
from numpy import *
import pylab as p
import matplotlib.axes3d as p3
Ex = 0.0 # Components of Applied Electric Field
Ey = 0.0
Ez = 2.0
Bx = 0.0 # Magnetic field
By = 0.0
Bz = 2.0
m = 2.0 # Mass of the particle
q = 5.0 # Charge
x = 0.0 # Components of initial position and velocity
y = 0.0
z = 0.0
vx = 20.0
vy = 0.0
vz = 0.0
a = []
b = []
c = []
t = 0.0
dt = 0.01
while t < 6: # trace until time reaches 6 units
Fx = q * (Ex + (vy * Bz) - (vz * By) )
vx = vx + Fx/m * dt # Acceleration = F/m; dv = a.dt
Fy = q * (Ey - (vx * Bz) + (vz * Bx) )
vy = vy + Fy/m * dt
Fz = q * (Ez + (vx * By) - (vy * Bx) )
vz = vz + Fz/m * dt
# print vx,vy, sqrt(vx**2+vy**2)
x = x + vx * dt
y = y + vy * dt
z = z + vz * dt
a.append(x)
b.append(y)
c.append(z)
t = t + dt
fig=p.figure()
ax = p3.Axes3D(fig)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.plot3D(a,b,c)
p.show()
pycode-browser-1.02/Code/Physics/diff1.py 0000775 0000000 0000000 00000000742 12544046010 0020241 0 ustar 00root root 0000000 0000000 from pylab import *
dx = 0.1 # value of x increment
x = arange(0,10, dx)
y = sin(x)
yprime = [] # empty list
for k in range(99): # from 100 points we get 99 diference values
dy = y[k+1]-y[k]
yprime.append(dy/dx)
x1 = x[:-1] # A new array without the last element
x1 = x1 + dx/2 # The derivative corresponds to the middle point
plot(x1, yprime, '+')
plot(x1, cos(x1)) # Cross check with the analitic value
show()
pycode-browser-1.02/Code/Physics/fit1.py 0000775 0000000 0000000 00000000737 12544046010 0020117 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
from scipy.optimize import leastsq
def err_func(p,y,x):
A,k,theta = p
return y - A*sin(2*pi*k*x+theta)
def evaluate(x,p):
return p[0] * sin(2*pi*p[1]*x+p[2])
ax = arange(0, 0.2, 0.001)
A,k,theta = 5, 50.0, pi/3
y_true = A*sin(2*pi*k*ax+theta)
y_meas = y_true + 0.2*randn(len(ax))
p0 = [6, 50.0, pi/3]
plsq = leastsq(err_func,p0,args=(y_meas,ax))
print plsq
plot(ax,y_true)
plot(ax,y_meas,'o')
plot(ax,evaluate(ax,plsq[0]))
show()
pycode-browser-1.02/Code/Physics/fit2.py 0000775 0000000 0000000 00000000737 12544046010 0020120 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
from scipy.optimize import leastsq
def err_func(p,y,x):
A,k,theta = p
return y - A*sin(2*pi*k*x+theta)
def evaluate(x,p):
return p[0] * sin(2*pi*p[1]*x+p[2])
ax = arange(0, 0.2, 0.001)
A,k,theta = 5, 50.0, pi/3
y_true = A*sin(2*pi*k*ax+theta)
y_meas = y_true + 0.2*randn(len(ax))
p0 = [6, 50.0, pi/3]
plsq = leastsq(err_func,p0,args=(y_meas,ax))
print plsq
plot(ax,y_true)
plot(ax,y_meas,'o')
plot(ax,evaluate(ax,plsq[0]))
show()
pycode-browser-1.02/Code/Physics/fourier1.py 0000775 0000000 0000000 00000000263 12544046010 0021002 0 ustar 00root root 0000000 0000000 from pylab import *
x = linspace(0.0, 2 * pi, 100)
y = sin(x)
for h in range(3,10,2): # Add even harmonics to get square wave
y = y + sin(h*x)/h
plot(x,y)
show()
pycode-browser-1.02/Code/Physics/hydro.py 0000775 0000000 0000000 00000001205 12544046010 0020370 0 ustar 00root root 0000000 0000000 from numpy import *
from scipy import special
import pylab as p
import matplotlib.axes3d as p3
phi = linspace(0, 2*pi, 50)
theta = linspace(-pi/2, pi/2, 200)
ax = []
ay = []
az = []
R = 1.0
for t in theta:
polar = float(t)
for k in phi:
azim = float(k)
sph = special.sph_harm(0,5,azim, polar) # Y(m,l,phi,theta)
modulation = 0.2 * abs(sph)
r = R * ( 1 + modulation)
x = r*cos(polar)*cos(azim)
y = r*cos(polar)*sin(azim)
z = r*sin(polar)
# print z
# print x,y,z
ax.append(x)
ay.append(y)
az.append(z)
fig=p.figure()
f = p3.Axes3D(fig)
f.set_xlabel('X')
f.set_ylabel('Y')
f.set_zlabel('Z')
f.scatter3D(ax,ay,az)
p.show()
pycode-browser-1.02/Code/Physics/legen1.py 0000775 0000000 0000000 00000000244 12544046010 0020420 0 ustar 00root root 0000000 0000000 from scipy import linspace, special
import pylab
x = linspace(-1,1,100)
for n in range(1,6):
leg = special.legendre(n)
y = leg(x)
pylab.plot(x,y)
pylab.show()
pycode-browser-1.02/Code/Physics/numpy1.py 0000775 0000000 0000000 00000000336 12544046010 0020500 0 ustar 00root root 0000000 0000000 from numpy import *
a = array( [ 10, 20, 30, 40 ] ) # create an array out of a list
print a
print a * 3
print a / 3
b = array([1.0, 2.0, 3.0, 4.0])
c = a + b
a = array([1,2,3,4], dtype='float')
a = array([[1,2],[3,4]])
pycode-browser-1.02/Code/Physics/numpy2.py 0000775 0000000 0000000 00000000326 12544046010 0020500 0 ustar 00root root 0000000 0000000 from pylab import *
from numpy import *
x = linspace(0.0, 2 * pi, 100)
s = sin(x) # sine of each element of 'x' is taken
c = cos(x) # cosine of each element of 'x' is taken
plot(x,s)
plot(x,c)
show()
pycode-browser-1.02/Code/Physics/numpy3.py 0000775 0000000 0000000 00000000251 12544046010 0020476 0 ustar 00root root 0000000 0000000 from pylab import *
x = linspace(0.0, 2 * pi, 100)
plot(sin(x), cos(x), 'b') # plot lissagous figures
plot(sin(2*x), cos(x),'r')
plot(sin(x), cos(2*x),'y')
show()
pycode-browser-1.02/Code/Physics/plot1.py 0000775 0000000 0000000 00000000065 12544046010 0020305 0 ustar 00root root 0000000 0000000 from pylab import *
x = range(10)
plot(x)
show()
pycode-browser-1.02/Code/Physics/plot2.py 0000775 0000000 0000000 00000000172 12544046010 0020305 0 ustar 00root root 0000000 0000000 from pylab import *
x = range(10,20)
y = range(40,50)
plot(x,y, marker = '+', color = 'red', markersize = 10)
show()
pycode-browser-1.02/Code/Physics/plot3.py 0000775 0000000 0000000 00000000302 12544046010 0020301 0 ustar 00root root 0000000 0000000 from pylab import *
x = [] # empty lists
y = []
for k in range(100):
ang = 0.1 * k
sang = sin(ang)
x.append(ang)
y.append(sang)
plot(x,y)
show()
pycode-browser-1.02/Code/Physics/plot3d1.py 0000775 0000000 0000000 00000000421 12544046010 0020530 0 ustar 00root root 0000000 0000000 from numpy import *
import pylab as p
import matplotlib.axes3d as p3
w = v = u = linspace(0, 4*pi, 100)
fig=p.figure()
ax = p3.Axes3D(fig)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.plot3D(u,v,sin(w))
ax.plot3D(u,sin(v),w)
ax.plot3D(sin(u),v,u)
p.show()
pycode-browser-1.02/Code/Physics/poly1.py 0000775 0000000 0000000 00000000443 12544046010 0020312 0 ustar 00root root 0000000 0000000 import scipy
import pylab
a = scipy.poly1d([3,4,5])
print a, ' is the polynomial'
print a*a, 'is its square'
print a.deriv(), ' is its derivative'
print a.integ(), ' is its integral'
print a(0.5), 'is its value at x = 0.5'
x = scipy.linspace(0,5,100)
b = a(x)
pylab.plot(x,b)
pylab.show()
pycode-browser-1.02/Code/Physics/pyphy.lyx 0000775 0000000 0000000 00000176343 12544046010 0020620 0 ustar 00root root 0000000 0000000 #LyX 1.4.2 created this file. For more info see http://www.lyx.org/
\lyxformat 245
\begin_document
\begin_header
\textclass article
\language english
\inputencoding auto
\fontscheme default
\graphics default
\paperfontsize default
\spacing other 1.2
\papersize default
\use_geometry false
\use_amsmath 1
\cite_engine basic
\use_bibtopic false
\paperorientation portrait
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\papercolumns 1
\papersides 1
\paperpagestyle default
\tracking_changes false
\output_changes false
\end_header
\begin_body
\begin_layout Title
Python in Physics Education
\end_layout
\begin_layout Author
ajith@iuac.res.in
\end_layout
\begin_layout Section
Introduction
\end_layout
\begin_layout Standard
Mathematics is considered as the language of physics.
Physical laws are expressed as mathematical relations and they are solved
under desired boundary conditions to obtain the results.
To illustrate this point take the example of the relationship between electric
and magnetic fields as represented by the Maxwell's equations
\end_layout
\begin_layout Standard
\begin_inset Formula \[
\nabla\times E=-\frac{\partial B}{\partial t}\,;\,\,\nabla\times B=\mu_{0}J+\mu_{0}\varepsilon_{0}\frac{\partial E}{\partial t}\,;\,\nabla.E=\frac{\rho}{\varepsilon_{0}}\,;\nabla.B=0\]
\end_inset
\end_layout
\begin_layout Standard
In order to find out the field distribution inside a resonator cavity, we
need to solve these equations by applying suitable boundary conditions
dictated by the geometry of the cavity and electromagnetic properties of
the material used for making it.
For simple geometries, analytic solutions are possible but in most cases
numerical methods are essential and that is one reason why computers are
important for physics.
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
With the wide spread availability of personal computers, programming has
been included in almost all Physics courses.
Unfortunately the learning has been in separate compartments without any
attempt to apply the acquired programming skills to understand physics
in a better way.
Partially this has been due to, in my view, the complexities of the chosen
languages like FORTRAN, C, C++ etc.
Another drawback was the lack of libraries to generate visual output.
This writeup is an attempt to connect computer programming with physics
learning.
The language chosen is Python, due to its simplicity and the huge collection
of libraries, mainly the ones for doing math and graphics.
\family default
\series default
\shape default
\size default
\emph default
\bar default
\noun default
\begin_inset Foot
status open
\begin_layout Standard
All the Python programs listed in this article are on the Phoenix Live CD.
To run them boot from the liveCD, in graphics mode open a terminal, change
to directory 'phy' and type
\end_layout
\begin_layout Standard
# python program_name.py
\end_layout
\end_inset
\end_layout
\begin_layout Section
Python Basics
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
The first reaction from most of the readers would be like
\begin_inset Quotes eld
\end_inset
Oh.
No.
One more programming language.
I already had tough time learning the one know now
\begin_inset Quotes erd
\end_inset
.
Cool down, Python is not harmful as the name sounds.
A high school student with average intelligence can pick it up within two
weeks.
What is there in a programming language anyway.
It allows you to create variables, like elementary algebra, and allows
you to manipulate them using arithmetic and logical operators.
A sequence of such statements make the program.
But most of the program are are not meant for running from the first line
to the last line.
Depending on the situation some lines may execute more than once and some
may be totally skipped.
This is done by using control flow statements for looping and decision
making (while/for loops and if-elif-else kind of stuff).
The variables belong to certain types like 'integer', 'float', 'string'
etc.
If you are new to programming refer to the book 'Snake wrangling for Kids',
included in Phoenix CD.
After that, as a test, read the code fragments below and if you can guess
their outputs, you know enough to proceed with the material in this writeup.
\end_layout
\begin_layout Standard
Example 1: test1.py
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = 1
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
b = 1.2
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
c = 2 + 3j
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
d = 'i am a string'
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
e = [a, b, c, 'hello']
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print d, b * c, e #what will be the
output
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Example 2: test2.py
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = 1
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
while x <= 10:
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print x * 8
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = x + 1
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Example 3: test3.py
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
s = 'hello world'
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
m = [1, 2.3, 33, 'ha']
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
for k in s:
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print k
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
for k in m:
\end_layout
\begin_layout LyX-Code
print m
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Example 4: test4.py
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = range(10)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print x
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
for i in x:
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
if i > 8:
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print i
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Example 5: test5.py
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = [12, 23]
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a.append(45)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Example 6: test6.py ( Three different ways to import a module)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
import time
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print time.ctime()
\end_layout
\begin_layout LyX-Code
from time import *
\end_layout
\begin_layout LyX-Code
print time()
\end_layout
\begin_layout LyX-Code
import time as t
\end_layout
\begin_layout LyX-Code
print t.time()
\end_layout
\begin_layout LyX-Code
from math import sin #imports only one function
\end_layout
\begin_layout LyX-Code
print sin(2.0)
\end_layout
\begin_layout Standard
Some modules may have several sub-packages containing functions.
For example the 'Special functions' sub-package from 'scipy' module can
be imported as
\end_layout
\begin_layout LyX-Code
from scipy import special
\end_layout
\begin_layout LyX-Code
print special.j0(0.2) # print values of Bessel function
\end_layout
\begin_layout Section
Plotting Graphs
\end_layout
\begin_layout Standard
While studying physics, we come across various
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
mathematical functions.
In order to understand a function, we need to have some idea about its
derivatives, integrals, location of zeros, maxima and minima, etc.
A graphical representation conveys them quickly.
To do graph plotting without much coding, we need to use some library (
called modules in Python).
We will use Matplotlib (refer to the matplotlib user's guide on Phoenix
CD for details).
Let us start with a simple example (plot1.py).
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
from pylab import *
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = range(10)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(x)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
show()
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
The 'Matplotlib' package contains much more than simple plotting, and are
available in a module named
\family default
\series default
\shape italic
\size default
\emph default
\bar default
\noun default
pylab
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
.
The first line imports all the functions from 'pylab'.
The
\family default
\series default
\shape italic
\size default
\emph default
\bar default
\noun default
range()
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
function generates a 'list' of ten numbers, that is passed on to the plot
routine.
When only a single list is given,
\family default
\series default
\shape italic
\size default
\emph default
\bar default
\noun default
plot()
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
takes it as the y-coordinates and x-coordinates are taken from 0 to N-1,
where N is the number of y-coordinates given.
The last statement
\family default
\series default
\shape italic
\size default
\emph default
\bar default
\noun default
show()
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
tells matplotlib to display the created graphs.
You can specify both x and y coordinates to the plot routine.
It is also possible to specify several other properties like the marker
shape and color.
(plot2.py)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
from pylab import *
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = range(10,20)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
y = range(40,50)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(x,y, marker = '+', color = 'red')
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
show()
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Well, enough of the 2D plots using 'list' of integers.
How about plotting some mathematical functions.
Let us plot a sine curve.
(plot3.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = []
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
# empty lists
\end_layout
\begin_layout LyX-Code
y = []
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
for k in range(100):
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
ang = 0.1 * k
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
sang = sin(ang) # sine function from pylab
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x.append(ang)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
y.append(sang)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(x,y)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
show()
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
First we made two empty lists x and y.
Then entered a
\family default
\series default
\shape italic
\size default
\emph default
\bar default
\noun default
for loop
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
where the integer k goes from 0 to 99.
For each value of 'k' we took '0.1 * k' as the angle and added to the list
'x'.
The sine of each angle is added to the list 'y'.
Doing this kind of coding is fine if your objective is to learn computer
programming but we are trying to use it as a tool for learning physics.
\end_layout
\begin_layout Subsection
NumPy and Scipy
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
To get rid of loops etc.
we need data types likes arrays and matrices.
Fortunately Python has such libraries, for example Numpy.
For learning more about Numpy, refer to the Numpy documentation on the
Phoenix CD or www.scipy.org website.
\begin_inset Foot
status collapsed
\begin_layout Standard
Numpy documentation is not complete, however one can go through the online
help about numpy at its subpackages.
Start Python interpreter from a Terminal, import the package and ask for
help as shown below.
\end_layout
\begin_layout LyX-Code
#python
\end_layout
\begin_layout LyX-Code
>>>import numpy
\end_layout
\begin_layout LyX-Code
>>>help(numpy)
\end_layout
\begin_layout LyX-Code
>>>help(numpy.core)
\end_layout
\begin_layout LyX-Code
\end_layout
\end_inset
Try out the simple examples shown below.
(numpy1.py)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
from numpy import *
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = array( [ 10, 20, 30, 40 ] ) # create an array from a list
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a * 3
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a / 3
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
b = array([1.0, 2.0, 3.0, 4.0])
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
c = a + b
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = array([1,2,3,4], dtype='float')
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = array([[1,2],[3,4]])
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Note that the operations performed on an array is carried out on each element,
we need not do it explicitly.
Numpy has several functions for the automatic creation of array objects.
Try the following lines to see how they work.
\end_layout
\begin_layout LyX-Code
a = ones(10)
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
a = zeros(10)
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a= arange(0,10)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = arange(0, 1, 0.1)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = arange(0,10,1,dtype = 'float')
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
a = linspace(0,10,100)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
print a
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Both 'arange' and 'linspace' functions generate an array.
The first and second arguments are the first and last elements.
For 'arange' , the third argument is the increment and for 'linspace' it
is the number of elements in the array.
In the case of arange() the last element may not match with the second
argument given.
We will try to make use of them in order to plot some mathematical functions.
(numpy2.)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
x = linspace(0.0, 2 * pi, 100)
\end_layout
\begin_layout LyX-Code
s = sin(x) # sine of each element of 'x' is taken
\end_layout
\begin_layout LyX-Code
c = cos(x) # cosine of each element of 'x' is taken
\end_layout
\begin_layout LyX-Code
plot(x,s)
\end_layout
\begin_layout LyX-Code
plot(x,c)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
Note that we have not imported Numpy explicitly.
Pylab requires 'numpy' and importing pylab brings numpy automatically.
The 'linspace' function generates an array of 100 equi-spaced values ranging
from
\begin_inset Formula $0\, to\,2\pi$
\end_inset
.
Also note that the
\begin_inset Formula $sin()$
\end_inset
function ,from Numpy, is a vectorized version.
It takes an array as an argument, computes the sine of each element and
returns the result in an array.
Such features reduce the complexity of the program and allows us to concentrate
on physics rather than the computer program.
Comparing this with the previous program illustrates the simplicity achieved.
Try another example generating lissagous figures, (numpy3.py)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
from pylab import *
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = linspace(0.0, 2 * pi, 100)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(sin(x), cos(x), 'b') # plot lissagous figures
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(sin(2*x), cos(x),'r')
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(sin(x), cos(2*x),'y')
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
show()
\end_layout
\begin_layout Subsection
Fourier Series
\end_layout
\begin_layout Standard
The Fourier series is a mathematical tool used for analyzing periodic functions
by decomposing such a function into a weighted sum of much simpler sinusoidal
component functions.
Fourier series serve many useful purposes, as manipulation and conceptualizatio
n of the modal coefficients are often easier than with the original function.
Areas of application include electrical engineering, vibration analysis,
acoustics, optics, signal and image processing, and data compression.
The example below shows how to generate a Square wave using this technique.
To make the output better, increase the number of terms by changing the
second argument of the range function.
(fourier1.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = linspace(0.0, 2 * pi, 100)
\end_layout
\begin_layout LyX-Code
y = sin(x)
\end_layout
\begin_layout LyX-Code
for h in range(3,10,2):
\end_layout
\begin_layout LyX-Code
y = y + sin(h*x) / h
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Power Series
\end_layout
\begin_layout Standard
Trignometric functions like sine and cosine sounds very familiar to all
of us, due to our familiarity with them since high school days.
However most of us would find it difficult to obtain the numerical values
of sin(2.0), say, without trigonometric tables or a calculator.
We know that differentiating a sine function twice will give you the original
function, with a sign reversal, which implies
\end_layout
\begin_layout Standard
\begin_inset Formula \[
\frac{d^{2}y}{dx^{2}}+y=0\]
\end_inset
\end_layout
\begin_layout Standard
which has a series solution of the form
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
y=a_{0}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n}}{(2n)!}+a_{1}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n+1}}{(2n+1)!}\label{eq:Trig Series}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
These are the Maclaurin series for sine and cosine functions.
The following code plots several terms of the sine series and their sum.
Try varying the number of terms to see the deviation.
(series_sin.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from scipy import *
\end_layout
\begin_layout LyX-Code
x = linspace(-pi,pi,40)
\end_layout
\begin_layout LyX-Code
a = zeros(40)
\end_layout
\begin_layout LyX-Code
plot(x,sin(x))
\end_layout
\begin_layout LyX-Code
for n in range(1,5):
\end_layout
\begin_layout LyX-Code
sign = (-1)**(n+1)
\end_layout
\begin_layout LyX-Code
term = x**(2*n-1) / factorial(2*n-1)
\end_layout
\begin_layout LyX-Code
a = a + sign * term
\end_layout
\begin_layout LyX-Code
print n,sign
\end_layout
\begin_layout LyX-Code
plot(x,term)
\end_layout
\begin_layout LyX-Code
plot(x,a,'+')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The program given below evaluates the cosine function using this series
and compares it with the result of the cos() function from the math library
(that also must be doing the same).
We have written a vectored version of the cosine function that can accept
an array argument.
You can study the accuracy of the results obtained by varying the number
of terms included.
(series_cos.py)
\end_layout
\begin_layout LyX-Code
import scipy, pylab
\end_layout
\begin_layout LyX-Code
def mycos(x):
\end_layout
\begin_layout LyX-Code
res = 0.0
\end_layout
\begin_layout LyX-Code
for n in range(18):
\end_layout
\begin_layout LyX-Code
res = res + (-1)**n * (x ** (2*n)) / scipy.factorial(2*n)
\end_layout
\begin_layout LyX-Code
return res
\end_layout
\begin_layout LyX-Code
def vmycos(ax):
\end_layout
\begin_layout LyX-Code
y = []
\end_layout
\begin_layout LyX-Code
for x in ax:
\end_layout
\begin_layout LyX-Code
y.append(mycos(x))
\end_layout
\begin_layout LyX-Code
return y
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
x = scipy.linspace(0,4*scipy.pi,100)
\end_layout
\begin_layout LyX-Code
y = vmycos(x)
\end_layout
\begin_layout LyX-Code
pylab.plot(x,y)
\end_layout
\begin_layout LyX-Code
pylab.plot(x,scipy.cos(x),'+')
\end_layout
\begin_layout LyX-Code
pylab.show()
\end_layout
\begin_layout Section
3D Plots
\end_layout
\begin_layout Standard
Matplotlib has a subpackage that supports 3D plots.
Some simple examples are given below and we will come back to it later.
(plot3d1.py)
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
import pylab as p
\end_layout
\begin_layout LyX-Code
import matplotlib.axes3d as p3
\end_layout
\begin_layout LyX-Code
w = v = u = linspace(0, 4*pi, 100)
\end_layout
\begin_layout LyX-Code
fig=p.figure()
\end_layout
\begin_layout LyX-Code
ax = p3.Axes3D(fig)
\end_layout
\begin_layout LyX-Code
ax.set_xlabel('X')
\end_layout
\begin_layout LyX-Code
ax.set_ylabel('Y')
\end_layout
\begin_layout LyX-Code
ax.set_zlabel('Z')
\end_layout
\begin_layout LyX-Code
ax.plot3D(u,v,sin(w))
\end_layout
\begin_layout LyX-Code
ax.plot3D(u,sin(v),w)
\end_layout
\begin_layout LyX-Code
ax.plot3D(sin(u),v,u)
\end_layout
\begin_layout LyX-Code
p.show()
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Section
Special Functions
\end_layout
\begin_layout Standard
Solving certain differential equations give rise to special functions like
Bessel.
Legendre, Spherical harmonic etc.
depending upon the symmetry properties of the coordinate systems used.
Now we will start using another package called 'Scipy'.
\begin_inset Foot
status collapsed
\begin_layout Standard
Refer to the Phoenix CD or www.scipy.org for scipy documentation.
\end_layout
\end_inset
Scipy has subpackages for a large number of mathematical operations inclding
the computation of various special functions.
\end_layout
\begin_layout Subsection
Bessel Functions
\end_layout
\begin_layout Standard
Let us start with plotting the Bessel functions, restricted to integral
values of n, given by the expression
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
J_{n}=\left(\frac{x}{2}\right)^{n}\sum_{k=0}^{\infty}\frac{\left(-\right)^{k}\left(\frac{x}{2}\right)^{2k}}{\left(k!\right)\left(n+k\right)!}\label{eq:Bessel}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
using the following Python program.
It uses the 'Scipy' module.
(bes1.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from scipy import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def vj0(xarray):
\end_layout
\begin_layout LyX-Code
y = []
\end_layout
\begin_layout LyX-Code
for x in xarray:
\end_layout
\begin_layout LyX-Code
val = special.j0(x) # Compute Jo
\end_layout
\begin_layout LyX-Code
y.append(val)
\end_layout
\begin_layout LyX-Code
return y
\end_layout
\begin_layout LyX-Code
a = linspace(0,10,100)
\end_layout
\begin_layout LyX-Code
b = vj0(a)
\end_layout
\begin_layout LyX-Code
plot(a,b)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
Note that function calculating Bessel function does not accept array arguments.
So we had to write a vectorized version of the same.
The next example generalizes the computation to higher orders as shown
below.
(bes2.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from scipy import *
\end_layout
\begin_layout LyX-Code
def vjn(n,xarray):
\end_layout
\begin_layout LyX-Code
y = []
\end_layout
\begin_layout LyX-Code
for x in xarray:
\end_layout
\begin_layout LyX-Code
val = special.jn(n,x) # Compute Jn(x)
\end_layout
\begin_layout LyX-Code
y.append(val)
\end_layout
\begin_layout LyX-Code
return y
\end_layout
\begin_layout LyX-Code
a = linspace(0,10,100)
\end_layout
\begin_layout LyX-Code
for n in range(5):
\end_layout
\begin_layout LyX-Code
b = vjn(n,a)
\end_layout
\begin_layout LyX-Code
plot(a,b)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
In the two examples above, the order in which pylab and scipy are imported
matters due to the following reason.
The function linspace() is there in both the packages.
They do the same job but the elements of the array returned by scipy.linspace()
are 'float' type but they are 'numpy.float64' in the case of numpy.linspace().
These sort of conflicts can arise when you are importing multiple libraries.
The best way to avoid them is to use the following syntax.
\end_layout
\begin_layout LyX-Code
import scipy
\end_layout
\begin_layout LyX-Code
import numpy
\end_layout
\begin_layout LyX-Code
a = scipy.linspace(0,1,10) # from scipy
\end_layout
\begin_layout LyX-Code
b = numpy.linspace(0,1,10) # from numpy
\end_layout
\begin_layout LyX-Code
c = linspace(0,1,10) # from numpy, last import
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
Instead of using the library function from scipy(), we can calculate the
Bessel functions using the expression
\begin_inset LatexCommand \ref{eq:Bessel}
\end_inset
and compare the results.
Try changing the number of terms to see the deviations.
(bes3.py)
\end_layout
\begin_layout LyX-Code
from scipy import *
\end_layout
\begin_layout LyX-Code
from scipy import special
\end_layout
\begin_layout LyX-Code
import pylab
\end_layout
\begin_layout LyX-Code
def jn(n,x):
\end_layout
\begin_layout LyX-Code
jn = 0.0
\end_layout
\begin_layout LyX-Code
for k in range(30):
\end_layout
\begin_layout LyX-Code
num = (-1)**k * (x/2)**(2*k)
\end_layout
\begin_layout LyX-Code
den = factorial(k)*factorial(n+k)
\end_layout
\begin_layout LyX-Code
jn = jn + num/den
\end_layout
\begin_layout LyX-Code
return jn * (x/2)**n
\end_layout
\begin_layout LyX-Code
def vjn_local(n,xarray):
\end_layout
\begin_layout LyX-Code
y = []
\end_layout
\begin_layout LyX-Code
for x in xarray:
\end_layout
\begin_layout LyX-Code
val = jn(n,x) # Jn(x) using our function
\end_layout
\begin_layout LyX-Code
y.append(val)
\end_layout
\begin_layout LyX-Code
return y
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def vjn(n,xarray):
\end_layout
\begin_layout LyX-Code
y = []
\end_layout
\begin_layout LyX-Code
for x in xarray:
\end_layout
\begin_layout LyX-Code
val = special.jn(n,x) # Compute Jn(x)
\end_layout
\begin_layout LyX-Code
y.append(val)
\end_layout
\begin_layout LyX-Code
return y
\end_layout
\begin_layout LyX-Code
a = linspace(0,10,100)
\end_layout
\begin_layout LyX-Code
for n in range(2):
\end_layout
\begin_layout LyX-Code
b = vjn(n,a)
\end_layout
\begin_layout LyX-Code
c = vjn_local(n,a)
\end_layout
\begin_layout LyX-Code
pylab.plot(a,b)
\end_layout
\begin_layout LyX-Code
pylab.plot(a,c,marker = '+')
\end_layout
\begin_layout LyX-Code
pylab.show()
\end_layout
\begin_layout Subsection
Polynomials
\end_layout
\begin_layout Standard
Before proceeding with other special functions, let us have a look at the
one dimensional polynomial class 'poly1d' of Scipy.
You can define a polynomial by supplying the coefficient as a list.
For example , the statement p = poly1d([1,2,3]) constructs the polynomial
x**2 + 2 x + 3.
The following example describe the various operations you can do with this
class.
(ploy1.py)
\end_layout
\begin_layout LyX-Code
import scipy
\end_layout
\begin_layout LyX-Code
import pylab
\end_layout
\begin_layout LyX-Code
a = scipy.poly1d([3,4,5])
\end_layout
\begin_layout LyX-Code
print a, ' is the polynomial'
\end_layout
\begin_layout LyX-Code
print a*a, 'is its square'
\end_layout
\begin_layout LyX-Code
print a.deriv(), ' is its derivative'
\end_layout
\begin_layout LyX-Code
print a.integ(), ' is its integral'
\end_layout
\begin_layout LyX-Code
print a(0.5), 'is its value at x = 0.5'
\end_layout
\begin_layout LyX-Code
x = scipy.linspace(0,5,100)
\end_layout
\begin_layout LyX-Code
b = a(x)
\end_layout
\begin_layout LyX-Code
pylab.plot(a,b)
\end_layout
\begin_layout LyX-Code
pylab.show()
\end_layout
\begin_layout Standard
Note that a polynomial can take an array argument for evaluation to return
the results in an array.
\begin_inset Foot
status collapsed
\begin_layout Standard
To know more type help(poly1d) at the python prompt after importing scipy;
\end_layout
\begin_layout LyX-Code
>>>import scipy
\end_layout
\begin_layout LyX-Code
>>>help(scipy.poly1d)
\end_layout
\end_inset
\end_layout
\begin_layout Subsection
Legendre Functions
\end_layout
\begin_layout Standard
The Legendre polynomials, sometimes called Legendre functions of the first
kind, are solutions to the Legendre differential equation
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
(1-z^{2})\frac{d^{2}w}{dz^{2}}-2z\frac{dw}{dz}+n(n+1)w=0\label{eq:Legendre}\end{equation}
\end_inset
If n is an integer, they are polynomials.
The Legendre polynomials P_n(x) are illustrated using the Python program
given below.
(legen1.py)
\end_layout
\begin_layout LyX-Code
from scipy import linspace, special
\end_layout
\begin_layout LyX-Code
import pylab
\end_layout
\begin_layout LyX-Code
x = linspace(-1,1,100)
\end_layout
\begin_layout LyX-Code
for n in range(1,6):
\end_layout
\begin_layout LyX-Code
leg = special.legendre(n)
\end_layout
\begin_layout LyX-Code
y = leg(x)
\end_layout
\begin_layout LyX-Code
pylab.plot(x,y)
\end_layout
\begin_layout LyX-Code
pylab.show()
\end_layout
\begin_layout Subsection
Spherical Harmonics
\end_layout
\begin_layout Standard
In mathematics, the spherical harmonics are the angular portion of an orthogonal
set of solutions to Laplace's equation represented in a system of spherical
coordinates.
Spherical harmonics are important in many theoretical and practical application
s, particularly in the computation of atomic electron configurations, the
representation of the gravitational field, magnetic field of planetary
bodies, characterization of the cosmic microwave background radiation etc..
Laplace's equation in spherical polar coordinates can be written as
\end_layout
\begin_layout Standard
\begin_inset Formula \[
\nabla^{2}\Phi=\frac{1}{r^{2}}\frac{\partial}{\partial r}\left(r^{2}\frac{\partial\Phi}{\partial r}\right)+\frac{1}{r^{2}\sin\theta}\frac{\partial}{\partial\theta}\left(\sin\theta\frac{\partial\Phi}{\partial\theta}\right)+\frac{1}{r^{2}\sin^{2}\theta}\frac{\partial^{2}\Phi}{\partial\phi^{2}}\]
\end_inset
\end_layout
\begin_layout Standard
Separation of variables in
\begin_inset Formula $r,\theta and\phi$
\end_inset
coordinates gives the angular part of the solution as
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
Y_{l}^{m}(\theta,\phi)=\sqrt{\frac{(2\ell+1}{4\pi}\frac{(l-m)!}{(l+m)!}}P_{l}^{m}(\cos\theta)e^{im\phi}\label{eq:Spherical harmonics}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
This is a called a spherical harmonic function of degree
\begin_inset Formula $\ell$
\end_inset
and order
\begin_inset Formula $m$
\end_inset
,
\begin_inset Formula $P_{\ell}^{m}(\theta)$
\end_inset
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
\family default
\series default
\shape default
\size default
\emph default
\bar default
\noun default
an associated Legendre function.
The following program calculates the spherical harmonics for
\begin_inset Formula $\ell=10,m=0$
\end_inset
.
Change the values of
\begin_inset Formula $\ell andm$
\end_inset
to observe the changes.
(sph1.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from scipy import special
\end_layout
\begin_layout LyX-Code
a_th = [] # list to store polar angle theta from -90 to + 90 deg
\end_layout
\begin_layout LyX-Code
a_sph = [] # list to store absolute values if sperical harminics
\end_layout
\begin_layout LyX-Code
phi = 0.0 # Fix azimuth, phi at zero
\end_layout
\begin_layout LyX-Code
theta = -pi/2 # start theta from -90 deg
\end_layout
\begin_layout LyX-Code
while theta < pi/2:
\end_layout
\begin_layout LyX-Code
h = special.sph_harm(0,10, phi, theta) # (m, l , phi, theta)
\end_layout
\begin_layout LyX-Code
a_sph.append(abs(h))
\end_layout
\begin_layout LyX-Code
a_th.append(theta * 180/pi)
\end_layout
\begin_layout LyX-Code
theta = theta + 0.02
\end_layout
\begin_layout LyX-Code
plot(a_th,a_sph)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The spherical harmonics are easily visualized by counting the number of
zero crossings they possess in both the latitudinal and longitudinal directions.
For the latitudinal direction, the associated Legendre functions possess
\begin_inset Formula $\ell-\left|m\right|$
\end_inset
zeros, whereas for the longitudinal direction, the trigonomentric sin and
cos functions possess
\begin_inset Formula $2\left|m\right|$
\end_inset
zeros.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/sph_from_wp.eps
width 6cm
keepAspectRatio
\end_inset
\end_layout
\begin_layout Caption
Schematic representation of
\begin_inset Formula $Y_{\ell}^{m}$
\end_inset
on the unit sphere.
\begin_inset Formula $Y_{\ell}^{m}$
\end_inset
is equal to 0 along m great circles passing through the poles, and along
l-m circles of equal latitude.
The function changes sign each time it crosses one of these lines.
\begin_inset LatexCommand \label{fig:Schematic-representation-of Spherical harmonics}
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
When the spherical harmonic order m is zero, the spherical harmonic functions
do not depend upon longitude, and are referred to as zonal.
When
\begin_inset Formula $\ell=\left|m\right|$
\end_inset
, there are no zero crossings in latitude, and the functions are referred
to as sectoral.
For the other cases, the functions checker the sphere, and they are referred
to as tesseral.
The variation of a function on the surface of a sphere is shown in figure
\begin_inset LatexCommand \ref{fig:Schematic-representation-of Spherical harmonics}
\end_inset
.
The Python program given below gives a 3D plot of a sphere.
The radius is modulated using the value of
\begin_inset Formula $Y_{\ell}^{m}$
\end_inset
so that we can visualize it.
(sph2.py)
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
from scipy import special
\end_layout
\begin_layout LyX-Code
import pylab as p
\end_layout
\begin_layout LyX-Code
import matplotlib.axes3d as p3
\end_layout
\begin_layout LyX-Code
phi = linspace(0, 2*pi, 50)
\end_layout
\begin_layout LyX-Code
theta = linspace(-pi/2, pi/2, 200)
\end_layout
\begin_layout LyX-Code
ax = []
\end_layout
\begin_layout LyX-Code
ay = []
\end_layout
\begin_layout LyX-Code
az = []
\end_layout
\begin_layout LyX-Code
R = 1.0
\end_layout
\begin_layout LyX-Code
for t in theta:
\end_layout
\begin_layout LyX-Code
polar = float(t)
\end_layout
\begin_layout LyX-Code
for k in phi:
\end_layout
\begin_layout LyX-Code
azim = float(k)
\end_layout
\begin_layout LyX-Code
sph = special.sph_harm(0,5,azim, polar) # Y(m,l,phi,theta)
\end_layout
\begin_layout LyX-Code
modulation = 0.2 * abs(sph)
\end_layout
\begin_layout LyX-Code
r = R * ( 1 + modulation)
\end_layout
\begin_layout LyX-Code
x = r*cos(polar)*cos(azim)
\end_layout
\begin_layout LyX-Code
y = r*cos(polar)*sin(azim)
\end_layout
\begin_layout LyX-Code
z = r*sin(polar)
\end_layout
\begin_layout LyX-Code
ax.append(x)
\end_layout
\begin_layout LyX-Code
ay.append(y)
\end_layout
\begin_layout LyX-Code
az.append(z)
\end_layout
\begin_layout LyX-Code
fig=p.figure()
\end_layout
\begin_layout LyX-Code
f = p3.Axes3D(fig)
\end_layout
\begin_layout LyX-Code
f.set_xlabel('X')
\end_layout
\begin_layout LyX-Code
f.set_ylabel('Y')
\end_layout
\begin_layout LyX-Code
f.set_zlabel('Z')
\end_layout
\begin_layout LyX-Code
f.scatter3D(ax,ay,az)
\end_layout
\begin_layout LyX-Code
p.show()
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Section
Numerical Differentiation
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
Simple Numerical Differentiation For a function y=f(x) , the derivative
\begin_inset Formula $dy/dx$
\end_inset
can be obtained numerically.
We take the difference between consecutive elements
\begin_inset Formula $dy$
\end_inset
and divide it with the x increment
\begin_inset Formula $dx$
\end_inset
.
The following program create an array of
\begin_inset Formula $sines$
\end_inset
and find the derivative numerically.
The result is compared with the
\begin_inset Formula $cosines$
\end_inset
.
(diff1.py)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
from pylab import *
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
dx = 0.1 # value of x increment
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x = arange(0,10, dx)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
y = sin(x)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
yprime = [] # empty list
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
for k in range(99): # from 100 points we get 99 diference values
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
dy = y[k+1]-y[k]
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
yprime.append(dy/dx)
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x1 = x[:-1] # A new array without the last element
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
x1 = x1 + dx/2 # The derivative corresponds to the middle point
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(x1, yprime, '+')
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
plot(x1, cos(x1)) # Cross check with the analytic value
\end_layout
\begin_layout LyX-Code
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
show()
\end_layout
\begin_layout Standard
(to be modified later)
\end_layout
\begin_layout Section
Solving Differential Equations
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
If we know the value of a function
\begin_inset Formula $y=f(x)$
\end_inset
and its derivative at some particular value of 'x' , we can calculate the
value of the function at a nearby point
\begin_inset Formula $x+dx$
\end_inset
.
\begin_inset Formula $Y_{n+1}$
\end_inset
=
\begin_inset Formula $Y_{n}$
\end_inset
+
\begin_inset Formula $dx.(dy/dx)$
\end_inset
.
Integrating a function using this method is not very efficient compared
to the more sophisticated methods like fourth order Runge-Kutta.
However our objective is to just understand how numerical integration works.
We will trace the 'sine' function, that can be
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
\frac{d(\sin(x))}{dx}=\cos(x)\label{eq:sine}\end{equation}
\end_inset
\end_layout
\begin_layout Subsection
Runge-Kutta Integration
\end_layout
\begin_layout Standard
In the previous section we have used the Euler method that uses the formula
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
y_{n+1}=y_{n}+hf(x_{n},y_{n})\label{eq:Euler}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
to evaluate the value of 'y' at point 'n+1' using the known value at 'n'.
The formula is asymmetrical since it uses the derivative information at
the beginning of the interval.
In Fourth order Runge-Kutta method, for each step the derivative is evaluated
four times; once at the initial point, twice at two trial midpoints, once
at trial a endpoint.
The final value is evaluated from these derivatives using the equations
\end_layout
\begin_layout Standard
\begin_inset Formula \[
k_{1}=hf(x_{n},y_{n})\]
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Formula \[
k_{2}=hf(x_{n}+\frac{h}{2},y_{n}+\frac{k_{1}}{2})\]
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Formula \[
k_{3}=hf(x_{n}+\frac{h}{2},y_{n}+\frac{k_{2}}{2})\]
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Formula \[
k_{4}=hf(x_{n}+h,y_{n}+k_{3})\]
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Formula \[
y_{n+1}=y_{n}+\frac{k_{1}}{6}+\frac{k_{2}}{3}+\frac{k_{3}}{3}+\frac{k_{4}}{6}\]
\end_inset
\end_layout
\begin_layout Standard
In numerical analysis, the Runge-Kutta methods are an important family of
implicit and explicit iterative methods for the approximation of solutions
of ordinary differential equations.
These techniques were developed around 1900 by the German mathematicians
C.
Runge and M.W.
Kutta.
For more details on fouth order Runge-Kutta method refer to the file 'rk.pdf'
on the Phoenix Live CD.
The following program makes the sine curve using
\shape italic
fourth order RK method
\shape default
.
At any point the derivative of the curve is cos(t) and we use this information
to estimate the next point.
(rk_sin.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def func(t):
\end_layout
\begin_layout LyX-Code
return cos(t)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def rk4(s,t):
\end_layout
\begin_layout LyX-Code
k1 = dt * func(t)
\end_layout
\begin_layout LyX-Code
k2 = dt * func(t + dt/2.0)
\end_layout
\begin_layout LyX-Code
k3 = dt * func(t + dt/2.0)
\end_layout
\begin_layout LyX-Code
k4 = dt * func(t + dt)
\end_layout
\begin_layout LyX-Code
return s + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
t = 0.0 # Stating angle
\end_layout
\begin_layout LyX-Code
dt = 0.01 # value of angle increment
\end_layout
\begin_layout LyX-Code
val = 0.0 # value of the 'sine' function at t = 0
\end_layout
\begin_layout LyX-Code
tm = [0.0] # List to store theta values
\end_layout
\begin_layout LyX-Code
res = [0.0] # RK4 results
\end_layout
\begin_layout LyX-Code
while t < 10:
\end_layout
\begin_layout LyX-Code
val = rk4(val,t) # get the new value
\end_layout
\begin_layout LyX-Code
t = t + dt
\end_layout
\begin_layout LyX-Code
tm.append(t)
\end_layout
\begin_layout LyX-Code
res.append(val)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
plot(tm, res,'+')
\end_layout
\begin_layout LyX-Code
plot(tm, sin(tm)) # compare with actual curve
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Physics Simulations
\end_layout
\begin_layout Standard
Using the numerical methods discussed in the previous sections we will try
to solve some simple problems in physics, like calculating the trajectory
of an object in a known force field.
\end_layout
\begin_layout Subsection
Mass-Spring Problem
\end_layout
\begin_layout Standard
As a simple example let us
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
take the "Mass-Spring" problem.
A mass is attached to one end of a spring whose other end is fixed.
If we displace the mass from the equilibrium position by
\begin_inset Formula $x$
\end_inset
, the force is given by the relation
\begin_inset Formula $F=-kx$
\end_inset
, where
\begin_inset Formula $k$
\end_inset
is the spring constant.
If we release the mass at this point, it will start oscillating.
The objective is to plot the displacement of the mass as a function of
time.
The force is known at the initial point
\begin_inset Formula $-kx$
\end_inset
, the acceleration of the mass when it is released is given by Newton's
equation
\begin_inset Formula $F=ma$
\end_inset
, where m is the mass of the object.
The initial position is Xo and initial velocity Vo is zero.
We can integrate the acceleration to find out the velocity after a small
time interval 'dt'.
Similarly, integrating the velocity will give the displacement.
(spring1.py)
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
t = 0.0 # Stating time
\end_layout
\begin_layout LyX-Code
dt = 0.01 # value of time increment
\end_layout
\begin_layout LyX-Code
x = 10.0 # initial position
\end_layout
\begin_layout LyX-Code
v = 0.0 # initial velocity
\end_layout
\begin_layout LyX-Code
k = 10.0 # spring constant
\end_layout
\begin_layout LyX-Code
m = 2.0 # mass of the oscillating object
\end_layout
\begin_layout LyX-Code
tm = [] # Empty lists to store time, velocity and displacement
\end_layout
\begin_layout LyX-Code
vel = []
\end_layout
\begin_layout LyX-Code
dis = []
\end_layout
\begin_layout LyX-Code
while t < 5:
\end_layout
\begin_layout LyX-Code
f = -k * x # Try (-k*x - 0.5 * v) to add damping
\end_layout
\begin_layout LyX-Code
v = v + (f/m ) * dt # dv = a.dt
\end_layout
\begin_layout LyX-Code
x = x + v * dt # dS = v.dt
\end_layout
\begin_layout LyX-Code
t = t + dt
\end_layout
\begin_layout LyX-Code
tm.append(t)
\end_layout
\begin_layout LyX-Code
vel.append(v)
\end_layout
\begin_layout LyX-Code
dis.append(x)
\end_layout
\begin_layout LyX-Code
plot(tm,vel)
\end_layout
\begin_layout LyX-Code
plot(tm,dis)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
From the result we can see the phase relationship between the velocity and
the displacement.
If you want to see the effect of damping add that to the expression for
force.
Try changing parameters like spring constant, mass etc.
to study the effect of them on the result.
\end_layout
\begin_layout Standard
The above problem is solved using the Fourth order Runge-Kutta method in
the program listed below.
The displacement, as a function of time, calculated using RK method is
compared with the result of the analytical expression.
(spring2.py)
\end_layout
\begin_layout LyX-Code
"""
\end_layout
\begin_layout LyX-Code
The rk4_two() routine in this program does a two step integration using
\end_layout
\begin_layout LyX-Code
an array method.
The current x and xprime values are kept in a global
\end_layout
\begin_layout LyX-Code
list named 'val'.
\end_layout
\begin_layout LyX-Code
val[0] = current position; val[1] = current velocity
\end_layout
\begin_layout LyX-Code
The results are compared with analytically calculated values.
\end_layout
\begin_layout LyX-Code
"""
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
def accn(t, val):
\end_layout
\begin_layout LyX-Code
force = -spring_const * val[0] - damping * val[1]
\end_layout
\begin_layout LyX-Code
return force/mass
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def vel(t, val):
\end_layout
\begin_layout LyX-Code
return val[1]
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def rk4_two(t, h): # Time and Step value
\end_layout
\begin_layout LyX-Code
global xxp # x and xprime values in a 'xxp'
\end_layout
\begin_layout LyX-Code
k1 = [0,0] # initialize 5 empty lists.
\end_layout
\begin_layout LyX-Code
k2 = [0,0]
\end_layout
\begin_layout LyX-Code
k3 = [0,0]
\end_layout
\begin_layout LyX-Code
k4 = [0,0]
\end_layout
\begin_layout LyX-Code
tmp= [0,0]
\end_layout
\begin_layout LyX-Code
k1[0] = vel(t,xxp)
\end_layout
\begin_layout LyX-Code
k1[1] = accn(t,xxp)
\end_layout
\begin_layout LyX-Code
for i in range(2): # value of functions at t + h/2
\end_layout
\begin_layout LyX-Code
tmp[i] = xxp[i] + k1[i] * h/2
\end_layout
\begin_layout LyX-Code
k2[0] = vel(t + h/2, tmp)
\end_layout
\begin_layout LyX-Code
k2[1] = accn(t + h/2, tmp)
\end_layout
\begin_layout LyX-Code
for i in range(2): # value of functions at t + h/2
\end_layout
\begin_layout LyX-Code
tmp[i] = xxp[i] + k2[i] * h/2
\end_layout
\begin_layout LyX-Code
k3[0] = vel(t + h/2, tmp)
\end_layout
\begin_layout LyX-Code
k3[1] = accn(t + h/2, tmp)
\end_layout
\begin_layout LyX-Code
for i in range(2): # value of functions at t + h
\end_layout
\begin_layout LyX-Code
tmp[i] = xxp[i] + k3[i] * h
\end_layout
\begin_layout LyX-Code
k4[0] = vel(t+h, tmp)
\end_layout
\begin_layout LyX-Code
k4[1] = accn(t+h, tmp)
\end_layout
\begin_layout LyX-Code
for i in range(2): # value of functions at t + h
\end_layout
\begin_layout LyX-Code
xxp[i] = xxp[i] + ( k1[i] +
\backslash
\end_layout
\begin_layout LyX-Code
2.0*k2[i] + 2.0*k3[i] + k4[i]) * h/ 6.0
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
t = 0.0 # Stating time
\end_layout
\begin_layout LyX-Code
h = 0.01 # Runge-Kutta step size, time increment
\end_layout
\begin_layout LyX-Code
xxp = [2.0, 0.0] # initial position & velocity
\end_layout
\begin_layout LyX-Code
spring_const = 100.0 # spring constant
\end_layout
\begin_layout LyX-Code
mass = 2.0 # mass of the oscillating object
\end_layout
\begin_layout LyX-Code
damping = 0.0
\end_layout
\begin_layout LyX-Code
tm = [0.0] # Lists to store time, position & velocity
\end_layout
\begin_layout LyX-Code
x = [xxp[0]]
\end_layout
\begin_layout LyX-Code
xp = [xxp[1]]
\end_layout
\begin_layout LyX-Code
xth = [xxp[0]]
\end_layout
\begin_layout LyX-Code
while t < 5:
\end_layout
\begin_layout LyX-Code
rk4_two(t,h) # Do one step RK integration
\end_layout
\begin_layout LyX-Code
t = t + h
\end_layout
\begin_layout LyX-Code
tm.append(t)
\end_layout
\begin_layout LyX-Code
xp.append(xxp[1])
\end_layout
\begin_layout LyX-Code
x.append(xxp[0])
\end_layout
\begin_layout LyX-Code
th = 2.0 * cos(sqrt(spring_const/mass)* (t))
\end_layout
\begin_layout LyX-Code
xth.append(th)
\end_layout
\begin_layout LyX-Code
plot(tm,x)
\end_layout
\begin_layout LyX-Code
plot(tm,xth,'+')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsubsection
Mass Spring problem in 3D
\end_layout
\begin_layout Standard
The following program displays the movement of the mass attached toa spring
in 3D graphics.
(spring3d.py)
\end_layout
\begin_layout LyX-Code
from visual import *
\end_layout
\begin_layout LyX-Code
base = box (pos=(0,-1,0), length=16, height=0.1, width=4, color=color.blue)
\end_layout
\begin_layout LyX-Code
wall = box (pos=(0,0,0), length=0.1, height=2, width=4, color=color.white)
\end_layout
\begin_layout LyX-Code
ball = sphere (pos=(4,0,0), radius=1, color=color.red)
\end_layout
\begin_layout LyX-Code
spring = helix(pos=(0,0,0), axis=(4,0,0), radius=0.5, color=color.red)
\end_layout
\begin_layout LyX-Code
ball2 = sphere (pos=(-4,0,0), radius=1, color=color.green)
\end_layout
\begin_layout LyX-Code
spring2 = helix(pos=(0,0,0), axis=(-4,0,0), radius=0.5, color=color.green)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
t = 0.0
\end_layout
\begin_layout LyX-Code
dt = 0.01
\end_layout
\begin_layout LyX-Code
x1 = 2.0
\end_layout
\begin_layout LyX-Code
x2 = -2.0
\end_layout
\begin_layout LyX-Code
v1 = 0.0
\end_layout
\begin_layout LyX-Code
v2 = 0.0
\end_layout
\begin_layout LyX-Code
k = 1000.0
\end_layout
\begin_layout LyX-Code
m = 1.0
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
while 1:
\end_layout
\begin_layout LyX-Code
rate(20)
\end_layout
\begin_layout LyX-Code
f1 = -k * x1
\end_layout
\begin_layout LyX-Code
v1 = v1 + (f1/m ) * dt # Acceleration = Force / mass ; dv = a.dt
\end_layout
\begin_layout LyX-Code
f2 = -k * x2 - v2 # damping proportional to velocity
\end_layout
\begin_layout LyX-Code
v2 = v2 + (f2/m ) * dt # Acceleration = Force / mass ; dv = a.dt
\end_layout
\begin_layout LyX-Code
x1 = x1 + v1 * dt
\end_layout
\begin_layout LyX-Code
x2 = x2 + v2 * dt
\end_layout
\begin_layout LyX-Code
t = t + dt
\end_layout
\begin_layout LyX-Code
spring.length = 4 + x1
\end_layout
\begin_layout LyX-Code
ball.x = x1 + 4
\end_layout
\begin_layout LyX-Code
spring2.length = 4 - x2
\end_layout
\begin_layout LyX-Code
ball2.x = x2 - 4
\end_layout
\begin_layout Subsection
Charged particle in Electric and Magnetic Fields
\end_layout
\begin_layout Standard
The following example traces the movement of a charged particle under the
influence of electric and magnetic fields.
You can edit the program to change the components of the feilds to see
their effect on the trajectory.
For better results we should rewrite it using RK4 method.
(cp_em.py)
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
import pylab as p
\end_layout
\begin_layout LyX-Code
import matplotlib.axes3d as p3
\end_layout
\begin_layout LyX-Code
Ex = 0.0 # Components of Applied Electric Field
\end_layout
\begin_layout LyX-Code
Ey = 2.0
\end_layout
\begin_layout LyX-Code
Ez = 0.0
\end_layout
\begin_layout LyX-Code
Bx = 0.0 # Magnetic field
\end_layout
\begin_layout LyX-Code
By = 0.0
\end_layout
\begin_layout LyX-Code
Bz = 2.0
\end_layout
\begin_layout LyX-Code
m = 2.0 # Mass of the particle
\end_layout
\begin_layout LyX-Code
q = 5.0 # Charge
\end_layout
\begin_layout LyX-Code
x = 0.0 # Components of initial position and velocity
\end_layout
\begin_layout LyX-Code
y = 0.0
\end_layout
\begin_layout LyX-Code
z = 0.0
\end_layout
\begin_layout LyX-Code
vx = 20.0
\end_layout
\begin_layout LyX-Code
vy = 0.0
\end_layout
\begin_layout LyX-Code
vz = 0.0
\end_layout
\begin_layout LyX-Code
a = []
\end_layout
\begin_layout LyX-Code
b = []
\end_layout
\begin_layout LyX-Code
c = []
\end_layout
\begin_layout LyX-Code
t = 0.0
\end_layout
\begin_layout LyX-Code
dt = 0.01
\end_layout
\begin_layout LyX-Code
while t < 6: # trace until time reaches 1
\end_layout
\begin_layout LyX-Code
Fx = q * (Ex + (vy * Bz) - (vz * By) )
\end_layout
\begin_layout LyX-Code
vx = vx + Fx/m * dt # Acceleration = F/m; dv = a.dt
\end_layout
\begin_layout LyX-Code
Fy = q * (Ey - (vx * Bz) + (vz * Bx) )
\end_layout
\begin_layout LyX-Code
vy = vy + Fy/m * dt
\end_layout
\begin_layout LyX-Code
Fz = q * (Ez + (vx * By) - (vy * Bx) )
\end_layout
\begin_layout LyX-Code
vz = vz + Fz/m * dt
\end_layout
\begin_layout LyX-Code
x = x + vx * dt
\end_layout
\begin_layout LyX-Code
y = y + vy * dt
\end_layout
\begin_layout LyX-Code
z = z + vz * dt
\end_layout
\begin_layout LyX-Code
a.append(x)
\end_layout
\begin_layout LyX-Code
b.append(y)
\end_layout
\begin_layout LyX-Code
c.append(z)
\end_layout
\begin_layout LyX-Code
t = t + dt
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
p.plot(c,b)
\end_layout
\begin_layout LyX-Code
fig=p.figure()
\end_layout
\begin_layout LyX-Code
ax = p3.Axes3D(fig)
\end_layout
\begin_layout LyX-Code
ax.set_xlabel('X')
\end_layout
\begin_layout LyX-Code
ax.set_ylabel('Y')
\end_layout
\begin_layout LyX-Code
ax.set_zlabel('Z')
\end_layout
\begin_layout LyX-Code
ax.plot3D(a,b,c)
\end_layout
\begin_layout LyX-Code
p.show()
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout Subsection
Motion in a central field
\end_layout
\begin_layout Standard
Run the program cf3d.py from the CD to simulate motion of a mass in a gravitation
al field.
\end_layout
\begin_layout Section
Matrix manipulation
\end_layout
\begin_layout Standard
(todo)
\end_layout
\begin_layout Section
Random Distributions
\end_layout
\begin_layout Standard
(todo)
\end_layout
\end_body
\end_document
pycode-browser-1.02/Code/Physics/readme 0000775 0000000 0000000 00000000171 12544046010 0020052 0 ustar 00root root 0000000 0000000 This directory contains small examples of numerical computation using
Python. To run them, for example;
#python plot1.py pycode-browser-1.02/Code/Physics/rk_sin.py 0000775 0000000 0000000 00000001131 12544046010 0020526 0 ustar 00root root 0000000 0000000 from pylab import *
def func(t):
return cos(t)
def rk4(s,t):
k1 = dt * func(t)
k2 = dt * func(t + dt/2.0)
k3 = dt * func(t + dt/2.0)
k4 = dt * func(t + dt)
return s + ( k1/6 + k2/3 + k3/3 + k4/6 )
t = 0.0 # Stating angle
dt = 0.01 # value of angle increment
val = 0.0 # value of the 'sine' function at t = 0
tm = [0.0] # List to store theta values
res = [0.0] # RK4 results
while t < 2*pi:
val = rk4(val,t) # get the new value
t = t + dt
tm.append(t)
res.append(val)
plot(tm, res,'+')
plot(tm, sin(tm)) # compare with actual curve
show()
pycode-browser-1.02/Code/Physics/series_cos.py 0000775 0000000 0000000 00000000504 12544046010 0021402 0 ustar 00root root 0000000 0000000 import scipy, pylab
def mycos(x):
res = 0.0
for n in range(18):
res = res + (-1)**n * (x ** (2*n)) / scipy.factorial(2*n)
return res
def vmycos(ax):
y = []
for x in ax:
y.append(mycos(x))
return y
x = scipy.linspace(0,4*scipy.pi,100)
y = vmycos(x)
pylab.plot(x,y)
pylab.plot(x,scipy.cos(x),'+')
pylab.show()
pycode-browser-1.02/Code/Physics/series_sin.py 0000775 0000000 0000000 00000000365 12544046010 0021414 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import *
x = linspace(-pi,pi,40)
a = zeros(40)
plot(x,sin(x))
for n in range(1,5):
sign = (-1)**(n+1)
term = x**(2*n-1) / factorial(2*n-1)
a = a + sign * term
print n,sign
plot(x,term)
plot(x,a,'+')
show()
pycode-browser-1.02/Code/Physics/sph1.py 0000775 0000000 0000000 00000000667 12544046010 0020131 0 ustar 00root root 0000000 0000000 from pylab import *
from scipy import special
a_th = [] # list to store polar angle theta from -90 to + 90 deg
a_sph = [] # list to store absolute values if sperical harminics
phi = 0.0 # Fix azimuth, phi at zero
theta = -pi/2 # start theta from -90 deg
while theta < pi/2:
h = special.sph_harm(0,10, phi, theta) # (m, l , phi, theta)
a_sph.append(abs(h))
a_th.append(theta * 180/pi)
theta = theta + 0.02
plot(a_th,a_sph)
show()
pycode-browser-1.02/Code/Physics/sph2.py 0000775 0000000 0000000 00000001205 12544046010 0020117 0 ustar 00root root 0000000 0000000 from numpy import *
from scipy import special
import pylab as p
import matplotlib.axes3d as p3
phi = linspace(0, 2*pi, 50)
theta = linspace(-pi/2, pi/2, 200)
ax = []
ay = []
az = []
R = 1.0
for t in theta:
polar = float(t)
for k in phi:
azim = float(k)
sph = special.sph_harm(0,2,azim, polar) # Y(m,l,phi,theta)
modulation = 0.2 * abs(sph)
r = R * ( 1 + modulation)
x = r*cos(polar)*cos(azim)
y = r*cos(polar)*sin(azim)
z = r*sin(polar)
# print z
# print x,y,z
ax.append(x)
ay.append(y)
az.append(z)
fig=p.figure()
f = p3.Axes3D(fig)
f.set_xlabel('X')
f.set_ylabel('Y')
f.set_zlabel('Z')
f.scatter3D(ax,ay,az)
p.show()
pycode-browser-1.02/Code/Physics/spring1.py 0000775 0000000 0000000 00000001151 12544046010 0020626 0 ustar 00root root 0000000 0000000 #spring1.py
from pylab import *
t = 0.0 # Stating time
dt = 0.01 # value of time increment
x = 10.0 # initial position
v = 0.0 # initial velocity
k = 10.0 # spring constant
m = 2.0 # mass of the oscillating object
tm = [] # Empty lists to store time, velocity and displacement
vel = []
dis = []
while t < 5:
f = -k * x # Try (-k*x - 0.5 * v) to add damping
v = v + (f/m ) * dt # dv = a.dt
x = x + v * dt # dS = v.dt
t = t + dt
tm.append(t)
vel.append(v)
dis.append(x)
plot(tm,vel)
plot(tm,dis)
show()
pycode-browser-1.02/Code/Physics/spring2.py 0000775 0000000 0000000 00000003370 12544046010 0020634 0 ustar 00root root 0000000 0000000 """
spring2.py
The rk4_two() routine in this program does a two step integration using
an array method. The current x and xprime values are kept in a global
list named 'val'.
val[0] = current position; val[1] = current velocity
The results are compared with analytically calculated values.
"""
from pylab import *
def accn(t, val):
force = -spring_const * val[0] - damping * val[1]
return force/mass
def vel(t, val):
return val[1]
def rk4_two(t, h): # Time and Step value
global xxp # x and xprime values in a 'xxp'
k1 = [0,0] # initialize 5 empty lists.
k2 = [0,0]
k3 = [0,0]
k4 = [0,0]
tmp= [0,0]
k1[0] = vel(t,xxp)
k1[1] = accn(t,xxp)
for i in range(2): # value of functions at t + h/2
tmp[i] = xxp[i] + k1[i] * h/2
k2[0] = vel(t + h/2, tmp)
k2[1] = accn(t + h/2, tmp)
for i in range(2): # value of functions at t + h/2
tmp[i] = xxp[i] + k2[i] * h/2
k3[0] = vel(t + h/2, tmp)
k3[1] = accn(t + h/2, tmp)
for i in range(2): # value of functions at t + h
tmp[i] = xxp[i] + k3[i] * h
k4[0] = vel(t+h, tmp)
k4[1] = accn(t+h, tmp)
for i in range(2): # value of functions at t + h
xxp[i] = xxp[i] + ( k1[i] + \
2.0*k2[i] + 2.0*k3[i] + k4[i]) * h/ 6.0
t = 0.0 # Stating time
h = 0.01 # Runge-Kutta step size, time increment
xxp = [2.0, 0.0] # initial position & velocity
spring_const = 100.0 # spring constant
mass = 2.0 # mass of the oscillating object
damping = 0.0
tm = [0.0] # Lists to store time, position & velocity
x = [xxp[0]]
xp = [xxp[1]]
xth = [xxp[0]]
while t < 5:
rk4_two(t,h) # Do one step RK integration
t = t + h
tm.append(t)
xp.append(xxp[1])
x.append(xxp[0])
th = 2.0 * cos(sqrt(spring_const/mass)* (t))
xth.append(th)
plot(tm,x)
plot(tm,xth,'+')
show()
pycode-browser-1.02/Code/Physics/spring3d.py 0000775 0000000 0000000 00000001606 12544046010 0021001 0 ustar 00root root 0000000 0000000 #spring3d.py
from visual import *
base = box (pos=(0,-1,0), length=16, height=0.1, width=4, color=color.blue)
wall = box (pos=(0,0,0), length=0.1, height=2, width=4, color=color.white)
ball = sphere (pos=(4,0,0), radius=1, color=color.red)
spring = helix(pos=(0,0,0), axis=(4,0,0), radius=0.5, color=color.red)
ball2 = sphere (pos=(-4,0,0), radius=1, color=color.green)
spring2 = helix(pos=(0,0,0), axis=(-4,0,0), radius=0.5, color=color.green)
t = 0.0
dt = 0.01
x1 = 2.0
x2 = -2.0
v1 = 0.0
v2 = 0.0
k = 1000.0
m = 1.0
while 1:
rate(20)
f1 = -k * x1
v1 = v1 + (f1/m ) * dt # Acceleration = Force / mass ; dv = a.dt
f2 = -k * x2 - v2 # damping proportional to velocity
v2 = v2 + (f2/m ) * dt # Acceleration = Force / mass ; dv = a.dt
x1 = x1 + v1 * dt
x2 = x2 + v2 * dt
t = t + dt
spring.length = 4 + x1
ball.x = x1 + 4
spring2.length = 4 - x2
ball2.x = x2 - 4
pycode-browser-1.02/Code/PythonBook/ 0000775 0000000 0000000 00000000000 12544046010 0017342 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/PythonBook/chap2/ 0000775 0000000 0000000 00000000000 12544046010 0020337 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/PythonBook/chap2/area.py 0000775 0000000 0000000 00000000160 12544046010 0021621 0 ustar 00root root 0000000 0000000 #Example: area.py
pi = 3.1416
r = input('Enter Radius ')
a = pi * r ** 2 #A=\pi r^{2}
print 'Area = ', a
pycode-browser-1.02/Code/PythonBook/chap2/badtable.py 0000775 0000000 0000000 00000000123 12544046010 0022446 0 ustar 00root root 0000000 0000000 #Example: badtable.py
print 1 * 8
print 2 * 8
print 3 * 8
print 4 * 8
print 5 * 8
pycode-browser-1.02/Code/PythonBook/chap2/big.py 0000775 0000000 0000000 00000000233 12544046010 0021453 0 ustar 00root root 0000000 0000000 #Example: big.py
x = input('Enter a number ')
if x > 10:
print 'Bigger Number'
elif x < 10:
print 'Smaller Number'
else:
print 'Same Number'
pycode-browser-1.02/Code/PythonBook/chap2/big2.py 0000775 0000000 0000000 00000000214 12544046010 0021534 0 ustar 00root root 0000000 0000000 #Example: big2.py
x = 1
while x < 11:
if x < 5:
print 'Samll ', x
else:
print 'Big ', x
x = x + 1
print 'Done'
pycode-browser-1.02/Code/PythonBook/chap2/big3.py 0000775 0000000 0000000 00000000302 12544046010 0021533 0 ustar 00root root 0000000 0000000 x = 1
while x < 10:
if x < 3:
print 'skipping work', x
x = x + 1
continue
print x
if x == 4:
print 'Enough of work'
break
x = x + 1
print 'Done'
pycode-browser-1.02/Code/PythonBook/chap2/compare.py 0000775 0000000 0000000 00000000120 12544046010 0022333 0 ustar 00root root 0000000 0000000 x = raw_input('Enter a string ')
if x == 'hello':
print 'You typed ', x
pycode-browser-1.02/Code/PythonBook/chap2/conflict.py 0000775 0000000 0000000 00000000365 12544046010 0022521 0 ustar 00root root 0000000 0000000 #Example conflict.py
from numpy import *
x = linspace(0, 5, 10) # make a 10 element array
print sin(x) # sin of scipy can handle arrays
from math import * # sin of math will be called now
print sin(x) # will give ERROR
pycode-browser-1.02/Code/PythonBook/chap2/cpoint.py 0000775 0000000 0000000 00000000430 12544046010 0022205 0 ustar 00root root 0000000 0000000 from point import *
class colPoint(Point): #colPoint inherits Point
color = 'black'
def __init__(self,x=0, y=0, col='black'):
Point.__init__(self,x,y)
self.color = col
def __str__(self):
return '%s colored Point at (%f,%f)'%(self.color,self.xpos, self.ypos)
pycode-browser-1.02/Code/PythonBook/chap2/draw.py 0000775 0000000 0000000 00000012232 12544046010 0021651 0 ustar 00root root 0000000 0000000 from Tkinter import *
AXWIDTH = 30 # width of the axis display canvas
class disp:
"""
Class for displaying items in a canvas using a world coordinate system. The range of the
world coordinate system is specified by calling the setWorld method.
"""
border = 0
pad = 0
bordcol = 'grey' # Border color
gridcol = 'grey' # Grid color
bgcolor = '#dbdbdb' # background color for all
plotbg = 'ivory' # Plot window background color
textcolor = 'blue'
traces = []
xtext = []
ytext = []
markerval = []
markertext = None
def __init__(self, parent, width=400., height=100.,color = 'ivory'):
self.parent = parent
self.SCX = width
self.SCY = height
self.plotbg = color
f = Frame(parent, bg = self.bgcolor, borderwidth = self.pad)
f.pack(side=TOP)
self.yaxis = Canvas(f, width = AXWIDTH, height = height, bg = self.bgcolor)
self.yaxis.pack(side = LEFT, anchor = N, pady = self.border)
f1 = Frame(f)
f1.pack(side=LEFT)
self.canvas = Canvas(f1, background = self.plotbg, width = width, height = height)
self.canvas.pack(side = TOP)
self.canvas.bind("", self.show_xy)
self.xaxis = Canvas(f1, width = width, height = AXWIDTH, bg = self.bgcolor)
self.xaxis.pack(side = LEFT, anchor = N, padx = self.border)
self.canvas.create_rectangle ([(1,1),(width,height)], outline = self.bordcol)
self.canvas.pack()
Canvas(f, width = AXWIDTH, height = height, bg = self.bgcolor).pack(side=LEFT) # spacer only
self.setWorld(0 , 0, self.SCX, self.SCY) # initialize scale factors
self.grid(10,100)
def setWorld(self, x1, y1, x2, y2): #Calculates the scale factors
self.xmin = float(x1)
self.ymin = float(y1)
self.xmax = float(x2)
self.ymax = float(y2)
self.xscale = (self.xmax - self.xmin) / (self.SCX)
self.yscale = (self.ymax - self.ymin) / (self.SCY)
def w2s(self, p): # World to Screen xy conversion before plotting anything
ip = []
for xy in p:
ix = self.border + int( (xy[0] - self.xmin) / self.xscale)
iy = self.border + int( (xy[1] - self.ymin) / self.yscale)
iy = self.SCY - iy
ip.append((ix,iy))
return ip
def show_xy(self,event): #Prints the XY coordinates of the current cursor position
ix = self.canvas.canvasx(event.x) - self.border
iy = self.SCY - self.canvas.canvasy(event.y) #- self.border
x = ix * self.xscale + self.xmin
y = iy * self.yscale + self.ymin
s = 'x = %5.3f\ny = %5.3f' % (x,y)
try:
self.canvas.delete(self.markertext)
except:
pass
self.markertext = self.canvas.create_text(self.border + 1,\
self.SCY-1, anchor = SW, justify = LEFT, text = s)
self.markerval = [x,y]
def mark_axes(self, xlab='milli seconds', ylab='mV', numchans=1):
# Draw the axis labels and values
numchans = 1
for t in self.xtext: # display after dividing by scale factors
self.xaxis.delete(t)
for t in self.ytext:
self.yaxis.delete(t)
self.xtext = []
self.ytext = []
dx = float(self.SCX)/5
for x in range(0,6):
a = numchans * x *(self.xmax - self.xmin)/5 + self.xmin
s = '%4.1f'%(a)
adjust = 0
if x == 0: adjust = 6
if x == 5: adjust = -10
t = self.xaxis.create_text(int(x*dx)+adjust,1,text = s, anchor=N, fill = self.textcolor)
self.xtext.append(t)
self.xtext.append(self.xaxis.create_text(int(self.SCX/2)\
,AXWIDTH, text = xlab, anchor=S, fill = self.textcolor))
dy = float(self.SCY)/5
for y in range(0,6):
a = y*(self.ymax - self.ymin)/5 # + self.ymin
if self.ymax > 99:
s = '%4.0f'%(self.ymax-a)
else:
s = '%4.1f'%(self.ymax-a)
adjust = 0
if y == 0: adjust = 6
if y == 5: adjust = -5
t = self.yaxis.create_text(AXWIDTH, int(y*dy)+adjust, \
text = s,anchor = E, fill = self.textcolor)
self.ytext.append(t)
self.ytext.append(self.yaxis.create_text(0,self.SCY/2,\
text = ylab, anchor=W, fill = self.textcolor))
def box(self, x1, y1, x2, y2, col):
ip = self.w2s([(x1,y1),(x2,y2)])
self.canvas.create_rectangle(ip, outline=col)
def line(self, points, col, permanent = False, smooth = True):
ip = self.w2s(points)
t = self.canvas.create_line(ip, fill=col, smooth = smooth)
if permanent == False:
self.traces.append(t)
def delete_lines(self):
for t in self.traces:
self.canvas.delete(t)
self.traces = []
def grid(self, major, minor):
dx = (self.xmax - self.xmin) / major
dy = (self.ymax - self.ymin) / major
x = self.xmin + dx
while x < self.xmax:
self.line([(x,self.ymin),(x,self.ymax)],self.gridcol, True)
x = x +dx
y = self.ymin + dy
while y < self.ymax:
self.line([(self.xmin,y),(self.xmax,y)],self.gridcol, True)
y = y +dy
#------------------------------- disp class end --------------------------------------
root = Tk()
for k in range(3):
w = disp(root, width=400, height=100)
w.setWorld(0, 0, 100, 100)
w.mark_axes('X','Y')
root.mainloop()
pycode-browser-1.02/Code/PythonBook/chap2/except.py 0000775 0000000 0000000 00000000144 12544046010 0022203 0 ustar 00root root 0000000 0000000 x = input('Enter a number ')
try:
print 10.0/x
except:
print 'Division by zero not allowed'
pycode-browser-1.02/Code/PythonBook/chap2/except2.py 0000775 0000000 0000000 00000000327 12544046010 0022270 0 ustar 00root root 0000000 0000000 import string
def get_number():
while 1:
try:
a = raw_input('Enter a number ')
x = string.atof(a)
return x
except:
print 'Enter a valid number'
print get_number()
pycode-browser-1.02/Code/PythonBook/chap2/factor.py 0000775 0000000 0000000 00000000244 12544046010 0022172 0 ustar 00root root 0000000 0000000 #Example factor.py
def factorial(n): # a recursive function
if n == 0:
return 1
else:
return n * factorial(n-1)
print factorial(10)
pycode-browser-1.02/Code/PythonBook/chap2/fibanocci.py 0000775 0000000 0000000 00000000200 12544046010 0022621 0 ustar 00root root 0000000 0000000 def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b
fib(30) pycode-browser-1.02/Code/PythonBook/chap2/first.py 0000775 0000000 0000000 00000000544 12544046010 0022046 0 ustar 00root root 0000000 0000000
#Example: first.py
'''
This is Python program starting with a multi-line
comment, enclosed within triple quotes.
In a single line, anything after a # sign is a comment
'''
x = 10
print x, type(x) #print x and its type
y = 10.4
print y, type(y)
z = 3 + 4j
print z, type(z)
s1 = 'I am a String '
s2 = 'me too'
print s1, s2, type(s1)
pycode-browser-1.02/Code/PythonBook/chap2/forloop.py 0000775 0000000 0000000 00000000174 12544046010 0022376 0 ustar 00root root 0000000 0000000 #Example: forloop.py
a = 'my name'
for ch in a:
print ch
b = ['hello', 3.4, 2345, 3+5j]
for item in b:
print item
pycode-browser-1.02/Code/PythonBook/chap2/forloop2.py 0000775 0000000 0000000 00000000132 12544046010 0022452 0 ustar 00root root 0000000 0000000 #Example: forloop2.py
mylist = range(5)
print mylist
for item in mylist:
print item
pycode-browser-1.02/Code/PythonBook/chap2/forloop3.py 0000775 0000000 0000000 00000000123 12544046010 0022453 0 ustar 00root root 0000000 0000000 #Example: forloop3.py
mylist = range(5,51,5)
for item in mylist:
print item ,
pycode-browser-1.02/Code/PythonBook/chap2/forloop4.py 0000775 0000000 0000000 00000000135 12544046010 0022457 0 ustar 00root root 0000000 0000000 a = [2, 5, 3, 4, 12]
size = len(a)
for k in range(size):
if a[k] < 0:
a[k] = 0
print a
pycode-browser-1.02/Code/PythonBook/chap2/format.py 0000775 0000000 0000000 00000000130 12544046010 0022176 0 ustar 00root root 0000000 0000000 #Example: format.py
a = 2.0 /3
print a
print 'a = %5.3f' %(a) # upto 3 decimal places
pycode-browser-1.02/Code/PythonBook/chap2/format2.py 0000775 0000000 0000000 00000000314 12544046010 0022264 0 ustar 00root root 0000000 0000000 #Example: format2.py
a = 'justify as you like'
print '%30s'%a
print '%-30s'%a # minus sign for left justification
for k in range(1,11): # A good looking table
print '5 x %2d = %2d' %(k, k*5) pycode-browser-1.02/Code/PythonBook/chap2/func.py 0000775 0000000 0000000 00000000132 12544046010 0021643 0 ustar 00root root 0000000 0000000 #Example func.py
def sum(a,b): # a trivial function
return a + b
print sum(3, 4)
pycode-browser-1.02/Code/PythonBook/chap2/global.py 0000775 0000000 0000000 00000000164 12544046010 0022155 0 ustar 00root root 0000000 0000000 def change(x):
global counter # use the global variable
counter = x
counter = 10
change(5)
print counter pycode-browser-1.02/Code/PythonBook/chap2/hello.py 0000775 0000000 0000000 00000000024 12544046010 0022013 0 ustar 00root root 0000000 0000000 print 'Hello World'
pycode-browser-1.02/Code/PythonBook/chap2/kin1.py 0000775 0000000 0000000 00000000220 12544046010 0021550 0 ustar 00root root 0000000 0000000 x = input('Enter an integer ')
y = input('Enter one more ')
print 'The sum is ', x + y
s = raw_input('Enter a String ')
print 'You entered ', s
pycode-browser-1.02/Code/PythonBook/chap2/kin2.py 0000775 0000000 0000000 00000000320 12544046010 0021552 0 ustar 00root root 0000000 0000000 x,y = input('Enter x and y separated by comma ')
print 'The sum is ', x + y
s = raw_input('Enter a decimal number ')
a = float(s)
print s * 2 # prints string twice
print a * 2 # converted value times 2
pycode-browser-1.02/Code/PythonBook/chap2/list1.py 0000775 0000000 0000000 00000000135 12544046010 0021747 0 ustar 00root root 0000000 0000000 a = [3, 3.5, 234] # make a list
print a[0]
a[1] = 'haha' # Change an element
print a
pycode-browser-1.02/Code/PythonBook/chap2/list2.py 0000775 0000000 0000000 00000000076 12544046010 0021754 0 ustar 00root root 0000000 0000000 a = [1,2]
print a * 2
print a + [3,4]
b = [10, 20, a]
print b
pycode-browser-1.02/Code/PythonBook/chap2/list3.py 0000775 0000000 0000000 00000000216 12544046010 0021751 0 ustar 00root root 0000000 0000000 a = [] # make an empty list
a.append(3) # Add an element
a.insert(0,2.3) # insert 2.3 as first element
print a, a[0]
print len(a) pycode-browser-1.02/Code/PythonBook/chap2/list_copy.py 0000775 0000000 0000000 00000000174 12544046010 0022723 0 ustar 00root root 0000000 0000000 a = [1,2,3,4]
print a
b = a
print a == b
b[0] = 5
print a
import copy
c = copy.copy(a)
c[1] = 100
print a is c
print a, c
pycode-browser-1.02/Code/PythonBook/chap2/mathlocal.py 0000775 0000000 0000000 00000000132 12544046010 0022654 0 ustar 00root root 0000000 0000000 #Example mathlocal.py
from math import sin # sin is imported as local
print sin(0.5)
pycode-browser-1.02/Code/PythonBook/chap2/mathlocal2.py 0000775 0000000 0000000 00000000133 12544046010 0022737 0 ustar 00root root 0000000 0000000 #Example mathlocal2.py
from math import * # import everything from math
print sin(0.5)
pycode-browser-1.02/Code/PythonBook/chap2/mathsin.py 0000775 0000000 0000000 00000000116 12544046010 0022355 0 ustar 00root root 0000000 0000000 #Example math.py
import math
print math.sin(0.5) # module_name.method_name
pycode-browser-1.02/Code/PythonBook/chap2/mathsin2.py 0000775 0000000 0000000 00000000154 12544046010 0022441 0 ustar 00root root 0000000 0000000 #Example math2.py
import math as m # Give another madule name
print m.sin(0.5) # Refer by the new name
pycode-browser-1.02/Code/PythonBook/chap2/max.py 0000775 0000000 0000000 00000000242 12544046010 0021477 0 ustar 00root root 0000000 0000000 #Example: max.py
max = 0
while 1: # Infinite loop
x = input('Enter a number ')
if x > max:
max = x
if x == 0:
print max
break
pycode-browser-1.02/Code/PythonBook/chap2/mutable.py 0000775 0000000 0000000 00000000233 12544046010 0022343 0 ustar 00root root 0000000 0000000 s = [3, 3.5, 234] # make a list
s[2] = 'haha' # Change an element
print s
x = 'myname' # String type
#x[1] = 2 # Will give ERROR
pycode-browser-1.02/Code/PythonBook/chap2/named.py 0000775 0000000 0000000 00000000213 12544046010 0021774 0 ustar 00root root 0000000 0000000 def power(mant = 10.0, exp = 2.0):
return mant ** exp
print power(5., 3)
print power(4.) # prints 16
print power(exp=3) pycode-browser-1.02/Code/PythonBook/chap2/oper.py 0000775 0000000 0000000 00000000140 12544046010 0021654 0 ustar 00root root 0000000 0000000 x = 2
y = 4
print x + y * 2
s = 'Hello '
print s + s
print 3 * s
print x == y
print y == 2 * x
pycode-browser-1.02/Code/PythonBook/chap2/pickledump.py 0000775 0000000 0000000 00000000161 12544046010 0023047 0 ustar 00root root 0000000 0000000 #Example pickle.py
import pickle
f = open('test.pck' , 'w')
pickle.dump(12.3, f) # write a float type
f.close()
pycode-browser-1.02/Code/PythonBook/chap2/pickleload.py 0000775 0000000 0000000 00000000222 12544046010 0023017 0 ustar 00root root 0000000 0000000 #Example pickle2.py
import pickle
f = open('test.pck' , 'r')
x = pickle.load(f)
print x , type(x) # check the type of data read
f.close()
pycode-browser-1.02/Code/PythonBook/chap2/point.py 0000775 0000000 0000000 00000001044 12544046010 0022044 0 ustar 00root root 0000000 0000000 class Point:
xpos = 0
ypos = 0
def __init__(self, x=0, y=0):
self.xpos = x
self.ypos = y
def __str__(self):
return 'Point at (%f,%f)'%(self.xpos, self.ypos)
def __add__(self, other):
xpos = self.xpos + other.xpos
ypos = self.ypos + other.ypos
res = Point(xpos,ypos)
return res
def __sub__(self, other):
import math
dx = self.xpos - other.xpos
dy = self.ypos - other.ypos
return math.sqrt(dx**2+dy**2)
def dist(self):
import math
return math.sqrt(self.xpos**2 + self.ypos**2)
pycode-browser-1.02/Code/PythonBook/chap2/point1.py 0000775 0000000 0000000 00000000222 12544046010 0022122 0 ustar 00root root 0000000 0000000 from point import *
origin = Point()
print origin
p1 = Point(4,4)
p2 = Point(8,7)
print p1
print p2
print p1 + p2
print p1 - p2
print p1.dist()
pycode-browser-1.02/Code/PythonBook/chap2/point2.py 0000775 0000000 0000000 00000000165 12544046010 0022131 0 ustar 00root root 0000000 0000000 from cpoint import *
p1 = Point(5,5)
rp1 = colPoint(2,2,'red')
print p1
print rp1
print rp1 + p1
print rp1.dist()
pycode-browser-1.02/Code/PythonBook/chap2/power.py 0000775 0000000 0000000 00000000133 12544046010 0022045 0 ustar 00root root 0000000 0000000 def power(mant, exp = 2.0):
return mant ** exp
print power(5., 3)
print power(4.)
pycode-browser-1.02/Code/PythonBook/chap2/reverse.py 0000775 0000000 0000000 00000000103 12544046010 0022361 0 ustar 00root root 0000000 0000000 a = 'abcd'
b = ''
for k in range(len(a)):
b = b + a[-1-k]
print b
pycode-browser-1.02/Code/PythonBook/chap2/rfile.py 0000775 0000000 0000000 00000000107 12544046010 0022013 0 ustar 00root root 0000000 0000000 #Example rfile.py
f = open('test.dat' , 'r')
print f.read()
f.close()
pycode-browser-1.02/Code/PythonBook/chap2/rfile2.py 0000775 0000000 0000000 00000000231 12544046010 0022073 0 ustar 00root root 0000000 0000000 #Example rfile2.py
f = open('test.dat' , 'r')
print f.read(7) # get first seven characters
print f.read() # get the remaining ones
f.close()
pycode-browser-1.02/Code/PythonBook/chap2/rfile3.py 0000775 0000000 0000000 00000000404 12544046010 0022076 0 ustar 00root root 0000000 0000000 #Example rfile3.py
f = open('data.dat' , 'r')
while 1: # infinite loop
s = f.readline()
if s == '' : # Empty string means end of file
break # terminate the loop
m = int(s) # Convert to integer
print m * 5
f.close()
pycode-browser-1.02/Code/PythonBook/chap2/scope.py 0000775 0000000 0000000 00000000110 12544046010 0022015 0 ustar 00root root 0000000 0000000 def change(x):
counter = x
counter = 10
change(5)
print counter pycode-browser-1.02/Code/PythonBook/chap2/slice.py 0000775 0000000 0000000 00000000067 12544046010 0022016 0 ustar 00root root 0000000 0000000 a = 'hello world'
print a[3:5]
print a[6:]
print a[:5]
pycode-browser-1.02/Code/PythonBook/chap2/split.py 0000775 0000000 0000000 00000000160 12544046010 0022044 0 ustar 00root root 0000000 0000000 s = 'I am a long string'
print s.split()
a = 'abc.abc.abc'
aa = a.split('.')
print aa
mm = '+'.join(aa)
print mm pycode-browser-1.02/Code/PythonBook/chap2/string.py 0000775 0000000 0000000 00000000231 12544046010 0022216 0 ustar 00root root 0000000 0000000 s = 'hello world'
print s[0] # print first element, h
print s[1] # print e
print s[-1] # will print the last character pycode-browser-1.02/Code/PythonBook/chap2/string.pyc 0000775 0000000 0000000 00000000330 12544046010 0022361 0 ustar 00root root 0000000 0000000
Z-Lc @ s% d Z e d GHe d GHe d GHd S( s hello worldi i iN( t s( ( ( s5 /home/phoenix/Desktop/PythonBook/code/chap2/string.pyt s pycode-browser-1.02/Code/PythonBook/chap2/string2.py 0000775 0000000 0000000 00000000103 12544046010 0022276 0 ustar 00root root 0000000 0000000 a = 'hello'+'world'
print a
b = 'ha' * 3
print b
print a[-1] + b[0] pycode-browser-1.02/Code/PythonBook/chap2/stringhelp.py 0000775 0000000 0000000 00000000130 12544046010 0023065 0 ustar 00root root 0000000 0000000 s = 'hello world'
print len(s)
print s.upper()
help(str) # press q to quit help pycode-browser-1.02/Code/PythonBook/chap2/submodule.py 0000775 0000000 0000000 00000000134 12544046010 0022711 0 ustar 00root root 0000000 0000000 from numpy import *
print random.normal()
import scipy.special
print scipy.special.j0(.1)
pycode-browser-1.02/Code/PythonBook/chap2/table.py 0000775 0000000 0000000 00000000107 12544046010 0022001 0 ustar 00root root 0000000 0000000 #Example: table.py
x = 1
while x <= 10:
print x * 8
x = x + 1
pycode-browser-1.02/Code/PythonBook/chap2/tkbutton.py 0000775 0000000 0000000 00000000306 12544046010 0022565 0 ustar 00root root 0000000 0000000 from Tkinter import *
def hello():
print 'hello world'
w = Tk() # Creates the main Graphics window
b = Button(w, text = 'Click Me', command = hello)
b.pack()
w.mainloop() pycode-browser-1.02/Code/PythonBook/chap2/tkcanvas.py 0000775 0000000 0000000 00000000313 12544046010 0022523 0 ustar 00root root 0000000 0000000 from Tkinter import *
def draw(event):
c.create_rectangle(event.x, event.y, event.x+5, event.y+5)
w = Tk()
c = Canvas(w, width = 300, height = 200)
c.pack()
c.bind("", draw)
w.mainloop()
pycode-browser-1.02/Code/PythonBook/chap2/tkcanvas2.py 0000775 0000000 0000000 00000000717 12544046010 0022615 0 ustar 00root root 0000000 0000000 from Tkinter import *
recs = [] # List keeping track of the rectangles
def remove(event):
global recs
if len(recs) > 0:
c.delete(recs[0]) # delete from Canvas
recs.pop(0) # delete first item from list
def draw(event):
r = c.create_rectangle(event.x, event.y, event.x+5, event.y+5)
recs.append(r)
w = Tk()
c = Canvas(w, width = 300, height = 200)
c.pack()
c.bind("", draw)
c.bind("", remove)
w.mainloop()
pycode-browser-1.02/Code/PythonBook/chap2/tklabel.py 0000775 0000000 0000000 00000000141 12544046010 0022326 0 ustar 00root root 0000000 0000000 from Tkinter import *
root = Tk()
w = Label(root, text="Hello, world")
w.pack()
root.mainloop() pycode-browser-1.02/Code/PythonBook/chap2/tkmain.py 0000775 0000000 0000000 00000000062 12544046010 0022175 0 ustar 00root root 0000000 0000000 from Tkinter import *
root = Tk()
root.mainloop() pycode-browser-1.02/Code/PythonBook/chap2/tkplot.py 0000775 0000000 0000000 00000000420 12544046010 0022225 0 ustar 00root root 0000000 0000000 from tkplot_class import *
from math import *
w = Tk()
gw1 = disp(w)
xy = []
for k in range(200):
x = 2 * pi * k/200
y = sin(x)
xy.append((x,y))
gw1.setWorld(0, -1.0, 2*pi, 1.0)
gw1.line(xy)
gw2 = disp(w)
gw2.line([(10,10),(100,100),(350,50)], 'red')
w.mainloop()
pycode-browser-1.02/Code/PythonBook/chap2/tkplot_class.py 0000775 0000000 0000000 00000002547 12544046010 0023426 0 ustar 00root root 0000000 0000000 from Tkinter import *
from math import *
class disp:
"""
Class for displaying items in a canvas using a world coordinate system. The range of the
world coordinate system is specified by calling the setWorld method.
"""
traces = []
def __init__(self, parent, width=400., height=200.):
self.parent = parent
self.SCX = width
self.SCY = height
self.border = 1
self.canvas = Canvas(parent, width=width, height=height)
self.canvas.pack(side = LEFT)
self.setWorld(0 , 0, self.SCX, self.SCY) # initialize scale factors
def setWorld(self, x1, y1, x2, y2): #Calculates the scale factors
self.xmin = float(x1)
self.ymin = float(y1)
self.xmax = float(x2)
self.ymax = float(y2)
self.xscale = (self.xmax - self.xmin) / (self.SCX)
self.yscale = (self.ymax - self.ymin) / (self.SCY)
def w2s(self, p): # World to Screen xy conversion before plotting anything
ip = []
for xy in p:
ix = self.border + int( (xy[0] - self.xmin) / self.xscale)
iy = self.border + int( (xy[1] - self.ymin) / self.yscale)
iy = self.SCY - iy
ip.append((ix,iy))
return ip
def line(self, points, col='blue'):
ip = self.w2s(points)
t = self.canvas.create_line(ip, fill=col)
self.traces.append(t)
def delete_lines(self):
for t in self.traces:
self.canvas.delete(t)
self.traces = []
pycode-browser-1.02/Code/PythonBook/chap2/turtle1.py 0000775 0000000 0000000 00000000357 12544046010 0022321 0 ustar 00root root 0000000 0000000 from turtle import *
a = Pen() # Creates a graphics window
a.forward(50)
a.left(45)
a.backward(50)
a.right(45)
a.forward(50)
a.circle(10)
a.up()
a.forward(50)
a.down()
a.color('red')
a.right(90)
a.forward(50)
raw_input('Press Enter')
pycode-browser-1.02/Code/PythonBook/chap2/turtle2.py 0000775 0000000 0000000 00000000207 12544046010 0022314 0 ustar 00root root 0000000 0000000 from turtle import *
a = Pen() # Creates a graphics window
for k in range(4):
a.forward(50)
a.left(90)
a.circle(25)
raw_input() pycode-browser-1.02/Code/PythonBook/chap2/turtle3.py 0000775 0000000 0000000 00000000326 12544046010 0022317 0 ustar 00root root 0000000 0000000 from turtle import *
def draw_rectangle():
for k in range(4):
a.forward(50)
a.left(90)
a = Pen() # Creates a graphics window
for k in range(36):
draw_rectangle()
a.left(10)
raw_input() pycode-browser-1.02/Code/PythonBook/chap2/turtle4.py 0000775 0000000 0000000 00000000427 12544046010 0022322 0 ustar 00root root 0000000 0000000 from turtle import *
def f(length, depth):
if depth == 0:
forward(length)
else:
f(length/3, depth-1)
right(60)
f(length/3, depth-1)
left(120)
f(length/3, depth-1)
right(60)
f(length/3, depth-1)
f(500, 4)
raw_input('Press any Key')
pycode-browser-1.02/Code/PythonBook/chap2/wfile.py 0000775 0000000 0000000 00000000130 12544046010 0022014 0 ustar 00root root 0000000 0000000 #Example wfile.py
f = open('test.dat' , 'w')
f.write ('This is a test file')
f.close()
pycode-browser-1.02/Code/PythonBook/chap2/wfile2.py 0000775 0000000 0000000 00000000167 12544046010 0022110 0 ustar 00root root 0000000 0000000 #Example wfile2.py
f = open('data.dat' , 'w')
for k in range(1,4):
s = '%3d\n' %(k)
f.write(s)
f.close()
pycode-browser-1.02/Code/PythonBook/chap3/ 0000775 0000000 0000000 00000000000 12544046010 0020340 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/PythonBook/chap3/aroper.py 0000775 0000000 0000000 00000000162 12544046010 0022204 0 ustar 00root root 0000000 0000000 #Example oper.py
from numpy import *
a = array([[2,3], [4,5]])
b = array([[1,2], [3,0]])
print a + b
print a * b
pycode-browser-1.02/Code/PythonBook/chap3/array_copy.py 0000775 0000000 0000000 00000000145 12544046010 0023065 0 ustar 00root root 0000000 0000000 from numpy import *
a = zeros(3)
print a
b = a
c = a.copy()
c[0] = 10
print a, c
b[0] = 10
print a,c
pycode-browser-1.02/Code/PythonBook/chap3/cross.py 0000775 0000000 0000000 00000000144 12544046010 0022045 0 ustar 00root root 0000000 0000000 #Example cross.py
from numpy import *
a = array([1,2,3])
b = array([4,5,6])
c = cross(a,b)
print c
pycode-browser-1.02/Code/PythonBook/chap3/fileio.py 0000775 0000000 0000000 00000000206 12544046010 0022162 0 ustar 00root root 0000000 0000000 #Example fileio.py
from numpy import *
a = arange(10)
print a
a.tofile('myfile.dat')
b = fromfile('myfile.dat', dtype='int')
print b
pycode-browser-1.02/Code/PythonBook/chap3/inv.py 0000775 0000000 0000000 00000000223 12544046010 0021506 0 ustar 00root root 0000000 0000000 #Example inv.py
from numpy import *
a = array([ [4,1,-2], [2,-3,3], [-6,-2,1] ], dtype='float')
ainv = linalg.inv(a)
print ainv
print dot(a,ainv)
pycode-browser-1.02/Code/PythonBook/chap3/numpy1.py 0000775 0000000 0000000 00000000146 12544046010 0022147 0 ustar 00root root 0000000 0000000 #Example numpy1.py
from numpy import *
x = array( [1,2] ) # Make array from list
print x , type(x)
pycode-browser-1.02/Code/PythonBook/chap3/numpy2.py 0000775 0000000 0000000 00000000313 12544046010 0022144 0 ustar 00root root 0000000 0000000 #Example numpy2.py
from numpy import *
a = arange(1.0, 2.0, 0.1) # start, stop & step
print a
b = linspace(1,2,11)
print b
c = ones(5)
print c
d = zeros(5)
print d
e = random.rand(5)
print e
pycode-browser-1.02/Code/PythonBook/chap3/numpy3.py 0000775 0000000 0000000 00000000207 12544046010 0022147 0 ustar 00root root 0000000 0000000 #Example numpy3.py
from numpy import *
a = [ [1,2] , [3,4] ] # make a list of lists
x = array(a) # and convert to an array
print a
pycode-browser-1.02/Code/PythonBook/chap3/numpy4.py 0000775 0000000 0000000 00000000161 12544046010 0022147 0 ustar 00root root 0000000 0000000 #Example numpy4.py
from numpy import *
a = arange(10)
print a
a = a.reshape(5,2) # 5 rows and 2 columns
print a
pycode-browser-1.02/Code/PythonBook/chap3/reshape.py 0000775 0000000 0000000 00000000126 12544046010 0022343 0 ustar 00root root 0000000 0000000 #Example reshape.py
from numpy import *
a = arange(20)
b = reshape(a, [4,5])
print b
pycode-browser-1.02/Code/PythonBook/chap3/sine.py 0000775 0000000 0000000 00000000146 12544046010 0021654 0 ustar 00root root 0000000 0000000 #Example sine.py
import math
x = 0.0
while x < math.pi * 4:
print x , math.sin(x)
x = x + 0.1 pycode-browser-1.02/Code/PythonBook/chap3/vectorize.py 0000775 0000000 0000000 00000000153 12544046010 0022726 0 ustar 00root root 0000000 0000000 from numpy import *
def spf(x):
return 3*x
vspf = vectorize(spf)
a = array([1,2,3,4])
print vspf(a)
pycode-browser-1.02/Code/PythonBook/chap3/vfunc.py 0000775 0000000 0000000 00000000076 12544046010 0022041 0 ustar 00root root 0000000 0000000 from numpy import *
a = array([1,10,100,1000])
print log10(a)
pycode-browser-1.02/Code/PythonBook/chap4/ 0000775 0000000 0000000 00000000000 12544046010 0020341 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/PythonBook/chap4/archi.py 0000775 0000000 0000000 00000000173 12544046010 0022005 0 ustar 00root root 0000000 0000000 #Example archi.py
from pylab import *
a = 2
th= linspace(0, 10*pi,200)
r = a*th
polar(th,r)
axis([0, 2*pi, 0, 70])
show()
pycode-browser-1.02/Code/PythonBook/chap4/arcs.py 0000775 0000000 0000000 00000000251 12544046010 0021644 0 ustar 00root root 0000000 0000000 #Example arcs.py
from pylab import *
a = 10.0
for a in range(5,21,5):
th = linspace(0, pi * a/10, 200)
x = a * cos(th)
y = a * sin(th)
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/astro.py 0000775 0000000 0000000 00000000175 12544046010 0022051 0 ustar 00root root 0000000 0000000 #Example astro.py
from pylab import *
a = 2
x = linspace(0,a,100)
y = ( a**(2.0/3) - x**(2.0/3) )**(3.0/2)
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/astropar.py 0000775 0000000 0000000 00000000200 12544046010 0022541 0 ustar 00root root 0000000 0000000 #Example astropar.py
from pylab import *
a = 2
t = linspace(-2*a,2*a,101)
x = a * cos(t)**3
y = a * sin(t)**3
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/circ.py 0000775 0000000 0000000 00000000245 12544046010 0021637 0 ustar 00root root 0000000 0000000 #Example circ.py
from pylab import *
a = 10.0
x = linspace(-a, a , 200)
yupper = sqrt(a**2 - x**2)
ylower = -sqrt(a**2 - x**2)
plot(x,yupper)
plot(x,ylower)
show()
pycode-browser-1.02/Code/PythonBook/chap4/circpar.py 0000775 0000000 0000000 00000000177 12544046010 0022346 0 ustar 00root root 0000000 0000000 #Example circpar.py
from pylab import *
a = 10.0
th = linspace(0, 2*pi, 200)
x = a * cos(th)
y = a * sin(th)
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/ellipse.py 0000775 0000000 0000000 00000000210 12544046010 0022344 0 ustar 00root root 0000000 0000000 #Example ellipse.py
from pylab import *
a = 2
b = 3
t = linspace(0, 2 * pi, 100)
x = a * sin(t)
y = b * cos(t)
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/fermat.py 0000775 0000000 0000000 00000000176 12544046010 0022200 0 ustar 00root root 0000000 0000000 #Example fermat.py
from pylab import *
a = 2
th= linspace(0, 10*pi,200)
r = sqrt(a**2 * th)
polar(th,r)
polar(th, -r)
show()
pycode-browser-1.02/Code/PythonBook/chap4/fourier_sawtooth.py 0000775 0000000 0000000 00000000327 12544046010 0024323 0 ustar 00root root 0000000 0000000 #Example fourier_sawtooth.py
from pylab import *
N = 100 # number of points
x = linspace(-pi, pi, N)
y = zeros(N)
for n in range(1,10):
term = (-1)**(n+1) * sin(n*x) / n
y = y + term
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/fourier_square.py 0000775 0000000 0000000 00000000327 12544046010 0023753 0 ustar 00root root 0000000 0000000 #Example fourier_square.py
from pylab import *
N = 100 # number of points
x = linspace(0.0, 2 * pi, N)
y = zeros(N)
for n in range(5):
term = sin((2*n+1)*x) / (2*n+1)
y = y + term
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/imshow1.py 0000775 0000000 0000000 00000000072 12544046010 0022304 0 ustar 00root root 0000000 0000000 from pylab import *
m = random([50,50])
imshow(m)
show()
pycode-browser-1.02/Code/PythonBook/chap4/julia.py 0000775 0000000 0000000 00000002106 12544046010 0022021 0 ustar 00root root 0000000 0000000 '''
Region of a complex plane ranging from -1 to +1 in both real
and imaginary axes is rpresented using a 2 dimensional matrix
having X x Y elements.For X and Y equal to 200, the stepsize
in the complex plane is 2.0/200 = 0.01.
The nature of the pattern depends very much on the value of c.
'''
from pylab import *
X = 200
Y = 200
rlim = 1.0
ilim = 1.0
rscale = 2*rlim / X
iscale = 2*ilim / Y
MAXIT = 100
MAXABS = 2.0
c = 0.02 - 0.8j # The constant in equation z**2 + c
m = zeros([X,Y],dtype=uint8) # A two dimensional array
def numit(x,y): # number of iterations to diverge
z = complex(x,y)
for k in range(MAXIT):
if abs(z) <= MAXABS:
z = z**2 + c
else:
return k # diverged after k trials
return MAXIT # did not diverge,
for x in range(X):
for y in range(Y):
re = rscale * x - rlim # complex number represented
im = iscale * y - ilim # by the (x,y) coordinate
m[x][y] = numit(re,im) # get the color for (x,y)
imshow(m) # Colored plot using the two dimensional matrix
show()
pycode-browser-1.02/Code/PythonBook/chap4/line3d.py 0000775 0000000 0000000 00000000505 12544046010 0022074 0 ustar 00root root 0000000 0000000 from pylab import *
from mpl_toolkits.mplot3d import Axes3D
ax = Axes3D(figure())
phi = linspace(0, 2*pi, 400)
x = cos(phi)
y = sin(phi)
z = 0
ax.plot(x, y, z, label = 'x') # circle
z = sin(4*phi) # modulated in z plane
ax.plot(x, y, z, label = 'x')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
show()
pycode-browser-1.02/Code/PythonBook/chap4/lissa.py 0000775 0000000 0000000 00000000261 12544046010 0022030 0 ustar 00root root 0000000 0000000 #Example lissa.py
from pylab import *
a = 2
b = 3
t= linspace(0, 2*pi,100)
x = a * sin(2*t)
y = b * cos(t)
plot(x,y)
x = a * sin(3*t)
y = b * cos(2*t)
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/mgrid1.py 0000775 0000000 0000000 00000000146 12544046010 0022102 0 ustar 00root root 0000000 0000000 from numpy import *
x = arange(0, 3, 1)
y = arange(0, 3, 1)
gx, gy = meshgrid(x, y)
print gx
print gy
pycode-browser-1.02/Code/PythonBook/chap4/mgrid2.py 0000775 0000000 0000000 00000000223 12544046010 0022077 0 ustar 00root root 0000000 0000000
from pylab import *
x = arange(-3*pi, 3*pi, 0.1)
y = arange(-3*pi, 3*pi, 0.1)
xx, yy = meshgrid(x, y)
z = sin(xx) + sin(yy)
imshow(z)
show()
pycode-browser-1.02/Code/PythonBook/chap4/npsin.py 0000775 0000000 0000000 00000000200 12544046010 0022035 0 ustar 00root root 0000000 0000000 #Example npsin.py
from pylab import *
x = linspace(-pi, pi , 200)
y = sin(x)
y1 = sin(x*x)
plot(x,y)
plot(x,y1,'r')
show()
pycode-browser-1.02/Code/PythonBook/chap4/piechart.py 0000775 0000000 0000000 00000000171 12544046010 0022514 0 ustar 00root root 0000000 0000000 from pylab import *
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
fracs = [25, 25, 30, 20]
pie(fracs, labels=labels)
show()
pycode-browser-1.02/Code/PythonBook/chap4/plot1.py 0000775 0000000 0000000 00000000110 12544046010 0021745 0 ustar 00root root 0000000 0000000 #Example plot1.py
from pylab import *
data = [1,2,5]
plot(data)
show()
pycode-browser-1.02/Code/PythonBook/chap4/plot2.py 0000775 0000000 0000000 00000000120 12544046010 0021747 0 ustar 00root root 0000000 0000000 #Example plot2.py
from pylab import *
x = [1,2,5]
y = [4,5,6]
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/plot3.py 0000775 0000000 0000000 00000000207 12544046010 0021756 0 ustar 00root root 0000000 0000000 #Example plot3.py
from pylab import *
x = [1,2,5]
y = [4,5,6]
plot(x,y,'ro')
xlabel('x-axis')
ylabel('y-axis')
axis([0,6,1,7])
show()
pycode-browser-1.02/Code/PythonBook/chap4/plot4.py 0000775 0000000 0000000 00000000206 12544046010 0021756 0 ustar 00root root 0000000 0000000 #Example plot4.py
from pylab import *
t = arange(0.0, 5.0, 0.2)
plot(t, t**2,'x') # t^{2}
plot(t, t**3,'ro') # t^{3}
show()
pycode-browser-1.02/Code/PythonBook/chap4/polar.py 0000775 0000000 0000000 00000000164 12544046010 0022034 0 ustar 00root root 0000000 0000000 #Example polar.py
from pylab import *
th = linspace(0,2*pi,100)
r = 5 * ones(100) # radius = 5
polar(th,r)
show()
pycode-browser-1.02/Code/PythonBook/chap4/rose.py 0000775 0000000 0000000 00000000132 12544046010 0021662 0 ustar 00root root 0000000 0000000 from pylab import *
k = 4
th = linspace(0, 12*pi,1000)
r = cos(k*th)
polar(th,r)
show()
pycode-browser-1.02/Code/PythonBook/chap4/series_sin.py 0000775 0000000 0000000 00000000463 12544046010 0023064 0 ustar 00root root 0000000 0000000 #Example series_sin.py
from pylab import *
from scipy import factorial
x = linspace(-pi, pi, 50)
y = zeros(50)
for n in range(5):
term = (-1)**(n) * (x**(2*n+1)) / factorial(2*n+1)
y = y + term
#plot(x,term)
plot(x, y, '+b')
plot(x, sin(x),'r') # compare with the real one
show()
pycode-browser-1.02/Code/PythonBook/chap4/subplot1.py 0000775 0000000 0000000 00000000277 12544046010 0022475 0 ustar 00root root 0000000 0000000 from pylab import *
subplot(211) # the first subplot
plot([1,2,3,4])
xlabel('first row')
subplot(212) # the second subplot
plot([4,2,3,1])
xlabel('second row')
show()
pycode-browser-1.02/Code/PythonBook/chap4/subplot2.py 0000775 0000000 0000000 00000000454 12544046010 0022473 0 ustar 00root root 0000000 0000000 from pylab import *
mark = ['x','o','^','+','>']
NR = 2 # number of rows
NC = 3 # number of columns
pn = 1
for row in range(NR):
for col in range(NC):
subplot(NR, NC, pn)
a = rand(10) * pn
plot(a, marker = mark[(pn+1)%5])
xlabel('plot %d X'%pn)
ylabel('plot %d Y'%pn)
pn = pn + 1
show()
pycode-browser-1.02/Code/PythonBook/chap4/surf3d.py 0000775 0000000 0000000 00000000220 12544046010 0022116 0 ustar 00root root 0000000 0000000 from numpy import *
from enthought.mayavi.mlab import *
x, y = mgrid[-10.:10.05:0.1, -10.:10.05:0.05]
z = sin(x) + sin(y)
surf(x, y, z)
show()
pycode-browser-1.02/Code/PythonBook/chap4/surface3d.py 0000775 0000000 0000000 00000000403 12544046010 0022572 0 ustar 00root root 0000000 0000000 from pylab import *
from mpl_toolkits.mplot3d import Axes3D
ax = Axes3D(figure())
x = arange(-3*pi, 3*pi, 0.1)
y = arange(-3*pi, 3*pi, 0.1)
xx, yy = meshgrid(x, y)
z = sin(xx) + sin(yy)
ax.plot_surface(xx, yy, z, cmap=cm.jet, cstride=1)
#imshow(z)
show()
pycode-browser-1.02/Code/PythonBook/chap4/wireframe.py 0000775 0000000 0000000 00000000477 12544046010 0022707 0 ustar 00root root 0000000 0000000 from pylab import *
from mpl_toolkits.mplot3d import Axes3D
ax = Axes3D(figure())
phi = linspace(0, 2 * pi, 100)
theta = linspace(0, pi, 100)
x = 10 * outer(cos(phi), sin(theta))
y = 10 * outer(sin(phi), sin(theta))
z = 10 * outer(ones(size(phi)), cos(theta))
ax.plot_wireframe(x,y,z, rstride=2, cstride=2)
show()
pycode-browser-1.02/Code/PythonBook/chap4/xyplot.py 0000775 0000000 0000000 00000000330 12544046010 0022251 0 ustar 00root root 0000000 0000000 from pylab import *
x = []
y = []
f = open('xy.dat', 'r')
while True:
s = f.readline()
if len(s) < 3:
break
ss = s.split()
print ss
x.append(ss[0])
y.append(ss[1])
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap4/ylm20.py 0000775 0000000 0000000 00000000460 12544046010 0021661 0 ustar 00root root 0000000 0000000 from numpy import *
from enthought.mayavi import mlab
polar = linspace(0,pi,100)
azimuth = linspace(0, 2*pi,100)
phi,th = meshgrid(polar, azimuth)
r = 0.25 * sqrt(5.0/pi) * (3 * cos(phi) ** 2 - 1) #Ylm(0,2)
x = r*sin(phi)*cos(th)
y = r*cos(phi)
z = r*sin(phi)*sin(th)
mlab.mesh(x, y, z)
mlab.show()
pycode-browser-1.02/Code/PythonBook/chap5/ 0000775 0000000 0000000 00000000000 12544046010 0020342 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/PythonBook/chap5/environs.tex 0000775 0000000 0000000 00000001046 12544046010 0022733 0 ustar 00root root 0000000 0000000 \documentclass{article}
\begin{document}
\begin{center}
A numbered List (heading centered).
\end{center}
\begin{enumerate}
\item dog
\item cat
\end{enumerate}
\begin{flushleft}
A bulleted list (heading justified left).
\end{flushleft}
\begin{itemize}
\item dog
\item cat
\end{itemize}
\begin{flushright}
this part of the text is centered.
\end{flushright}
\begin{quote}
Any text inside quote\\
environment will appe-\\
ar as typed.\\
\end{quote}
\begin{verbatim}
x = 1
while x <= 10:
print x * 5
x = x + 1
\end{verbatim}
\end{document}
pycode-browser-1.02/Code/PythonBook/chap5/hello.tex 0000775 0000000 0000000 00000000115 12544046010 0022167 0 ustar 00root root 0000000 0000000 \documentclass{article}
\begin{document}
Small is beautiful.
\end{document}
pycode-browser-1.02/Code/PythonBook/chap5/math1.tex 0000775 0000000 0000000 00000000615 12544046010 0022103 0 ustar 00root root 0000000 0000000 \documentclass{article}
\usepackage{amsmath}
\begin{document}
The equation $a^2 + b^2 = c^2$ is typeset as inline. The same can be done in a separate line using
\begin{equation}
a^2 + b^2 = c^2
\end{equation}
We can also make the equation with a label refer to equation \eqref{mass} to know about the mass energy relation.
\begin{equation}
E = mc^2 \label{mass}
\end{equation}
\end{document}
pycode-browser-1.02/Code/PythonBook/chap5/math_many.tex 0000775 0000000 0000000 00000001056 12544046010 0023046 0 ustar 00root root 0000000 0000000 \documentclass{article}
\usepackage{amsmath}
\begin{document}
$A\quad B\qquad C$\\
$ \alpha \beta \gamma \pi$\\
$A_n \quad A^m$\\
$a^b \quad a^{b^c}$\\
$\frac{3}{5}$\\
$n! = 1 \cdot 2 \cdots (n-1) \cdot n$\\
$0.\overline{3} = \underline{1/3}$\\
$\vec{a}$\\
$\sin x + \arctan y$\\
$\sqrt{x^2+y^2}$\\
$z=\sqrt[3]{x^{2} + \sqrt{y}}$\\
$A \neq B \quad A \approx C \quad $\\
$\Leftrightarrow\quad\Downarrow$\\
$\frac{\partial ^2f}{\partial x^2}$\\
$\prod_\epsilon$\\
$\Big((x+1)(x-1)\Big)^{2}$\\
$\int_a^b f(x) dx$\\
$\pm \div \times \cup \ast $
\end{document}
pycode-browser-1.02/Code/PythonBook/chap5/qpaper.tex 0000775 0000000 0000000 00000001542 12544046010 0022361 0 ustar 00root root 0000000 0000000 \documentclass{article}
\usepackage{amsmath}
\begin{document}
\begin{center}
\large{\textbf{Sample Question Paper\\for\\Mathematics using Python}}
\end{center}
\begin{tabular}{p{8cm}r}
\textbf{Duration:3 Hrs} & \textbf{30 weightage}
\end{tabular}\\
\section{Answer all Questions. $4\times 1\frac{1}{2}$}
\begin{enumerate}
\item What are the main document classes supported by LaTeX.
\item Typeset $\sin^{2}x+\cos^{2}x=1$ using LaTeX.
\item Plot a circle using the polar() function.
\item Write code to print all perfect cubes upto 2000.
\end{enumerate}
\section{Answer any two Questions. $3\times 5$}
\begin{enumerate}
\item Set a sample question paper using LaTeX.
\item Write a Python function to calculate the GCD of two numbers
\item Write a program with a Canvas and a circle drawn on it.
\end{enumerate}
\begin{center}\text{End}\end{center}
\end{document}
pycode-browser-1.02/Code/PythonBook/chap5/sections.tex 0000775 0000000 0000000 00000000477 12544046010 0022726 0 ustar 00root root 0000000 0000000 \documentclass{article}
\begin{document}
\tableofcontents
\section{Animals}
This document defines sections.
\subsection{Domestic}
This document also defines subsections.
\subsubsection{cats and dogs}
Cats and dogs are Domestic animals.
\section*{Appendix A}
The section with a * is not given a number.
\end{document}
pycode-browser-1.02/Code/PythonBook/chap5/texts.tex 0000775 0000000 0000000 00000000370 12544046010 0022236 0 ustar 00root root 0000000 0000000 \documentclass{article}
\begin{document}
This is normal text.
\newline
\textbf{This is bold face text. }
\textit{This is italic text. }\\
\tiny{This is tiny text. }
\large{This is large text. }
\underline{This is underlined text.}
\end{document}
pycode-browser-1.02/Code/PythonBook/chap6/ 0000775 0000000 0000000 00000000000 12544046010 0020343 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/Code/PythonBook/chap6/bisection.py 0000775 0000000 0000000 00000001131 12544046010 0022673 0 ustar 00root root 0000000 0000000 import math
def func(x):
return x**3 - 10.0* x*x + 5
def bisect(f, x1, x2, epsilon=1.0e-9):
f1 = f(x1)
f2 = f(x2)
if f1*f2 > 0.0:
print 'x1 ans x2 are on the same side of x-axis'
return None
n = math.ceil(math.log(abs(x2 - x1)/epsilon)/math.log(2.0))
n = int(n)
for i in range(n):
x3 = 0.5 * (x1 + x2)
f3 = f(x3)
if f3 == 0.0: return x3
if f2*f3 < 0.0:
x1 = x3
f1 = f3
else:
x2 =x3
f2 = f3
return (x1 + x2)/2.0
print bisect(func, 0.70, 0.8, 1.0e-4)
print bisect(func, 0.70, 0.8, 1.0e-9)
pycode-browser-1.02/Code/PythonBook/chap6/compareEuRK4.py 0000775 0000000 0000000 00000001375 12544046010 0023167 0 ustar 00root root 0000000 0000000 '''
Cosine function is integrated by Euler and RK4 methods.
Results at each step is compared with sine function.
'''
from pylab import *
def rk4(x, y, fx, h = 0.1): # x, y , derivative, stepsize
k1 = h * fx(x)
k2 = h * fx(x + h/2.0)
k3 = h * fx(x + h/2.0)
k4 = h * fx(x + h)
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
h = 0.1 # stepsize
x = 0.0 # initail values
ye = 0.0 # for Euler
yr = 0.0 # for RK4
ax = [] # Lists to store calculated values
euerr = []
rkerr = []
while x < 2*pi:
ye = ye + h * math.cos(x) # Euler method
yr = rk4(x, yr, cos, h) # Runge-Kutta method
x = x + h
ax.append(x)
euerr.append(ye - sin(x))
rkerr.append(yr - sin(x))
plot(ax,euerr,'+')
plot(ax, rkerr,'ro')
show()
pycode-browser-1.02/Code/PythonBook/chap6/diff.py 0000775 0000000 0000000 00000000524 12544046010 0021631 0 ustar 00root root 0000000 0000000 from math import *
def f1(x):
return x**2
def f2(x):
return x**4
def f3(x):
return x**10
def deriv(func, x, dx=0.1):
df = func(x+dx/2)-func(x-dx/2)
return df/dx
print deriv(f1, 1.0), deriv(f1, 1.0, 0.01)
print deriv(f2, 1.0), deriv(f2, 1.0, 0.01)
print deriv(f3, 1.0), deriv(f3, 1.0, 0.01)
pycode-browser-1.02/Code/PythonBook/chap6/euler.py 0000775 0000000 0000000 00000000453 12544046010 0022036 0 ustar 00root root 0000000 0000000 #integrate cosine using Euler method. The result should be sine
from pylab import *
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0
ax = []
ay = []
while x < 2*pi:
y = y + h * math.cos(x) # Euler method
x = x + h
ax.append(x)
ay.append(y)
plot(ax,ay)
show()
pycode-browser-1.02/Code/PythonBook/chap6/lsfit.py 0000775 0000000 0000000 00000000373 12544046010 0022044 0 ustar 00root root 0000000 0000000 from pylab import *
NP = 50
r = 2*ranf([NP]) - 0.5
x = linspace(0,10,NP)
data = 3 * x + 2 + r
xbar = mean(x)
ybar = mean(data)
b = sum(data*(x-xbar)) / sum(x*(x-xbar))
a = ybar - xbar * b
print a,b
y = a + b * x
plot(x,y)
plot(x,data,'ob')
show()
pycode-browser-1.02/Code/PythonBook/chap6/newinterpol.py 0000775 0000000 0000000 00000001005 12544046010 0023262 0 ustar 00root root 0000000 0000000 from pylab import *
def eval(a,xpoints,x):
n = len(xpoints) - 1
p = a[n]
for k in range(1,n+1):
p = a[n-k] + (x -xpoints[n-k]) * p
return p
def coef(x,y):
a = copy(y)
m = len(x)
for k in range(1,m):
a[k:m] = (a[k:m] - a[k-1])/(x[k:m]-x[k-1])
return a
x = array([0,1,2,3])
y = array([0,3,14,39])
coef = coef(x,y)
NP = 20
newx = linspace(0,3, NP) # New x-values
newy = zeros(NP)
for i in range(NP):
newy[i] = eval(coef, x, newx[i])
plot(newx, newy,'-x')
plot(x, y,'ro')
show()
pycode-browser-1.02/Code/PythonBook/chap6/newpoly.py 0000775 0000000 0000000 00000000363 12544046010 0022417 0 ustar 00root root 0000000 0000000 from copy import copy
def coef(x,y):
a = copy(y)
m = len(x)
for k in range(1,m):
tmp = copy(a)
for i in range(k,m):
tmp[i] = (a[i] - a[i-1])/(x[i]-x[i-k])
a = copy(tmp)
return a
x = [0,1,2,3]
y = [0,3,14,39]
print coef(x,y)
pycode-browser-1.02/Code/PythonBook/chap6/newpoly2.py 0000775 0000000 0000000 00000000313 12544046010 0022474 0 ustar 00root root 0000000 0000000 from numpy import *
def coef(x,y):
a = copy(y)
m = len(x)
for k in range(1,m):
a[k:m] = (a[k:m] - a[k-1])/(x[k:m]-x[k-1])
return a
x = array([0,1,2,3])
y = array([0,3,14,39])
print coef(x,y)
pycode-browser-1.02/Code/PythonBook/chap6/newraph.py 0000775 0000000 0000000 00000000375 12544046010 0022371 0 ustar 00root root 0000000 0000000 from pylab import *
def f(x):
return 2.0 * x**2 - 3*x - 5
def df(x):
return 4.0 * x - 3
def nr(x, tol = 1.0e-9):
for i in range(30):
dx = -f(x)/df(x)
#print x
x = x + dx
if abs(dx) < tol:
return x
print nr(4)
print nr(1)
print nr(-4)
pycode-browser-1.02/Code/PythonBook/chap6/newraph_plot.py 0000775 0000000 0000000 00000000466 12544046010 0023430 0 ustar 00root root 0000000 0000000 #Newton Raphson method
from pylab import *
def f(x):
return 2.0 * x**2 - 3*x - 5
def df(x):
return 4.0 * x - 3
vf = vectorize(f)
x = linspace(-2, 5, 100)
y = vf(x)
x1 = 4
tg1 = df(x1)*(x-x1) + f(x1)
x1 = -3
tg2 = df(x1)*(x-x1) + f(x1)
grid(True)
plot(x,y)
plot(x,tg1)
plot(x,tg2)
ylim([-20,40])
show()
pycode-browser-1.02/Code/PythonBook/chap6/poly.py 0000775 0000000 0000000 00000000276 12544046010 0021710 0 ustar 00root root 0000000 0000000 #Example poly.py
from pylab import *
a = poly1d([3,4,5])
b = poly1d([6,7])
c = a * b + 5
d = c/a
print a
print a(0.5)
print b
print a * b
print a.deriv()
print a.integ()
print d[0], d[1]
pycode-browser-1.02/Code/PythonBook/chap6/polyplot.py 0000775 0000000 0000000 00000000301 12544046010 0022574 0 ustar 00root root 0000000 0000000 #Example polyplot.py
from pylab import *
x = linspace(-pi, pi, 100)
a = poly1d([-1.0/5040,0,1.0/120,0,-1.0/6,0,1,0])
da = a.deriv()
y = a(x)
y1 = da(x)
plot(x,y)
plot(x,y1)
grid(True)
show()
pycode-browser-1.02/Code/PythonBook/chap6/rk4.py 0000775 0000000 0000000 00000001075 12544046010 0021423 0 ustar 00root root 0000000 0000000 '''
Solving initial value problem using 4th order Runge-Kutta method.
Sine function is calculated by integrating its derivative, cosine.
'''
from pylab import *
def rk4(x, y, fx, h = 0.01): # x, y , derivative, stepsize
k1 = h * fx(x)
k2 = h * fx(x + h/2.0)
k3 = h * fx(x + h/2.0)
k4 = h * fx(x + h)
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
h = 0.01 # stepsize
x = 0.0 # initail values
y = 0.0
ax = [x]
ay = [y]
while x < math.pi:
y = rk4(x,y,math.cos) # Runge-Kutta method
x = x + h
ax.append(x)
ay.append(y)
plot(ax,ay)
show()
pycode-browser-1.02/Code/PythonBook/chap6/rk4_proper.py 0000775 0000000 0000000 00000001170 12544046010 0023006 0 ustar 00root root 0000000 0000000 '''
Solving initial value problem using 4th order Runge-Kutta method.
derivative depends on the value of the function.
f(x,y) = 1 + y**2
'''
from pylab import *
def f1(x,y):
return 1 + y**2
def f2(x,y):
return (y-x)/(y+x)
def rk4(x, y, fxy, h): # x, y , f(x,y)
k1 = h * fxy(x, y)
k2 = h * fxy(x + h/2.0, y+k1/2)
k3 = h * fxy(x + h/2.0, y+k2/2)
k4 = h * fxy(x + h, y+k3)
ny = y + ( k1/6 + k2/3 + k3/3 + k4/6 )
#print x,y,k1,k2,k3,k4, ny
return ny
h = 0.2 # stepsize
x = 0.0 # initail values
y = 0.0
print rk4(x,y,f1,h)
h = 1 # stepsize
x = 0.0 # initail values
y = 1.0
print rk4(x,y,f2,h)
pycode-browser-1.02/Code/PythonBook/chap6/rootsearch.py 0000775 0000000 0000000 00000000505 12544046010 0023071 0 ustar 00root root 0000000 0000000 import math
def func(x):
return x**3 - 10.0* x*x + 5
def rootsearch(f,a,b,dx):
x = a
while True:
f1 = f(x)
f2 = f(x+dx)
if f1*f2 < 0:
return x, x + dx
x = x + dx
if x >= b:
print 'Failed to find root'
return
x,y = rootsearch(func, 0.0,1.0,.1)
print x,y
x,y = rootsearch(math.cos, 0.0, 4,.1)
print x,y
pycode-browser-1.02/Code/PythonBook/chap6/series_sc.py 0000775 0000000 0000000 00000000612 12544046010 0022676 0 ustar 00root root 0000000 0000000 from pylab import *
def factorial(n): # a recursive function
if n == 0:
return 1
else:
return n * factorial(n-1)
NP = 100
x = linspace(-pi, pi, NP)
sinx = zeros(NP)
cosx = zeros(NP)
for n in range(10):
sinx += (-1)**(n) * (x**(2*n+1)) / factorial(2*n+1)
cosx += (-1)**(n) * (x**(2*n)) / factorial(2*n)
plot(x, sinx)
plot(x, cosx, 'r')
show()
pycode-browser-1.02/Code/PythonBook/chap6/solve_eqn.py 0000775 0000000 0000000 00000000155 12544046010 0022714 0 ustar 00root root 0000000 0000000 from numpy import *
b = array([0,9,0])
A = array([ [4,1,-2], [2,-3,3],[-6,-2,1]])
print dot(linalg.inv(A),b)
pycode-browser-1.02/Code/PythonBook/chap6/tan.py 0000775 0000000 0000000 00000000113 12544046010 0021475 0 ustar 00root root 0000000 0000000 from pylab import *
x = linspace(0, 2*pi,400)
y = tan(x)
plot(x,y)
show()
pycode-browser-1.02/Code/PythonBook/chap6/taylor.py 0000775 0000000 0000000 00000000430 12544046010 0022227 0 ustar 00root root 0000000 0000000 from numpy import *
p = poly1d([1,1,1,0])
dp = p.deriv()
dp2 = dp.deriv()
dp3 = dp2.deriv()
a = 0 # The known point
x = 0
while x < .5:
tay = p(a) + (x-a)* dp(a) + \
(x-a)**2 * dp2(a) / 2 + (x-a)**3 * dp3(a)/6
print '%5.1f %8.5f\t%8.5f'%(x, p(x), tay)
x = x + .1
pycode-browser-1.02/Code/PythonBook/chap6/trapez.py 0000775 0000000 0000000 00000000472 12544046010 0022230 0 ustar 00root root 0000000 0000000 from math import *
def sqr(a):
return sqrt(1.0 - a**2)
def trapez(f, a, b, n):
h = (b-a) / n
sum = f(a)
for i in range (1,n):
sum = sum + 2 * f(a + h * i)
sum = sum + f(b)
return 0.5 * h * sum
print 4*trapez(sqr,0.,1.,100)
print 4*trapez(sqr,0.,1.,1000)
print 4*trapez(sqr,0,1,100) # Why the error ?
pycode-browser-1.02/Code/PythonBook/chap6/trapez_figure.py 0000775 0000000 0000000 00000000535 12544046010 0023571 0 ustar 00root root 0000000 0000000 #Example polyplot.py
from pylab import *
x = linspace(0.5,2.5, 100)
y = 1 + sin(x)
plot(x,y,linewidth=2)
a = [1,1]
b = [0,1+sin(1.)]
plot(a,b,'b-',linewidth=2)
a = [2,2]
b = [0,1+sin(2.0)]
plot(a,b,'b-',linewidth=2)
xc = 1+.05
while xc < 2:
a = [xc,xc]
b = [0,1+sin(xc)]
plot(a,b,'b-',linewidth=1)
xc= xc + .1
xlim(0.,3)
ylim(0.,3)
show()
pycode-browser-1.02/Code/PythonBook/chap6/vdiff.py 0000775 0000000 0000000 00000000413 12544046010 0022014 0 ustar 00root root 0000000 0000000 #Example vdiff.py
from pylab import *
def f(x):
return sin(x)
def deriv(x,dx=0.005):
df = f(x+dx/2)-f(x-dx/2)
return df/dx
vecderiv = vectorize(deriv)
x = linspace(-2*pi, 2*pi, 200)
y = vecderiv(x,1.0)
plot(x,y,'+')
plot(x,cos(x))
show()
pycode-browser-1.02/LICENSE.txt 0000664 0000000 0000000 00000104513 12544046010 0016223 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
pycode-browser-1.02/Makefile 0000664 0000000 0000000 00000001317 12544046010 0016036 0 ustar 00root root 0000000 0000000 DESTDIR=
SHAREDIR=/usr/share/pycode-browser
BINDIR=$(DESTDIR)/usr/bin
APPDIR=$(DESTDIR)/usr/share/applications
all:
make -C pybooksrc all DESTDIR=$(DESTDIR)
clean:
rm -f *~
make -C pybooksrc clean
install:
mkdir -p $(DESTDIR)$(SHAREDIR)
cp -a Code gui pycode-browser.py $(DESTDIR)$(SHAREDIR)
cp pybooksrc/mapy.pdf $(DESTDIR)$(SHAREDIR)/
find $(DESTDIR)$(SHAREDIR) -type f -exec chmod 466 {} \;
mkdir $(BINDIR)
echo "#! /bin/sh" > $(BINDIR)/pycode-browser
echo "python $(SHAREDIR)/pycode-browser.py" >> $(BINDIR)/pycode-browser
echo "#! /bin/sh" > $(BINDIR)/pycode-browser-book
echo "evince $(SHAREDIR)/mapy.pdf" >> $(BINDIR)/pycode-browser-book
mkdir -p $(APPDIR)
install -m 644 *.desktop $(APPDIR)
pycode-browser-1.02/README 0000664 0000000 0000000 00000001077 12544046010 0015261 0 ustar 00root root 0000000 0000000 PyCodeBrowser: You can put any number of python files in this
directory and the software will list and execute the files.
Note: Most of the example code on the Code directory were written by Dr. Ajith Kumar for phoenix project. Rest are from the example code for various projects. If you found any of these sample programs are non-distributable please inform me, I will remove it from the repository.
Version 0.93
Authors:
Vibeesh P
Vimal Joseph
Python code in the Code directory: Dr. Ajith Kumar
pycode-browser-1.02/gui/ 0000775 0000000 0000000 00000000000 12544046010 0015160 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/gui/gui.glade 0000775 0000000 0000000 00000025723 12544046010 0016756 0 ustar 00root root 0000000 0000000
800600True Python Code BrowsercenterTrueverticalTrueTrue_FileTrueTruegtk-executeTrueFalseTrueTruegtk-save-asTrueFalseTrueTrueTruegtk-quitTrueTrueTrueTrue_HelpTrueTruegtk-aboutTrueTrueTrueFalse0TruebothTrueFalseExecuteTruegtk-executeFalseTrueTrueFalseSave AsTruegtk-save-asFalseTrueTrueQuitTruegtk-quitFalseTrueFalse1TrueTrueTrue250TrueTruein150407TrueTrueFalseTrueTrueverticalTrueTrueautomaticautomatic0TrueTrue02TrueTrue300TrueTrueneverautomaticTrueTerminallabel_item3True2False4
pycode-browser-1.02/gui/gui.ui 0000664 0000000 0000000 00000023164 12544046010 0016311 0 ustar 00root root 0000000 0000000
800600True Python Code BrowsercenterTrueverticalTrueFalse0TruebothTrueFalseExecuteTruegtk-executeFalseTrueTrueFalseSave AsTruegtk-save-asFalseTrueTrueQuitTruegtk-quitFalseTrueFalse1TrueTrueTrue250TrueTruein150407TrueTrueFalseTrueTrueverticalTrueTrueautomaticautomatic0TrueTrue02TrueTrue300TrueTrueneverautomaticTrueTerminal3True2False4
pycode-browser-1.02/pybooksrc/ 0000775 0000000 0000000 00000000000 12544046010 0016407 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/pybooksrc/GNU-fdl.txt 0000664 0000000 0000000 00000054662 12544046010 0020361 0 ustar 00root root 0000000 0000000
GNU Free Documentation License
Version 1.3, 3 November 2008
Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
0. PREAMBLE
The purpose of this License is to make a manual, textbook, or other
functional and useful document "free" in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.
This License is a kind of "copyleft", which means that derivative
works of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft
license designed for free software.
We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does. But this License is not limited to software manuals;
it can be used for any textual work, regardless of subject matter or
whether it is published as a printed book. We recommend this License
principally for works whose purpose is instruction or reference.
1. APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein. The "Document", below,
refers to any such manual or work. Any member of the public is a
licensee, and is addressed as "you". You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.
A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall
subject (or to related matters) and contains nothing that could fall
directly within that overall subject. (Thus, if the Document is in
part a textbook of mathematics, a Secondary Section may not explain
any mathematics.) The relationship could be a matter of historical
connection with the subject or with related matters, or of legal,
commercial, philosophical, ethical or political position regarding
them.
The "Invariant Sections" are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License. If a
section does not fit the above definition of Secondary then it is not
allowed to be designated as Invariant. The Document may contain zero
Invariant Sections. If the Document does not identify any Invariant
Sections then there are none.
The "Cover Texts" are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License. A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.
A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or
for automatic translation to a variety of formats suitable for input
to text formatters. A copy made in an otherwise Transparent file
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
of text. A copy that is not "Transparent" is called "Opaque".
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
or XML using a publicly available DTD, and standard-conforming simple
HTML, PostScript or PDF designed for human modification. Examples of
transparent image formats include PNG, XCF and JPG. Opaque formats
include proprietary formats that can be read and edited only by
proprietary word processors, SGML or XML for which the DTD and/or
processing tools are not generally available, and the
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
The "Title Page" means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in
formats which do not have any title page as such, "Title Page" means
the text near the most prominent appearance of the work's title,
preceding the beginning of the body of the text.
The "publisher" means any person or entity that distributes copies of
the Document to the public.
A section "Entitled XYZ" means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language. (Here XYZ stands for a
specific section name mentioned below, such as "Acknowledgements",
"Dedications", "Endorsements", or "History".) To "Preserve the Title"
of such a section when you modify the Document means that it remains a
section "Entitled XYZ" according to this definition.
The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document. These Warranty
Disclaimers are considered to be included by reference in this
License, but only as regards disclaiming warranties: any other
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.
2. VERBATIM COPYING
You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies
to the Document are reproduced in all copies, and that you add no
other conditions whatsoever to those of this License. You may not use
technical measures to obstruct or control the reading or further
copying of the copies you make or distribute. However, you may accept
compensation in exchange for copies. If you distribute a large enough
number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and
you may publicly display copies.
3. COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover. Both covers must also clearly and legibly identify
you as the publisher of these copies. The front cover must present
the full title with all words of the title equally prominent and
visible. You may add other material on the covers in addition.
Copying with changes limited to the covers, as long as they preserve
the title of the Document and satisfy these conditions, can be treated
as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto adjacent
pages.
If you publish or distribute Opaque copies of the Document numbering
more than 100, you must either include a machine-readable Transparent
copy along with each Opaque copy, or state in or with each Opaque copy
a computer-network location from which the general network-using
public has access to download using public-standard network protocols
a complete Transparent copy of the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps,
when you begin distribution of Opaque copies in quantity, to ensure
that this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you distribute an
Opaque copy (directly or through your agents or retailers) of that
edition to the public.
It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to
give them a chance to provide you with an updated version of the
Document.
4. MODIFICATIONS
You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy
of it. In addition, you must do these things in the Modified Version:
A. Use in the Title Page (and on the covers, if any) a title distinct
from that of the Document, and from those of previous versions
(which should, if there were any, be listed in the History section
of the Document). You may use the same title as a previous version
if the original publisher of that version gives permission.
B. List on the Title Page, as authors, one or more persons or entities
responsible for authorship of the modifications in the Modified
Version, together with at least five of the principal authors of the
Document (all of its principal authors, if it has fewer than five),
unless they release you from this requirement.
C. State on the Title page the name of the publisher of the
Modified Version, as the publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications
adjacent to the other copyright notices.
F. Include, immediately after the copyright notices, a license notice
giving the public permission to use the Modified Version under the
terms of this License, in the form shown in the Addendum below.
G. Preserve in that license notice the full lists of Invariant Sections
and required Cover Texts given in the Document's license notice.
H. Include an unaltered copy of this License.
I. Preserve the section Entitled "History", Preserve its Title, and add
to it an item stating at least the title, year, new authors, and
publisher of the Modified Version as given on the Title Page. If
there is no section Entitled "History" in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.
J. Preserve the network location, if any, given in the Document for
public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions
it was based on. These may be placed in the "History" section.
You may omit a network location for a work that was published at
least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.
K. For any section Entitled "Acknowledgements" or "Dedications",
Preserve the Title of the section, and preserve in the section all
the substance and tone of each of the contributor acknowledgements
and/or dedications given therein.
L. Preserve all the Invariant Sections of the Document,
unaltered in their text and in their titles. Section numbers
or the equivalent are not considered part of the section titles.
M. Delete any section Entitled "Endorsements". Such a section
may not be included in the Modified Version.
N. Do not retitle any existing section to be Entitled "Endorsements"
or to conflict in title with any Invariant Section.
O. Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant. To do this, add their titles to the
list of Invariant Sections in the Modified Version's license notice.
These titles must be distinct from any other section titles.
You may add a section Entitled "Endorsements", provided it contains
nothing but endorsements of your Modified Version by various
parties--for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.
You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list
of Cover Texts in the Modified Version. Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or
through arrangements made by) any one entity. If the Document already
includes a cover text for the same cover, previously added by you or
by arrangement made by the same entity you are acting on behalf of,
you may not add another; but you may replace the old one, on explicit
permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.
5. COMBINING DOCUMENTS
You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and
list them all as Invariant Sections of your combined work in its
license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single
copy. If there are multiple Invariant Sections with the same name but
different contents, make the title of each such section unique by
adding at the end of it, in parentheses, the name of the original
author or publisher of that section if known, or else a unique number.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled "History"
in the various original documents, forming one section Entitled
"History"; likewise combine any sections Entitled "Acknowledgements",
and any sections Entitled "Dedications". You must delete all sections
Entitled "Endorsements".
6. COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other
documents released under this License, and replace the individual
copies of this License in the various documents with a single copy
that is included in the collection, provided that you follow the rules
of this License for verbatim copying of each of the documents in all
other respects.
You may extract a single document from such a collection, and
distribute it individually under this License, provided you insert a
copy of this License into the extracted document, and follow this
License in all other respects regarding verbatim copying of that
document.
7. AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
distribution medium, is called an "aggregate" if the copyright
resulting from the compilation is not used to limit the legal rights
of the compilation's users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
the entire aggregate, the Document's Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
aggregate.
8. TRANSLATION
Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include
translations of some or all Invariant Sections in addition to the
original versions of these Invariant Sections. You may include a
translation of this License, and all the license notices in the
Document, and any Warranty Disclaimers, provided that you also include
the original English version of this License and the original versions
of those notices and disclaimers. In case of a disagreement between
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.
If a section in the Document is Entitled "Acknowledgements",
"Dedications", or "History", the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.
9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense, or distribute it is void, and
will automatically terminate your rights under this License.
However, if you cease all violation of this License, then your license
from a particular copyright holder is reinstated (a) provisionally,
unless and until the copyright holder explicitly and finally
terminates your license, and (b) permanently, if the copyright holder
fails to notify you of the violation by some reasonable means prior to
60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, receipt of a copy of some or all of the same material does
not give you any rights to use it.
10. FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the
GNU Free Documentation License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in
detail to address new problems or concerns. See
http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
License "or any later version" applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation. If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation. If the Document
specifies that a proxy can decide which future versions of this
License can be used, that proxy's public statement of acceptance of a
version permanently authorizes you to choose that version for the
Document.
11. RELICENSING
"Massive Multiauthor Collaboration Site" (or "MMC Site") means any
World Wide Web server that publishes copyrightable works and also
provides prominent facilities for anybody to edit those works. A
public wiki that anybody can edit is an example of such a server. A
"Massive Multiauthor Collaboration" (or "MMC") contained in the site
means any set of copyrightable works thus published on the MMC site.
"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
license published by Creative Commons Corporation, a not-for-profit
corporation with a principal place of business in San Francisco,
California, as well as future copyleft versions of that license
published by that same organization.
"Incorporate" means to publish or republish a Document, in whole or in
part, as part of another Document.
An MMC is "eligible for relicensing" if it is licensed under this
License, and if all works that were first published under this License
somewhere other than this MMC, and subsequently incorporated in whole or
in part into the MMC, (1) had no cover texts or invariant sections, and
(2) were thus incorporated prior to November 1, 2008.
The operator of an MMC Site may republish an MMC contained in the site
under CC-BY-SA on the same site at any time before August 1, 2009,
provided the MMC is eligible for relicensing.
ADDENDUM: How to use this License for your documents
To use this License in a document you have written, include a copy of
the License in the document and put the following copyright and
license notices just after the title page:
Copyright (c) YEAR YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
A copy of the license is included in the section entitled "GNU
Free Documentation License".
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
replace the "with...Texts." line with this:
with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
If you have Invariant Sections without Cover Texts, or some other
combination of the three, merge those two alternatives to suit the
situation.
If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of
free software license, such as the GNU General Public License,
to permit their use in free software.
pycode-browser-1.02/pybooksrc/LICENSE.TXT 0000664 0000000 0000000 00000000301 12544046010 0020064 0 ustar 00root root 0000000 0000000 This Document is distributed under the GNU Free Documentation License.
Author : Ajith Kumar B.P., Inter University Accelerator Centre, New Delhi 110067.
(bpajith@gmail.com, ajith@iuac.res.in)
pycode-browser-1.02/pybooksrc/Makefile 0000664 0000000 0000000 00000000563 12544046010 0020053 0 ustar 00root root 0000000 0000000 .SUFFIXES= .lyx .tex .pdf
DESTDIR=
all: mapy.pdf
clean:
rm -f *~ *.tex *.aux *.log *.pdf *.toc pics/*.eps
install:
%.tex: %.lyx
tmpHome=$$(mktemp -d); \
HOME=$${tmpHome} lyx --export latex $<; \
rm -rf $${tmpHome}
%.pdf: %.tex
pdflatex $<
logfile=$$(echo $< | sed 's/tex/log/'); \
while (grep Warning $${logfile}| grep -iq run); do \
pdflatex $<; \
done
pycode-browser-1.02/pybooksrc/mapy.lyx 0000664 0000000 0000000 00001206610 12544046010 0020121 0 ustar 00root root 0000000 0000000 #LyX 1.5.5 created this file. For more info see http://www.lyx.org/
\lyxformat 276
\begin_document
\begin_header
\textclass book
\language american
\inputencoding auto
\font_roman default
\font_sans default
\font_typewriter default
\font_default_family default
\font_sc false
\font_osf false
\font_sf_scale 100
\font_tt_scale 100
\graphics default
\paperfontsize default
\spacing single
\papersize custom
\use_geometry true
\use_amsmath 1
\use_esint 0
\cite_engine basic
\use_bibtopic false
\paperorientation portrait
\paperwidth 21cm
\paperheight 24cm
\leftmargin 3cm
\topmargin 1.5cm
\rightmargin 3cm
\bottommargin 1.5cm
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\papercolumns 1
\papersides 1
\paperpagestyle default
\tracking_changes false
\output_changes false
\author ""
\author ""
\end_header
\begin_body
\begin_layout Standard
\lang english
\begin_inset ERT
status open
\begin_layout Standard
\backslash
thispagestyle{empty}
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\begin_inset VSpace 0.5in*
\end_inset
\end_layout
\begin_layout Standard
\align center
\size huge
Python for Education
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/ylm20.png
width 8cm
\end_inset
\end_layout
\begin_layout Standard
\align center
\shape italic
\size large
Learning Maths & Science using Python
\end_layout
\begin_layout Standard
\align center
\shape italic
\size large
and
\end_layout
\begin_layout Standard
\align center
\shape italic
\size large
writing them in LaTeX
\end_layout
\begin_layout Standard
\begin_inset VSpace 0.5in
\end_inset
\end_layout
\begin_layout Standard
\align center
\size large
Ajith Kumar B.P.
\end_layout
\begin_layout Standard
\align center
\size large
Inter University Accelerator Centre
\end_layout
\begin_layout Standard
\align center
\size large
New Delhi 110067
\end_layout
\begin_layout Standard
\align center
\size large
www.iuac.res.in
\end_layout
\begin_layout Standard
\align center
\begin_inset VSpace 0.3in
\end_inset
\end_layout
\begin_layout Standard
\align center
June 2010
\end_layout
\begin_layout Standard
\newpage
\end_layout
\begin_layout Standard
\align center
Preface
\end_layout
\begin_layout Standard
\begin_inset Quotes eld
\end_inset
Mathematics, rightly viewed, possesses not only truth, but supreme beauty
-- a beauty cold and austere, like that of sculpture, without appeal to
any part of our weaker nature, without the gorgeous trappings of painting
or music, yet sublimely pure, and capable of a stern perfection such as
only the greatest art can show
\begin_inset Quotes erd
\end_inset
, wrote Bertrand Russell about the beauty of mathematics.
All of us may not reach such higher planes, probably reserved for Russels
and Ramanujans, but we also have beautiful curves and nice geometrical
figures with intricate symmetries, like fractals, generated by seemingly
dull equations.
This book attempts to explore it using a simple tool, the Python programming
language.
\end_layout
\begin_layout Standard
I started using Python for the Phoenix project (www.iuac.res.in).
Phoenix was driven in to Python by Pramode CE (pramode.net) and I followed.
Writing this document was triggered by some of my friends who are teaching
mathematics at Calicut University.
\end_layout
\begin_layout Standard
In the first chapter, a general introduction about computers and high level
programming languages is given.
Basics of Python language, Python modules for array and matrix manipulation,
2D and 3D data visualization, type-setting mathematical equations using
latex and numerical methods in Python are covered in the subsequent chapters.
Example programs are given for every topic discussed.
This document is meant for those who want to try out these examples and
modify them for better understanding.
Huge amount of material is already available online on the topics covered,
and the references to many resources on the Internet are given for the
benefit of the serious reader.
\end_layout
\begin_layout Standard
This book comes with a live CD, containing a modified version of Ubuntu
GNU/Linux operating system.
You can boot any PC from this CD and practice Python.
Click on the 'Learn by Coding' icon on the desktop to browse through a
collection of Python programs, run any of them with a single click.
You can practice Python very easily by modifying and running these example
programs.
\end_layout
\begin_layout Standard
This document is prepared using LyX, a LaTeX front-end.
It is distributed under the GNU Free Documentation License (www.gnu.org).
Feel free to make verbatim copies of this document and distribute through
any media.
For the LyX source files please contact the author.
\end_layout
\begin_layout Standard
Ajith Kumar
\end_layout
\begin_layout Standard
IUAC , New Delhi
\end_layout
\begin_layout Standard
ajith at iuac.res.in
\end_layout
\begin_layout Standard
\newpage
\end_layout
\begin_layout Standard
\begin_inset LatexCommand tableofcontents
\end_inset
\end_layout
\begin_layout Chapter
Introduction
\end_layout
\begin_layout Standard
Primary objective of this book is to explore the possibilities of using
Python language as a tool for learning mathematics and science.
The reader is not assumed to be familiar with computer programming.
Ability to think logically is enough.
Before getting into Python programming, we will briefly explain some basic
concepts and tools required.
\end_layout
\begin_layout Standard
Computer is essentially an electronic device like a radio or a television.
What makes it different from a radio or a TV is its ability to perform
different kinds of tasks using the same electronic and mechanical components.
This is achieved by making the electronic circuits flexible enough to work
according to a set of instructions.
The electronic and mechanical parts of a computer are called the Hardware
and the set of instructions is called Software (or computer program).
Just by changing the Software, computer can perform vastly different kind
of tasks.
The instructions are stored in binary format using electronic switches.
\end_layout
\begin_layout Section
Hardware Components
\end_layout
\begin_layout Standard
Central Processing Unit (CPU), Memory and Input/Output units are the main
hardware components of a computer.
CPU
\begin_inset Foot
status collapsed
\begin_layout Standard
The cabinet that encloses most of the hardware is called CPU by some, mainly
the computer vendors.
They are not referring to the actual CPU chip.
\end_layout
\end_inset
can be called the brain of the computer.
It contains a Control Unit and an Arithmetic and Logic Unit, ALU.
The control unit brings the instructions stored in the main memory one
by one and acts according to it.
It also controls the movement of data between memory and input/output units.
The ALU can perform arithmetic operations like addition, multiplication
and logical operations like comparing two numbers.
\end_layout
\begin_layout Standard
Memory stores the instructions and data, that is processed by the CPU.
All types of information are stored as binary numbers.
The smallest unit of memory is called a binary digit or Bit.
It can have a value of zero or one.
A group of eight bits are called a Byte.
A computer has Main and Secondary types of memory.
Before processing, data and instructions are moved into the main memory.
Main memory is organized into words of one byte size.
CPU can select any memory location by using it's address.
Main memory is made of semiconductor switches and is very fast.
There are two types of Main Memory.
Read Only Memory and Read/Write Memory.
Read/Write Memory is also called Random Access Memory.
All computers contains some programs in ROM which start running when you
switch on the machine.
Data and programs to be stored for future use are saved to Secondary memory,
mainly devices like Hard disks, floppy disks, CDROM or magnetic tapes.
\end_layout
\begin_layout Standard
The Input devices are for feeding the input data into the computer.
Keyboard is the most common input device.
Mouse, scanner etc.
are other input devices.
The processed data is displayed or printed using the output devices.
The monitor screen and printer are the most common output devices.
\end_layout
\begin_layout Section
Software components
\end_layout
\begin_layout Standard
An ordinary user expects an easy and comfortable interaction with a computer,
and most of them are least inclined to learn even the basic concepts.
To use modern computers for common applications like browsing and word
processing, all you need to do is to click on some icons and type on the
keyboard.
However, to write your own computer programs, you need to learn some basic
concepts, like the operating system, editors, compilers, different types
of user interfaces etc.
This section describes the basics from that point of view.
\end_layout
\begin_layout Subsection
The Operating System
\end_layout
\begin_layout Standard
Operating system (OS) is the software that interacts with the user and makes
the hardware resources available to the user.
It starts running when you switch on the computer and remains in control.
On user request, operating system loads other application programs from
disk to the main memory and executes them.
OS also provides a file system, a facility to store information on devices
like floppy disk and hard disk.
In fact the OS is responsible for managing all the hardware resources.
\end_layout
\begin_layout Standard
GNU/Linux and MS Windows are two popular operating systems.
Based on certain features, operating systems can be classified as:
\end_layout
\begin_layout Itemize
Single user, single process systems like MS DOS.
Only one process can run at a time.
Such operating systems do not have much control over the application programs.
\end_layout
\begin_layout Itemize
Multi-tasking systems like MS Windows, where more than one processe can
run at a time.
\end_layout
\begin_layout Itemize
Multi-user, multi-tasking systems like GNU/Linux, Unix etc.
More than one person can use the computer at the same time.
\end_layout
\begin_layout Itemize
Real-time systems, mostly used in control applications, where the response
time to any external input is maintained under specified limits.
\end_layout
\begin_layout Subsection
The User Interface
\end_layout
\begin_layout Standard
Interacting with a computer involves, starting various application programs
and managing them on the computer screen.
The software that manages these actions is called the user interface.
The two most common forms of user interface have historically been the
Command-line Interface, where computer commands are typed out line-by-line,
and the Graphical User Interface (GUI), where a visual environment (consisting
of windows, menus, buttons, icons, etc.) is present.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/terminal.png
width 12cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
A GNU/Linux Terminal
\begin_inset LatexCommand label
name "fig:The-command-terminal"
\end_inset
.
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Subsubsection
The Command Terminal
\end_layout
\begin_layout Standard
To run any particular program, we need to request the operating system to
do so.
Under a Graphical User Interface, we do this by choosing the desired applicatio
n from a menu.
It is possible only because someone has added it to the menu earlier.
When you start writing your own programs, obviously they will not appear
in any menu.
Another way to request the operating system to execute a program is to
enter the name of the program (more precisely, the name of the file containing
it) at the Command Terminal.
On an Ubuntu GNU/Linux system, you can start a Terminal from the menu names
Applications->Accessories->Terminal.
Figure
\begin_inset LatexCommand ref
reference "fig:The-command-terminal"
\end_inset
shows a Terminal displaying the list of files in a directory (output of
the command 'ls -l' , the -l option is for long listing).
\end_layout
\begin_layout Standard
The command processor offers a host of features to make the interaction
more comfortable.
It keeps track of the history of commands and we can recall previous commands,
modify and reuse them using the cursor keys.
There is also a completion feature implemented using the Tab key that reduces
typing.
Use the tab key to complete command and filenames.
To run
\shape italic
hello.py
\shape default
from our test directory, type
\shape italic
python h
\shape default
and then press the tab key to complete it.
If there are more than one file starting with 'h', you need to type more
characters until the ambiguity is removed.
Always use the up-cursor key to recall the previous commands and re-issue
it.
\end_layout
\begin_layout Standard
The commands given at the terminal are processed by a program called the
\shape italic
shell
\shape default
.
(The version now popular under GNU/Linux is called bash, the Bourne again
shell).
Some of the GNU/Linux commands are listed below.
\end_layout
\begin_layout Itemize
top : Shows the CPU and memory usage of all the processes started.
\end_layout
\begin_layout Itemize
cp filename filename : copies a file to another.
\end_layout
\begin_layout Itemize
mv : moves files from one folder to another, or rename a file.
\end_layout
\begin_layout Itemize
rm : deletes files or directories.
\end_layout
\begin_layout Itemize
man : display manual pages for a program.
For example 'man bash' will give help on the bash shell.
Press 'q' to come out of the help screen.
\end_layout
\begin_layout Itemize
info : A menu driven information system on various topics.
\end_layout
\begin_layout Standard
See the manual pages of 'mv', cp, 'rm' etc.
to know more about them.
Most of these commands are application programs, stored inside the folders
/bin or /sbin, that the shell starts for you and displays their output
inside the terminal window.
\end_layout
\begin_layout Subsection
The File-system
\end_layout
\begin_layout Standard
Before the advent of computers, people used to keep documents in files and
folders.
The designers of the Operating System have implemented the electronic counterpa
rts of the same.
The storage space is made to appear as files arranged inside folders (directory
is another term for folder).
A simplified schematic of the GNU/Linux file system is shown in figure
\begin_inset LatexCommand ref
reference "fig:The-GNU/Linux-file"
\end_inset
.
The outermost directory is called 'root' directory and represented using
the forward slash character.
Inside that we have folders named bin, usr, home, tmp etc., containing different
type of files.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/linux-tree.png
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
The GNU/Linux file system tree
\begin_inset LatexCommand label
name "fig:The-GNU/Linux-file"
\end_inset
.
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Subsubsection
Ownership & permissions
\end_layout
\begin_layout Standard
On a multi-user operating system, application programs and document files
must be protected against any misuse.
This is achieved by defining a scheme of ownerships and permissions.
Each and every file on the system will be owned by a specific user.
The read, write and execute permissions can be assigned to them, to control
the usage.
The concept of
\shape italic
group
\shape default
is introduced to share files between a selected group of users.
\end_layout
\begin_layout Standard
There is one special user named
\shape italic
root
\shape default
(also called the system administrator or the super user) , who has permission
to use all the resources.
Ordinary user accounts, with a username and password, are created for everyone
who wants to use the computer.
In a multi-user operating system, like GNU/Linux, every user will have
one directory inside which he can create sub-directories and files.
This is called the 'home directory' of that user.
Home directory of one user cannot be modified by another user.
\end_layout
\begin_layout Standard
The operating system files are owned by
\shape italic
root
\shape default
.
The /home directory contains subdirectories named after every ordinary
user, for example, the user
\shape italic
fred
\shape default
owns the directory
\shape italic
/home/fred
\shape default
(fig
\begin_inset LatexCommand ref
reference "fig:The-GNU/Linux-file"
\end_inset
) and its contents.
That is also called the user's home directory.
Every file and directory has three types of permissions : read, write and
execute.
To view them use the 'ls -l ' command.
The first character of output line tells the type of the file.
The next three characters show the
\shape italic
rwx
\shape default
(read, write, execute) permissions for the owner of that file.
Next three for the users belonging to the same group and the next three
for other users.
A hyphen character (-) means the permission corresponding to that field
is not granted.
For example, the figure
\begin_inset LatexCommand ref
reference "fig:The-command-terminal"
\end_inset
shows a listing of five files:
\end_layout
\begin_layout Enumerate
asecret.dat : read & write for the owner.
No one else can even see it.
\end_layout
\begin_layout Enumerate
foo.png : rw for owner, but others can view the file.
\end_layout
\begin_layout Enumerate
hello.py : rwx for owner, others can view and execute.
\end_layout
\begin_layout Enumerate
share.tex : rw for owner and other members of the same group.
\end_layout
\begin_layout Enumerate
xdata is a directory.
Note that execute permission is required to view contents of a directory.
\end_layout
\begin_layout Standard
The system of ownerships and permissions also protects the system from virus
attacks
\begin_inset Foot
status collapsed
\begin_layout Standard
Do not expect this from the MS Windows system.
Even though it allows to create users, any user ( by running programs or
viruses) is allowed to modify the system files.
This may be because it grew from a single process system like MSDOS and
still keeps that legacy.
\end_layout
\end_inset
.
The virus programs damage the system by modifying some application program.
On a true multi-user system, for example GNU/Linux, the application program
and other system files are owned by the root user and ordinary users have
no permission to modify them.
When a virus attempts to modify an application, it fails due to this permission
and ownership scheme.
\end_layout
\begin_layout Subsubsection
Current Directory
\end_layout
\begin_layout Standard
There is a working directory for every user.
You can create subdirectories inside that and change your current working
directory to any of them.
While using the command-line interface, you can use the 'cd' command to
change the current working directory.
Figure
\begin_inset LatexCommand ref
reference "fig:The-command-terminal"
\end_inset
shows how to change the directory and come back to the parent directory
by using double dots.
We also used the command 'pwd' to print the name of the current working
directory.
\end_layout
\begin_layout Section
Text Editors
\end_layout
\begin_layout Standard
To create and modify files, we use different application programs depending
on the type of document contained in that file.
Text editors are used for creating and modifying plain text matter, without
any formatting information embedded inside.
Computer programs are plain text files and to write computer programs,
we need a text editor.
\shape italic
'gedit'
\shape default
is a simple, easy to use text editor available on GNU/Linux, which provides
syntax high-lighting for several programming languages.
\end_layout
\begin_layout Section
High Level Languages
\end_layout
\begin_layout Standard
In order to solve a problem using a computer, it is necessary to evolve
a detailed and precise step by step method of solution.
A set of these precise and unambiguous steps is called an Algorithm.
It should begin with steps accepting input data and should have steps which
gives output data.
For implementing any algorithm on a computer, each of it's steps must be
converted into proper machine language instructions.
Doing this process manually is called Machine Language Programming.
Writing machine language programs need great care and a deep understanding
about the internal structure of the computer hardware.
High level languages are designed to overcome these difficulties.
Using them one can create a program without knowing much about the computer
hardware.
\end_layout
\begin_layout Standard
We already learned that to solve a problem we require an algorithm and it
has to be executed step by step.
It is possible to express the algorithm using a set of precise and unambiguous
notations.
The notations selected must be suitable for the problems to be solved.
\shape italic
A high level programming language is a set of well defined notations which
is capable of expressing algorithms.
\end_layout
\begin_layout Standard
In general a high level language should have the following features.
\end_layout
\begin_layout Enumerate
Ability to represent different data types like characters, integers and
real numbers.
In addition to this it should also support a collection of similar objects
like character strings, arrays etc.
\end_layout
\begin_layout Enumerate
Arithmetic and Logical operators that acts on the supported data types.
\end_layout
\begin_layout Enumerate
Control flow structures for decision making, branching, looping etc.
\end_layout
\begin_layout Enumerate
A set of syntax rules that precisely specify the combination of words and
symbols permissible in the language.
\end_layout
\begin_layout Enumerate
A set of semantic rules that assigns a single, precise and unambiguous meaning
to each syntactically correct statement.
\end_layout
\begin_layout Standard
Program text written in a high level language is often called the Source
Code.
It is then translated into the machine language by using translator programs.
There are two types of translator programs, the Interpreter and the Compiler.
\shape italic
\size small
Interpreter reads the high level language program line by line, translates
and executes it.
Compilers convert the entire program in to machine language and stores
it to a file which can be executed.
\end_layout
\begin_layout Standard
High level languages make the programming job easier.
We can write programs that are machine independent.
For the same program different compilers can produce machine language code
to run on different types of computers and operating systems.
BASIC, COBOL, FORTRAN, C, C++, Python etc.
are some of the popular high level languages, each of them having advantages
in different fields.
\end_layout
\begin_layout Standard
To write any useful program for solving a problem, one has to develop an
algorithm.
The algorithm can be expressed in any suitable high level language.
\shape italic
Learning how to develop an algorithm is different from learning a programming
language.
\color black
Learning a programming language means learning the notations, syntax and
semantic rules of that language
\color inherit
.
\shape default
Best way to do this is by writing small programs with very simple algorithms.
After becoming familiar with the notations and rules of the language one
can start writing programs to implement more complicated algorithms.
\end_layout
\begin_layout Section
On Free Software
\end_layout
\begin_layout Standard
Software that can be used, studied, modified and redistributed in modified
or unmodified form without restriction is called Free Software.
In practice, for software to be distributed as free software, the human-readabl
e form of the program (the source code) must be made available to the recipient
along with a notice granting the above permissions.
\end_layout
\begin_layout Standard
The free software movement was conceived in 1983 by Richard Stallman to
give the benefit of "software freedom" to computer users.
Stallman founded the Free Software Foundation in 1985 to provide the organizati
onal structure to advance his Free Software ideas.
Later on, alternative movements like Open Source Software came.
\end_layout
\begin_layout Standard
Software for almost all applications is currently available under the pool
of Free Software.
GNU/Linux operating system, OpenOffice.org office suite, LaTeX typesetting
system, Apache web server, GIMP image editor, GNU compiler collection,
Python interpreter etc.
are some of the popular examples.
For more information refer to www.gnu.org website.
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Enumerate
What are the basic hardware components of a computer.
\end_layout
\begin_layout Enumerate
Name the working directory of a user named 'ramu' under GNU/Linux.
\end_layout
\begin_layout Enumerate
What is the command to list the file names inside a directory (folder).
\end_layout
\begin_layout Enumerate
What is the command under GNU/Linux to create a new folder.
\end_layout
\begin_layout Enumerate
What is the command to change the working directory.
\end_layout
\begin_layout Enumerate
Can we install more than one operating systems on a single hard disk.
\end_layout
\begin_layout Enumerate
Name two most popular Desktop Environments for GNU/Linux.
\end_layout
\begin_layout Enumerate
How to open a command window from the main menu of Ubuntu GNU/Linux.
\end_layout
\begin_layout Enumerate
Explain the file ownership and permission scheme of GNU/Linux.
\end_layout
\begin_layout Chapter
Programming in Python
\end_layout
\begin_layout Standard
Python is a simple, high level language with a clean syntax.
It offers strong support for integration with other languages and tools,
comes with extensive standard libraries, and can be learned in a few days.
Many Python programmers report substantial productivity gains and feel
the language encourages the development of higher quality, more maintainable
code.
To know more visit the Python website.
\begin_inset Foot
status collapsed
\begin_layout Standard
http://www.python.org/
\end_layout
\begin_layout Standard
http://docs.python.org/tutorial/
\end_layout
\begin_layout Standard
This document, example programs and a GUI program to browse through them
are at
\end_layout
\begin_layout Standard
http://www.iuac.res.in/phoenix
\end_layout
\end_inset
\end_layout
\begin_layout Section
Getting started with Python
\end_layout
\begin_layout Standard
To start programming in Python, we have to learn how to type the source
code and save it to a file, using a text editor program.
We also need to know how to open a Command Terminal and start the Python
Interpreter.
The details of this process may vary from one system to another.
On an Ubuntu GNU/Linux system, you can open the
\shape italic
Text Editor
\shape default
and the
\shape italic
Terminal
\shape default
from the Applications->Accessories menu.
\end_layout
\begin_layout Subsection
Two modes of using Python Interpreter
\end_layout
\begin_layout Standard
If you issue the command 'python', without any argument, from the command
terminal, the Python interpreter will start and display a
\shape italic
'>>>'
\shape default
prompt where you can type Python statements.
Use this method only for viewing the results of single Python statements,
for example to use Python as a calculator.
It could be confusing when you start writing larger programs, having looping
and conditional statements.
The preferred way is to enter your source code in a text editor, save it
to a file (with .py extension) and execute it from the command terminal
using Python.
A screen-shot of the Desktop with Text Editor and Terminal is shown in
figure
\begin_inset LatexCommand ref
reference "fig:Text-Editor-and"
\end_inset
.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/python_edit.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Text Editor and Terminal Windows.
\begin_inset LatexCommand label
name "fig:Text-Editor-and"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
In this document, we will start writing small programs showing the essential
elements of the language without going into the details.
The reader is expected to run these example programs and also to modify
them in different ways.It is like learning to drive a car, you master it
by practicing.
\end_layout
\begin_layout Standard
Let us start with a program to display the words
\emph on
\color black
Hello World
\emph default
\color inherit
on the computer screen.
This is the customary 'hello world' program.
There is another version that prints 'Goodbye cruel world', probably invented
by those who give up at this point.
The Python 'hello world' program is shown below.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example.
hello.py
\end_layout
\begin_layout LyX-Code
\shape italic
\emph on
\color black
print 'Hello World'
\end_layout
\begin_layout Standard
This should be entered into a text file using any text editor.
On a GNU/Linux system you may use the text editor like 'gedit' to create
the source file, save it as
\shape italic
\color black
hello.py
\shape default
\color inherit
.
The next step is to call the Python Interpreter to execute the new program.
For that, open a command terminal and (at the $ prompt) type:
\begin_inset Foot
status collapsed
\begin_layout Standard
For quick practicing, boot from the CD provided with this book and click
on the learn-by-coding icon to browse through the example programs given
in this book.
The browser allows you to run any of them with a single click, modify and
save the modified versions.
\end_layout
\end_inset
\end_layout
\begin_layout Standard
$ python hello.py
\end_layout
\begin_layout Section
Variables and Data Types
\end_layout
\begin_layout Standard
As mentioned earlier, any high level programming language should support
several data types.
The problem to be solved is represented using variables belonging to the
supported data types.
Python supports numeric data types like integers, floating point numbers
and complex numbers.
To handle character strings, it uses the String data type.
Python also supports other compound data types like lists, tuples, dictionaries
etc.
\end_layout
\begin_layout Standard
In languages like C, C++ and Java, we need to explicitly declare the type
of a variable.
This is not required in Python.
The data type of a variable is decided by the value assigned to it.
This is called dynamic data typing.
The type of a particular variable can change during the execution of the
program.
If required, one type of variable can be converted in to another type by
explicit type casting, like
\begin_inset Formula $y=float(3)$
\end_inset
.
Strings are enclosed within single quotes or double quotes.
\end_layout
\begin_layout Standard
The program
\shape italic
first.py
\shape default
shows how to define variables of different data types.
It also shows how to embed comments inside a program.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: first.py
\end_layout
\begin_layout LyX-Code
'''
\end_layout
\begin_layout LyX-Code
A multi-line comment, within a pair of three single quotes.
\end_layout
\begin_layout LyX-Code
In a line, anything after a # sign is also a comment
\end_layout
\begin_layout LyX-Code
'''
\end_layout
\begin_layout LyX-Code
x = 10
\end_layout
\begin_layout LyX-Code
print x, type(x) # print x and its type
\end_layout
\begin_layout LyX-Code
x = 10.4
\end_layout
\begin_layout LyX-Code
print x, type(x)
\end_layout
\begin_layout LyX-Code
x = 3 + 4j
\end_layout
\begin_layout LyX-Code
print x, type(x)
\end_layout
\begin_layout LyX-Code
x = 'I am a String '
\end_layout
\begin_layout LyX-Code
print x, type(x)
\end_layout
\begin_layout Standard
The output of the program is shown below.
Note that the type of the variable
\shape italic
x
\shape default
changes during the execution of the program, depending on the value assigned
to it.
\end_layout
\begin_layout LyX-Code
10
\end_layout
\begin_layout LyX-Code
10.4
\end_layout
\begin_layout LyX-Code
(3+4j)
\end_layout
\begin_layout LyX-Code
I am a String
\end_layout
\begin_layout Standard
\align block
The program treats the variables like humans treat labelled envelopes.
We can pick an envelope, write some name on it and keep something inside
it for future use.
In a similar manner the program creates a variable, gives it a name and
keeps some value inside it, to be used in subsequent steps.
So far we have used four data types of Python: int, float, complex and
str.
To become familiar with them, you may write simple programs performing
arithmetic and logical operations using them.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: oper.py
\end_layout
\begin_layout LyX-Code
x = 2
\end_layout
\begin_layout LyX-Code
y = 4
\end_layout
\begin_layout LyX-Code
print x + y * 2
\end_layout
\begin_layout LyX-Code
s = 'Hello '
\end_layout
\begin_layout LyX-Code
print s + s
\end_layout
\begin_layout LyX-Code
print 3 * s
\end_layout
\begin_layout LyX-Code
print x == y
\end_layout
\begin_layout LyX-Code
print y == 2 * x
\end_layout
\begin_layout Standard
Running the program
\shape italic
oper.py
\shape default
will generate the following output.
\end_layout
\begin_layout LyX-Code
10
\end_layout
\begin_layout LyX-Code
Hello Hello
\end_layout
\begin_layout LyX-Code
Hello Hello Hello
\end_layout
\begin_layout LyX-Code
False
\end_layout
\begin_layout LyX-Code
True
\end_layout
\begin_layout Standard
Note that a String can be added to another string and it can be multiplied
by an integer.
Try to understand the logic behind that and also try adding a String to
an Integer to see what is the error message you will get.
We have used the logical operator
\begin_inset Formula $==$
\end_inset
for comparing two variables.
\end_layout
\begin_layout Section
Operators and their Precedence
\end_layout
\begin_layout Standard
Python supports a large number of arithmetic and logical operators.
They are summarized in the table
\begin_inset LatexCommand ref
reference "tab:Operators-in-Python"
\end_inset
.
An important thing to remember is their precedence.
In the expression
\shape italic
2+3*4
\shape default
, is the addition done first or the multiplication? According to elementary
arithmetics, the multiplication should be done first.
It means that the multiplication operator has higher precedence than the
addition operator.
If you want the addition to be done first, enforce it by using parenthesis
like
\begin_inset Formula $(2+3)*4$
\end_inset
.
Whenever there is ambiguity in evaluation, use parenthesis to clarify the
order of evaluation.
\end_layout
\begin_layout Standard
\begin_inset Float table
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Tabular
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Operator
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Description
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Expression
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Result
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
or
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Boolean OR
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
0 or 4
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
4
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
and
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Boolean AND
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
3 and 0
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
0
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
not x
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Boolean NOT
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
not 0
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
True
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
in, not in
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Membership tests
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
3 in [2.2,3,12]
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
True
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
<, <=, >, >=, !=, ==
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Comparisons
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
2 > 3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
False
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
|
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Bitwise OR
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
1 | 2
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
^
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Bitwise XOR
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
1 ^ 5
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
4
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
&
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Bitwise AND
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
1 & 3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
1
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
<<, >>
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Bitwise Shifting
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
1 << 3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
8
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
+ , -
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Add, Subtract
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
6 - 4
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
2
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
*, /, %
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Multiply, divide, reminder
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
5 % 2
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
1
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
+x , -x
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Positive, Negative
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
-5*2
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
-10
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
~
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Bitwise NOT
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
~1
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
-2
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
**
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Exponentiation
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
2 ** 3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
8
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
x[index]
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
Subscription
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
a='abcd' ; a[1]
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\shape italic
\size small
'b'
\end_layout
\end_inset
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Operators in Python listed according to their precedence.
\begin_inset LatexCommand label
name "tab:Operators-in-Python"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Section
Python Strings
\end_layout
\begin_layout Standard
So far we have come across four data types: Integer, Float, Complex and
String.
Out of which, String is somewhat different from the other three.
It is a collection of same kind of elements, characters.
The individual elements of a String can be accessed by indexing as shown
in
\shape italic
string.py
\shape default
.
String is a compound, or collection, data type.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: string.py
\end_layout
\begin_layout LyX-Code
s = 'hello world'
\end_layout
\begin_layout LyX-Code
print s[0] # print first element, h
\end_layout
\begin_layout LyX-Code
print s[1] # print e
\end_layout
\begin_layout LyX-Code
print s[-1] # will print the last character
\end_layout
\begin_layout Standard
Addition and multiplication is defined for Strings, as demonstrated by string2.py.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: string2.py
\end_layout
\begin_layout LyX-Code
a = 'hello'+'world'
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
b = 'ha' * 3
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout LyX-Code
print a[-1] + b[0]
\end_layout
\begin_layout Standard
\align left
will give the output
\end_layout
\begin_layout Standard
helloworld
\end_layout
\begin_layout Standard
hahaha
\end_layout
\begin_layout Standard
dh
\end_layout
\begin_layout Standard
\align left
The last element of
\shape italic
a
\shape default
and first element of
\shape italic
b
\shape default
are added, resulting in the string 'dh'
\end_layout
\begin_layout Subsection
Slicing
\end_layout
\begin_layout Standard
Part of a String can be extracted using the slicing operation.
It can be considered as a modified form of indexing a single character.
Indexing using
\begin_inset Formula $s[a:b]$
\end_inset
extracts elements
\begin_inset Formula $s[a]$
\end_inset
to
\begin_inset Formula $s[b-1]$
\end_inset
.
We can skip one of the indices.
If the index on the left side of the colon is skipped, slicing starts from
the first element and if the index on right side is skipped, slicing ends
with the last element.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: slice.py
\end_layout
\begin_layout Standard
a = 'hello world'
\end_layout
\begin_layout Standard
print a[3:5]
\end_layout
\begin_layout Standard
print a[6:]
\end_layout
\begin_layout Standard
print a[:5]
\end_layout
\begin_layout Standard
\align left
The reader can guess the nature of slicing operation from the output of
this code, shown below.
\end_layout
\begin_layout LyX-Code
'lo'
\end_layout
\begin_layout LyX-Code
'world'
\end_layout
\begin_layout LyX-Code
'hello'
\end_layout
\begin_layout Standard
Please note that specifying a right side index more than the length of the
string is equivalent to skipping it.
Modify
\shape italic
slice.py
\shape default
to print the result of
\begin_inset Formula $a[6:20]$
\end_inset
to demonstrate it.
\end_layout
\begin_layout Section
Python Lists
\end_layout
\begin_layout Standard
List is an important data type of Python.
It is much more flexible than String.
The individual elements can be of any type, even another list.
Lists are defined by enclosing the elements inside a pair of square brackets,
separated by commas.
The program
\shape italic
list1.py
\shape default
defines a list and print its elements.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: list1.py
\end_layout
\begin_layout LyX-Code
a = [2.3, 3.5, 234] # make a list
\end_layout
\begin_layout LyX-Code
print a[0]
\end_layout
\begin_layout LyX-Code
a[1] = 'haha' # Change an element
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout Standard
The output is shown below
\begin_inset Foot
status collapsed
\begin_layout Standard
The floating point number 2.3 showing as 2.2999999999999998 is interesting.
This is the very nature of floting point representation of numbers, nothing
to do with Python.
With the precision we are using, the error in representing 2.3 is around
2.0e-16.
This becomes a concern in operations like inversion of big matrices.
\end_layout
\end_inset
.
\end_layout
\begin_layout Standard
2.3
\end_layout
\begin_layout Standard
[2.2999999999999998, 'haha', 234]
\end_layout
\begin_layout Standard
Lists can be sliced in a manner similar to that if Strings.
List addition and multiplication are demonstrated by the following example.
We can also have another list as an element of a list.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: list2.py
\end_layout
\begin_layout LyX-Code
a = [1,2]
\end_layout
\begin_layout LyX-Code
print a * 2
\end_layout
\begin_layout LyX-Code
print a + [3,4]
\end_layout
\begin_layout LyX-Code
b = [10, 20, a]
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout Standard
The output of this program is shown below.
\end_layout
\begin_layout Standard
[1, 2, 1, 2]
\end_layout
\begin_layout Standard
[1, 2, 3, 4]
\end_layout
\begin_layout Standard
[10, 20, [1, 2] ]
\end_layout
\begin_layout Section
Mutable and Immutable Types
\end_layout
\begin_layout Standard
There is one major difference between String and List types, List is mutable
but String is not.
\shape italic
We can change the value of an element in a list, add new elements to it
and remove any existing element.
This is not possible with String type
\shape default
.
Uncomment the last line of
\shape italic
third.py
\shape default
and run it to clarify this point.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: third.py
\end_layout
\begin_layout LyX-Code
s = [3, 3.5, 234] # make a list
\end_layout
\begin_layout LyX-Code
s[2] = 'haha' # Change an element
\end_layout
\begin_layout LyX-Code
print s
\end_layout
\begin_layout LyX-Code
x = 'myname' # String type
\end_layout
\begin_layout LyX-Code
#x[1] = 2 # uncomment to get ERROR
\end_layout
\begin_layout Standard
The List data type is very flexible, an element of a list can be another
list.
We will be using lists extensively in the coming chapters.
Tuple is another data type similar to List, except that it is immutable.
List is defined inside square brackets, tuple is defined in a similar manner
but inside parenthesis, like
\begin_inset Formula $(3,3.5,234)$
\end_inset
.
\end_layout
\begin_layout Section
Input from the Keyboard
\end_layout
\begin_layout Standard
Since most of the programs require some input from the user, let us introduce
this feature before proceeding further.
There are mainly two functions used for this purpose,
\emph on
\color black
input()
\emph default
\color inherit
for numeric type data and
\emph on
\color black
raw_input()
\emph default
\color inherit
for String type data.
A message to be displayed can be given as an argument while calling these
functions.
\begin_inset Foot
status collapsed
\begin_layout Standard
Functions will be introduced later.
For the time being, understand that it is an isolated piece of code, called
from the main program with some input arguments and returns some output.
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: kin1.py
\end_layout
\begin_layout LyX-Code
x = input('Enter an integer ')
\end_layout
\begin_layout LyX-Code
y = input('Enter one more ')
\end_layout
\begin_layout LyX-Code
print 'The sum is ', x + y
\end_layout
\begin_layout LyX-Code
s = raw_input('Enter a String ')
\end_layout
\begin_layout LyX-Code
print 'You entered ', s
\end_layout
\begin_layout Standard
It is also possible to read more than one variable using a single input()
statement.
\emph on
\color black
String
\emph default
\color inherit
type data read using raw_input() may be converted into
\emph on
\color black
integer
\emph default
\color inherit
or
\emph on
\color black
float
\emph default
\color inherit
type if they contain only the valid characters.
In order to show the effect of conversion explicitly, we multiply the variables
by 2 before printing.
Multiplying a String by 2 prints it twice.
If the String contains any other characters than
\shape italic
0..9, .
and e
\shape default
, the conversion to float will give an error.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: kin2.py
\end_layout
\begin_layout LyX-Code
x,y = input('Enter x and y separated by comma ')
\end_layout
\begin_layout LyX-Code
print 'The sum is ', x + y
\end_layout
\begin_layout LyX-Code
s = raw_input('Enter a decimal number ')
\end_layout
\begin_layout LyX-Code
a = float(s)
\end_layout
\begin_layout LyX-Code
print s * 2 # prints string twice
\end_layout
\begin_layout LyX-Code
print a * 2 # converted value times 2
\end_layout
\begin_layout Standard
We have learned about the basic data types of Python and how to get input
data from the keyboard.
This is enough to try some simple problems and algorithms to solve them.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
area.py
\end_layout
\begin_layout LyX-Code
pi = 3.1416
\end_layout
\begin_layout LyX-Code
r = input('Enter Radius ')
\end_layout
\begin_layout LyX-Code
a = pi * r ** 2 #
\begin_inset Formula $A=\pi r^{2}$
\end_inset
\end_layout
\begin_layout LyX-Code
print 'Area = ', a
\end_layout
\begin_layout Standard
\align block
The above example calculates the area of a circle.
Line three calculates
\begin_inset Formula $r^{2}$
\end_inset
\InsetSpace ~
using the exponentiation operator
\begin_inset Formula $**$
\end_inset
, and multiply it with
\begin_inset Formula $\pi$
\end_inset
using the multiplication operator
\begin_inset Formula $*$
\end_inset
.
\begin_inset Formula $r^{2}$
\end_inset
is evaluated first because ** has higher precedence than *, otherwise the
result would be
\begin_inset Formula $(\pi r)^{2}$
\end_inset
.
\end_layout
\begin_layout Section
Iteration: while and for loops
\end_layout
\begin_layout Standard
If programs can only execute from the first line to the last in that order,
as shown in the previous examples, it would be impossible to write any
useful program.
For example, we need to print the multiplication table of eight.
Using our present knowledge, it would look like the following
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
badtable.py
\end_layout
\begin_layout LyX-Code
print 1 * 8
\end_layout
\begin_layout LyX-Code
print 2 * 8
\end_layout
\begin_layout LyX-Code
print 3 * 8
\end_layout
\begin_layout LyX-Code
print 4 * 8
\end_layout
\begin_layout LyX-Code
print 5 * 8
\end_layout
\begin_layout Standard
Well, we are stopping here and looking for a better way to do this job.
\end_layout
\begin_layout Standard
The solution is to use the
\emph on
\color black
while
\emph default
\color inherit
loop of Python.
The logical expression in front of
\shape italic
while
\shape default
is evaluated, and if it is True, the body of the while loop (the indented
lines below the while statement) is executed.
The process is repeated until the condition becomes false.
We should have some statement inside the body of the loop that will make
this condition false after few iterations.
Otherwise the program will run in an infinite loop and you will have to
press Control-C to terminate it.
\end_layout
\begin_layout Standard
The program
\shape italic
table.py
\shape default
, defines a variable
\begin_inset Formula $x$
\end_inset
and assigns it an initial value of 1.
Inside the while loop
\begin_inset Formula $x*8$
\end_inset
is printed and the value of
\begin_inset Formula $x$
\end_inset
is incremented.
This process will be repeated until the value of
\begin_inset Formula $x$
\end_inset
becomes greater than 10.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
table.py
\end_layout
\begin_layout LyX-Code
x = 1
\end_layout
\begin_layout LyX-Code
while x <= 10:
\end_layout
\begin_layout LyX-Code
print x * 8
\end_layout
\begin_layout LyX-Code
x = x + 1
\end_layout
\begin_layout Standard
As per the Python syntax, the while statement ends with a colon and the
code inside the
\emph on
\color black
while
\emph default
\color inherit
loop is indented.
Indentation can be done using tab or few spaces.
In this example, we have demonstrated a simple algorithm.
\end_layout
\begin_layout Subsection
Python Syntax, Colon & Indentation
\end_layout
\begin_layout Standard
Python was designed to be a highly readable language.
It has a relatively uncluttered visual layout, uses English keywords frequently
where other languages use punctuation, and has notably fewer syntactic
constructions than other popular structured languages.
\end_layout
\begin_layout Standard
There are mainly two things to remember about Python syntax:
\shape italic
indentation and colon
\shape default
.
\shape italic
Python uses indentation to delimit blocks of code
\shape default
.
Both space characters and tab characters are currently accepted as forms
of indentation in Python.
Mixing spaces and tabs can create bugs that are hard to find, since the
text editor does not show the difference.
There should not be any extra white spaces in the beginning of any line.
\end_layout
\begin_layout Standard
\shape italic
The line before any indented block must end with a colon character
\shape default
.
\end_layout
\begin_layout Subsection
Syntax of 'for loops'
\end_layout
\begin_layout Standard
Python
\shape italic
for
\shape default
loops are slightly different from the for loops of other languages.
Python
\shape italic
for
\shape default
loop iterates over a compound data type like a String, List or Tuple.
During each iteration, one member of the compound data is assigned to the
loop variable.
The flexibility of this can be seen from the examples below.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
forloop.py
\end_layout
\begin_layout LyX-Code
a = 'Hello'
\end_layout
\begin_layout LyX-Code
for ch in a: # ch is the loop variable
\end_layout
\begin_layout LyX-Code
print ch
\end_layout
\begin_layout LyX-Code
b = ['haha', 3.4, 2345, 3+5j]
\end_layout
\begin_layout LyX-Code
for item in b:
\end_layout
\begin_layout LyX-Code
print item
\end_layout
\begin_layout Standard
which gives the output :
\end_layout
\begin_layout Standard
H
\end_layout
\begin_layout Standard
e
\end_layout
\begin_layout Standard
l
\end_layout
\begin_layout Standard
l
\end_layout
\begin_layout Standard
o
\end_layout
\begin_layout Standard
haha
\end_layout
\begin_layout Standard
3.4
\end_layout
\begin_layout Standard
2345
\end_layout
\begin_layout Standard
(3+5j)
\end_layout
\begin_layout Standard
For constructing for loops that executes a fixed number of times, we can
create a list using the range() function and run the for loop over that.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
forloop2.py
\end_layout
\begin_layout LyX-Code
mylist = range(5)
\end_layout
\begin_layout LyX-Code
print mylist
\end_layout
\begin_layout LyX-Code
for item in mylist:
\end_layout
\begin_layout LyX-Code
print item
\end_layout
\begin_layout Standard
The output will look like :
\end_layout
\begin_layout Standard
[0, 1, 2, 3, 4]
\end_layout
\begin_layout Standard
0
\end_layout
\begin_layout Standard
1
\end_layout
\begin_layout Standard
2
\end_layout
\begin_layout Standard
3
\end_layout
\begin_layout Standard
4
\end_layout
\begin_layout Standard
The range function in the above example generates the list
\begin_inset Formula $[0,1,2,3,4]$
\end_inset
and the for loop walks thorugh it printing each member.
It is possible to specify the starting point and increment as arguments
in the form range(start, end+1, step).
The following example prints the table of 5 using this feature.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
forloop3.py
\end_layout
\begin_layout LyX-Code
mylist = range(5,51,5)
\end_layout
\begin_layout LyX-Code
for item in mylist:
\end_layout
\begin_layout LyX-Code
print item ,
\end_layout
\begin_layout Standard
The output is shown below.
\end_layout
\begin_layout Standard
5 10 15 20 25 30 35 40 45 50
\end_layout
\begin_layout Standard
The print statement inserts a newline at the end by default.
We can suppress this behaviour by adding a comma character at the end as
done in the previous example.
\end_layout
\begin_layout Standard
In some cases, we may need to traverse the list to modify some or all of
the elements.
This can be done by looping over a list of indices generated by the range()
function.For example, the program
\emph on
\emph default
forloop4.py
\size large
\emph on
\size default
\emph default
zeros all the elements of the list.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
forloop4.py
\end_layout
\begin_layout LyX-Code
a = [2, 5, 3, 4, 12]
\end_layout
\begin_layout LyX-Code
size = len(a)
\end_layout
\begin_layout LyX-Code
for k in range(size):
\end_layout
\begin_layout LyX-Code
a[k] = 0
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout Section
Conditional Execution: if, elif and else
\end_layout
\begin_layout Standard
In some cases, we may need to execute some section of the code only if certain
conditions are true.
Python implements this feature using the
\emph on
\color black
if, elif
\emph default
\color inherit
and
\emph on
\color black
else
\emph default
\color inherit
keywords, as shown in the next example.
The indentation levels of
\shape italic
if
\shape default
and the corresponding
\shape italic
elif
\shape default
and
\shape italic
else
\shape default
must be kept the same.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
compare.py
\end_layout
\begin_layout LyX-Code
x = raw_input('Enter a string ')
\end_layout
\begin_layout LyX-Code
if x == 'hello':
\end_layout
\begin_layout LyX-Code
print 'You typed ', x
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
big.py
\end_layout
\begin_layout LyX-Code
x = input('Enter a number ')
\end_layout
\begin_layout LyX-Code
if x > 10:
\end_layout
\begin_layout LyX-Code
print 'Bigger Number'
\end_layout
\begin_layout LyX-Code
elif x < 10:
\end_layout
\begin_layout LyX-Code
print 'Smaller Number'
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
print 'Same Number'
\end_layout
\begin_layout Standard
The statement
\shape italic
x > 10 and x < 15
\shape default
can be expressed in a short form, like
\shape italic
10 < x < 15
\shape default
.
\end_layout
\begin_layout Standard
The next example uses
\emph on
\color black
while
\emph default
\color inherit
and
\emph on
\color black
if
\emph default
\color inherit
keywords in the same program.
Note the level of indentation when the if statement comes inside the while
loop.
Remember that, the
\shape italic
if
\shape default
statement must be aligned with the corresponding
\shape italic
elif and else.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
big2.py
\end_layout
\begin_layout LyX-Code
x = 1
\end_layout
\begin_layout LyX-Code
while x < 11:
\end_layout
\begin_layout LyX-Code
if x < 5:
\end_layout
\begin_layout LyX-Code
print 'Small ', x
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
print 'Big ', x
\end_layout
\begin_layout LyX-Code
x = x + 1
\end_layout
\begin_layout LyX-Code
print 'Done'
\end_layout
\begin_layout Section
Modify loops : break and continue
\end_layout
\begin_layout Standard
We can use the
\emph on
\color black
break
\emph default
\color inherit
statement to terminate a loop, if some condition is met.
The
\shape italic
continue
\shape default
statement is used to skip the rest of the block and go to the beginning
again.
Both are demonstrated in the program
\shape italic
big3.py
\shape default
shown below.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example:
\emph default
\color inherit
big3.py
\end_layout
\begin_layout LyX-Code
x = 1
\end_layout
\begin_layout LyX-Code
while x < 10:
\end_layout
\begin_layout LyX-Code
if x < 3:
\end_layout
\begin_layout LyX-Code
print 'skipping work', x
\end_layout
\begin_layout LyX-Code
x = x + 1
\end_layout
\begin_layout LyX-Code
continue
\end_layout
\begin_layout LyX-Code
print x
\end_layout
\begin_layout LyX-Code
if x == 4:
\end_layout
\begin_layout LyX-Code
print 'Enough of work'
\end_layout
\begin_layout LyX-Code
break
\end_layout
\begin_layout LyX-Code
x = x + 1
\end_layout
\begin_layout LyX-Code
print 'Done'
\end_layout
\begin_layout Standard
The output of big3.py is listed below.
\end_layout
\begin_layout Standard
skipping work 1
\end_layout
\begin_layout Standard
skipping work 2
\end_layout
\begin_layout Standard
3
\end_layout
\begin_layout Standard
4
\end_layout
\begin_layout Standard
Enough of work
\end_layout
\begin_layout Standard
Done
\end_layout
\begin_layout Standard
\align block
Now let us write a program to find out the largest positive number entered
by the user.
The algorithm works in the following manner.
To start with, we assume that the largest number is zero.
After reading a number, the program checks whether it is bigger than the
current value of the largest number.
If so the value of the largest number is replaced with the current number.
The program terminates when the user enters zero.
Modify max.py to work with negative numbers also.
\end_layout
\begin_layout Standard
\align left
Example: max.py
\end_layout
\begin_layout LyX-Code
max = 0
\end_layout
\begin_layout LyX-Code
while True: # Infinite loop
\end_layout
\begin_layout LyX-Code
x = input('Enter a number ')
\end_layout
\begin_layout LyX-Code
if x > max:
\end_layout
\begin_layout LyX-Code
max = x
\end_layout
\begin_layout LyX-Code
if x == 0:
\end_layout
\begin_layout LyX-Code
print max
\end_layout
\begin_layout LyX-Code
break
\end_layout
\begin_layout Section
Line joining
\end_layout
\begin_layout Standard
Python interpreter processes the code line by line.
A program may have a long line of code that may not physically fit in the
width of the text editor.
In such cases, we can split a logical line of code into more than one physical
lines, using backslash characters (
\backslash
), in other words multiple physical lines are joined to form a logical line
before interpreting it.
\end_layout
\begin_layout LyX-Code
if 1900 < year < 2100 and 1 <= month <= 12 :
\end_layout
\begin_layout Standard
can be split like
\end_layout
\begin_layout LyX-Code
if 1900 < year < 2100
\backslash
\end_layout
\begin_layout LyX-Code
and 1 <= month <= 12 :
\end_layout
\begin_layout Standard
Do not split in the middle of words except for Strings.
A long String can be split as shown below.
\end_layout
\begin_layout LyX-Code
longname = 'I am so long and will
\backslash
\end_layout
\begin_layout LyX-Code
not fit in a single line'
\end_layout
\begin_layout LyX-Code
print longname
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Standard
We have now covered the minimum essentials of Python; defining variables,
performing arithmetic and logical operations on them and the control flow
statements.
These are sufficient for handling most of the programming tasks.
It would be better to get a grip of it before proceeding further, by writing
some code.
\end_layout
\begin_layout Enumerate
Modify the expression
\shape italic
print 5+3*2
\shape default
to get a result of 16
\end_layout
\begin_layout Enumerate
What will be the output of
\shape italic
print type(4.5)
\end_layout
\begin_layout Enumerate
Print all even numbers upto 30, suffixed by a * if the number is a multiple
of 6.
(hint: use % operator)
\end_layout
\begin_layout Enumerate
Write Python code to remove the last two characters of 'I am a long string'
by slicing, without counting the characters.
(hint: use negative indexing)
\end_layout
\begin_layout Enumerate
s = '012345' .
(a) Slice it to remove last two elements (b) remove first two element.
\end_layout
\begin_layout Enumerate
a = [1,2,3,4,5].
Use Slicing and multiplication to generate [2,3,4,2,3,4] from it.
\end_layout
\begin_layout Enumerate
Compare the results of 5/2, 5.0/2 and 2.0/3.
\end_layout
\begin_layout Enumerate
Print the following pattern using a while loop
\newline
+
\newline
++
\newline
+++
\newline
++++
\end_layout
\begin_layout Enumerate
Write a program to read inputs like 8A, 10C etc.
and print the integer and alphabet parts separately.
\end_layout
\begin_layout Enumerate
Write code to print a number in the binary format (for example 5 will be
printed as 101)
\end_layout
\begin_layout Enumerate
Write code to print all perfect cubes upto 2000.
\end_layout
\begin_layout Enumerate
Write a Python program to print the multiplication table of 5.
\end_layout
\begin_layout Enumerate
Write a program to find the volume of a box with sides 3,4 and 5 inches
in
\begin_inset Formula $cm^{3}$
\end_inset
( 1 inch = 2.54 cm)
\end_layout
\begin_layout Enumerate
Write a program to find the percentage of volume occupied by a sphere of
diameter
\begin_inset Formula $r$
\end_inset
fitted in a cube of side
\begin_inset Formula $r$
\end_inset
.
Read
\begin_inset Formula $r$
\end_inset
from the keyboard.
\end_layout
\begin_layout Enumerate
Write a Python program to calculate the area of a circle.
\end_layout
\begin_layout Enumerate
Write a program to divide an integer by another without using the / operator.
(hint: use - operator)
\end_layout
\begin_layout Enumerate
Count the number of times the character 'a' appears in a String read from
the keyboard.
Keep on prompting for the string until there is no 'a' in the input.
\end_layout
\begin_layout Enumerate
Create an integer division machine that will ask the user for two numbers
then divide and give the result.
The program should give the result in two parts: the whole number result
and the remainder.
Example: If a user enters 11 / 4, the computer should give the result 2
and remainder 3.
\end_layout
\begin_layout Enumerate
Modify the previous program to avoid division by zero error.
\end_layout
\begin_layout Enumerate
Create an adding machine that will keep on asking the user for numbers,
add them together and show the total after each step.
Terminate when user enters a zero.
\end_layout
\begin_layout Enumerate
Modify the adding machine to use raw_input() and check for errors like user
entering invalid characters.
\end_layout
\begin_layout Enumerate
Create a script that will convert Celsius to Fahrenheit.
The program should ask the users to enter the temperature in Celsius and
should print out the temperature in Fahrenheit, using
\begin_inset Formula $f=\frac{9}{5}c+32$
\end_inset
.
\end_layout
\begin_layout Enumerate
Write a program to convert Fahrenheit to Celsius.
\end_layout
\begin_layout Enumerate
Create a script that uses a variable and will write 20 times "I will not
talk in class." Make each sentence on a separate line.
\end_layout
\begin_layout Enumerate
Define
\begin_inset Formula $2+5j$
\end_inset
and
\begin_inset Formula $2-5j$
\end_inset
as complex numbers , and find their product.
Verify the result by defining the real and imaginary parts separately and
using the multiplication formula.
\end_layout
\begin_layout Enumerate
Write the multiplication table of 12 using while loop.
\end_layout
\begin_layout Enumerate
Write the multiplication table of a number, from the user, using for loop.
\end_layout
\begin_layout Enumerate
Print the powers of 2 up to 1024 using a for loop.
(only two lines of code)
\end_layout
\begin_layout Enumerate
Define the list a = [123, 12.4, 'haha', 3.4]
\newline
a) print all members using a for
loop
\newline
b) print the float type members ( use type() function)
\newline
c) insert a member
after 12.4
\newline
d) append more members
\end_layout
\begin_layout Enumerate
Make a list containing 10 members using a for loop.
\end_layout
\begin_layout Enumerate
Generate multiplication table of 5 with two lines of Python code.
(hint: range function)
\end_layout
\begin_layout Enumerate
Write a program to find the sum of five numbers read from the keyboard.
\end_layout
\begin_layout Enumerate
Write a program to read numbers from the keyboard until their sum exceeds
200.
Modify the program to ignore numbers greater than 99.
\end_layout
\begin_layout Enumerate
Write a Python function to calculate the GCD of two numbers
\end_layout
\begin_layout Enumerate
Write a Python program to find annual compound interest.
Get P,N and R from user
\end_layout
\begin_layout Section
Functions
\end_layout
\begin_layout Standard
Large programs need to be divided into small logical units.
A function is generally an isolated unit of code that has a name and does
a well defined job.
A function groups a number of program statements into a unit and gives
it a name.
This unit can be invoked from other parts of a program.
Python allows you to define functions using the
\shape italic
def
\shape default
keyword.
A function may have one or more variables as arguments, which receive their
values from the calling program.
\end_layout
\begin_layout Standard
In the example shown below, function arguments (a and b) get the values
3 and 4 respectively from the caller.
One can specify more than one variables in the return statement, separated
by commas.
The function will return a tuple containing those variables.
Some functions may not have any arguments, but while calling them we need
to use an empty parenthesis, otherwise the function will not be invoked.
If there is no return statement, a None is returned to the caller.
\end_layout
\begin_layout Standard
\align left
\emph on
Example func.py
\end_layout
\begin_layout LyX-Code
def sum(a,b): # a trivial function
\end_layout
\begin_layout LyX-Code
return a + b
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print sum(3, 4)
\end_layout
\begin_layout Standard
The function
\shape italic
factorial.py
\shape default
calls itself recursively.
The value of argument is decremented before each call.
Try to understand the working of this by inserting print statements inside
the function.
\end_layout
\begin_layout Standard
\align left
\emph on
Example factor.py
\end_layout
\begin_layout LyX-Code
def factorial(n): # a recursive function
\end_layout
\begin_layout LyX-Code
if n == 0:
\end_layout
\begin_layout LyX-Code
return 1
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
return n * factorial(n-1)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print factorial(10)
\end_layout
\begin_layout Standard
\align left
\emph on
Example fibanocci.py
\end_layout
\begin_layout LyX-Code
def fib(n): # print Fibonacci series up to n
\end_layout
\begin_layout LyX-Code
a, b = 0, 1
\end_layout
\begin_layout LyX-Code
while b < n:
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout LyX-Code
a, b = b, a+b
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print fib(30)
\end_layout
\begin_layout Standard
Runing
\shape italic
fibanocci.py
\shape default
will print
\end_layout
\begin_layout Quotation
1 1 2 3 5 8 13 21
\end_layout
\begin_layout Standard
Modify it to replace
\begin_inset Formula $a,b=b,a+b$
\end_inset
by two separate assignment statements, if required introduce a third variable.
\end_layout
\begin_layout Subsection
Scope of variables
\end_layout
\begin_layout Standard
The variables defined inside a function are not known outside the function.
There could be two variables, one inside and one outside, with the same
name.
The program
\shape italic
scope.py
\shape default
demonstrates this feature.
\end_layout
\begin_layout Standard
\align left
\emph on
Example scope.py
\end_layout
\begin_layout LyX-Code
def change(x):
\end_layout
\begin_layout LyX-Code
counter = x
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
counter = 10
\end_layout
\begin_layout LyX-Code
change(5)
\end_layout
\begin_layout LyX-Code
print counter
\end_layout
\begin_layout Standard
The program will print 10 and not 5.
The two variables, both named counter, are not related to each other.
In some cases, it may be desirable to allow the function to change some
external variable.
This can be achieved by using the
\shape italic
global
\shape default
keyword, as shown in
\shape italic
global.py
\shape default
.
\end_layout
\begin_layout Standard
\align left
\emph on
Example global.py
\end_layout
\begin_layout LyX-Code
def change(x):
\end_layout
\begin_layout LyX-Code
global counter # use the global variable
\end_layout
\begin_layout LyX-Code
counter = x
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
counter = 10
\end_layout
\begin_layout LyX-Code
change(5)
\end_layout
\begin_layout LyX-Code
print counter
\end_layout
\begin_layout Standard
The program will now print 5.
Functions with global variables should be used carefully to avoid inadvertent
side effects.
\end_layout
\begin_layout Subsection
Optional and Named Arguments
\end_layout
\begin_layout Standard
Python allows function arguments to have default values; if the function
is called without a particular argument, its default value will be taken.
Due to this feature, the same function can be called with different number
of arguments.
The arguments without default values must appear first in the argument
list and they cannot be omitted while invoking the function.
The following example shows a function named power() that does exponentiation,
but the default value of exponent is set to 2.
\end_layout
\begin_layout Standard
\align left
\emph on
Example power.py
\end_layout
\begin_layout LyX-Code
def power(mant, exp = 2.0):
\end_layout
\begin_layout LyX-Code
return mant ** exp
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print power(5., 3)
\end_layout
\begin_layout LyX-Code
print power(4.) # prints 16
\end_layout
\begin_layout LyX-Code
print power() # Gives Error
\end_layout
\begin_layout Standard
Arguments can be specified in any order by using named arguments.
\end_layout
\begin_layout Standard
\align left
\emph on
Example named.py
\end_layout
\begin_layout LyX-Code
def power(mant = 10.0, exp = 2.0):
\end_layout
\begin_layout LyX-Code
return mant ** exp
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print power(5., 3)
\end_layout
\begin_layout LyX-Code
print power(4.) # prints 16
\end_layout
\begin_layout LyX-Code
print power(exp=3) # mant gets 10.0, prints 1000
\end_layout
\begin_layout Section
More on Strings and Lists
\end_layout
\begin_layout Standard
Before proceeding further, we will explore some of the functions provided
for manipulating strings and lists.
Python strings can be manipulated in many ways.
The following program prints the length of a string, makes an upper case
version for printing and prints a help message on the String class.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: stringhelp.py
\end_layout
\begin_layout LyX-Code
s = 'hello world'
\end_layout
\begin_layout LyX-Code
print len(s)
\end_layout
\begin_layout LyX-Code
print s.upper()
\end_layout
\begin_layout LyX-Code
help(str) # press q to exit help
\end_layout
\begin_layout Standard
Python is an object oriented language and all variables are objects belonging
to various classes.
The method upper() (a function belonging to a class is called a method)
is invoked using the dot operator.
All we need to know at this stage is that there are several methods that
can be used for manipulating objects and they can be invoked like:
\shape italic
variable_name.method_name()
\shape default
.
\end_layout
\begin_layout Subsection
split and join
\end_layout
\begin_layout Standard
\align left
Splitting a String will result in a list of smaller strings.
If you do not specify the separator, the space character is assumed by
default.
To demonstrate the working of these functions, few lines of code and its
output are listed below.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: split.py
\end_layout
\begin_layout LyX-Code
s = 'I am a long string'
\end_layout
\begin_layout LyX-Code
print s.split()
\end_layout
\begin_layout LyX-Code
a = 'abc.abc.abc'
\end_layout
\begin_layout LyX-Code
aa = a.split('.')
\end_layout
\begin_layout LyX-Code
print aa
\end_layout
\begin_layout LyX-Code
mm = '+'.join(aa)
\end_layout
\begin_layout LyX-Code
print mm
\end_layout
\begin_layout Standard
\align left
The result is shown below
\end_layout
\begin_layout Standard
['I', 'am', 'a', 'long', 'string']
\end_layout
\begin_layout Standard
['abc', 'abc', 'abc']
\end_layout
\begin_layout Standard
'abc+abc+abc'
\end_layout
\begin_layout Standard
\align left
The List of strings generated by split is joined using '+' character, resulting
in the last line of the output.
\end_layout
\begin_layout Subsection
Manipulating Lists
\end_layout
\begin_layout Standard
Python lists are very flexible, we can append, insert, delete and modify
elements of a list.
The program
\shape italic
list3.py
\shape default
demonstrates some of them.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: list3.py
\end_layout
\begin_layout LyX-Code
a = [] # make an empty list
\end_layout
\begin_layout LyX-Code
a.append(3) # Add an element
\end_layout
\begin_layout LyX-Code
a.insert(0,2.5) # insert 2.5 as first element
\end_layout
\begin_layout LyX-Code
print a, a[0]
\end_layout
\begin_layout LyX-Code
print len(a)
\end_layout
\begin_layout Standard
The output is shown below.
\end_layout
\begin_layout Standard
[2.5, 3] 2.5
\end_layout
\begin_layout Standard
2
\end_layout
\begin_layout Subsection
Copying Lists
\end_layout
\begin_layout Standard
Lists cannot be copied like numeric data types.
The statement
\begin_inset Formula $b=a$
\end_inset
will not create a new list b from list a, it just make a reference to a.
The following example will clarify this point.
To make a duplicate copy of a list, we need to use the
\shape italic
copy
\shape default
module.
\end_layout
\begin_layout Standard
\align left
\emph on
\color black
Example: list_copy.py
\end_layout
\begin_layout LyX-Code
a = [1,2,3,4]
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
b = a # b refers to a
\end_layout
\begin_layout LyX-Code
print a == b # True
\end_layout
\begin_layout LyX-Code
b[0] = 5 # Modifies a[0]
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
import copy
\end_layout
\begin_layout LyX-Code
c = copy.copy(a)
\end_layout
\begin_layout LyX-Code
c[1] = 100
\end_layout
\begin_layout LyX-Code
print a is c # is False
\end_layout
\begin_layout LyX-Code
print a, c
\end_layout
\begin_layout Standard
The output is shown below.
\end_layout
\begin_layout Standard
[1, 2, 3, 4]
\end_layout
\begin_layout Standard
True
\end_layout
\begin_layout Standard
[5, 2, 3, 4]
\end_layout
\begin_layout Standard
False
\end_layout
\begin_layout Standard
[5, 2, 3, 4] [5, 100, 3, 4]
\end_layout
\begin_layout Section
Python Modules and Packages
\begin_inset Foot
status collapsed
\begin_layout Standard
While giving names to your Python programs, make sure that you are not directly
or indirectly importing any Python module having same name.
For example, if you create a program named
\emph on
math.py
\emph default
and keep it in your working directory, the
\emph on
import math
\emph default
statement from any other program started from that directory will try to
import your file named
\emph on
math.py
\emph default
and give error.
If you ever do that by mistake, delete all the files with .pyc extension
from your directory.
\end_layout
\end_inset
\end_layout
\begin_layout Standard
One of the major advantages of Python is the availability of libraries for
various applications like graphics, networking and scientific computation.
The standard library distributed with Python itself has a large number
of modules: time, random, pickle, system etc.
are some of them.
The site http://docs.python.org/library/ has the complete reference.
\end_layout
\begin_layout Standard
Modules are loaded by using the
\shape italic
import
\shape default
keyword.
Several ways of using
\shape italic
import
\shape default
is explained below, using the math (containing mathematical functions)
module as an example.
\end_layout
\begin_layout Subsection
Different ways to import
\end_layout
\begin_layout Standard
simplest way to use import is shown in
\shape italic
mathsin.py
\shape default
, where the function is invoked using the form
\shape italic
module_name.function_name()
\shape default
.
In the next example, we use an alias for the module name.
\end_layout
\begin_layout Standard
\align left
\emph on
Example mathsin.py
\end_layout
\begin_layout LyX-Code
import math
\end_layout
\begin_layout LyX-Code
print math.sin(0.5) # module_name.method_name
\end_layout
\begin_layout Standard
\align left
\emph on
Example mathsin2.py
\end_layout
\begin_layout LyX-Code
import math as m # Give another name for math
\end_layout
\begin_layout LyX-Code
print m.sin(0.5) # Refer by the new name
\end_layout
\begin_layout Standard
We can also import the functions to behave like local (like the ones within
our source file) function, as shown below.
The character * is a wild card for importing all the functions.
\end_layout
\begin_layout Standard
\align left
\emph on
Example mathlocal.py
\end_layout
\begin_layout LyX-Code
from math import sin # sin is imported as local
\end_layout
\begin_layout LyX-Code
print sin(0.5)
\end_layout
\begin_layout Standard
\align left
\emph on
Example mathlocal2.py
\end_layout
\begin_layout LyX-Code
from math import * # import everything from math
\end_layout
\begin_layout LyX-Code
print sin(0.5)
\end_layout
\begin_layout Standard
In the third and fourth cases, we need not type the module name every time.
But there could be trouble if two modules imported contains a function
with same name.
In the program
\emph on
conflict.py
\emph default
, the
\begin_inset Formula $\sin()$
\end_inset
from
\emph on
numpy
\emph default
is capable of handling a list argument.
After importing
\shape italic
math.py
\shape default
, line 4, the
\begin_inset Formula $\sin$
\end_inset
function from
\shape italic
math
\shape default
module replaces the one from
\emph on
numpy
\emph default
.
The error occurs because the
\begin_inset Formula $\sin()$
\end_inset
from
\emph on
math
\emph default
can accept only a numeric type argument.
\end_layout
\begin_layout Standard
\align left
\emph on
Example conflict.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
x = [0.1, 0.2, 0.3]
\end_layout
\begin_layout LyX-Code
print sin(x) # numpy's sin can handle lists
\end_layout
\begin_layout LyX-Code
from math import * # sin of math becomes effective
\end_layout
\begin_layout LyX-Code
print sin(x) # will give ERROR
\end_layout
\begin_layout Subsection
Packages
\end_layout
\begin_layout Standard
Packages are used for organizing multiple modules.
The module name A.B designates a submodule named B in a package named A.
The concept is demonstrated using the packages Numpy
\begin_inset Foot
status collapsed
\begin_layout Standard
NumPy will be discusssed later in chapter
\begin_inset LatexCommand ref
reference "sec:Arrays-and-Matrices"
\end_inset
.
\end_layout
\end_inset
and Scipy.
\end_layout
\begin_layout Standard
\align left
\emph on
Example submodule.py
\end_layout
\begin_layout LyX-Code
import numpy
\end_layout
\begin_layout LyX-Code
print numpy.random.normal()
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
import scipy.special
\end_layout
\begin_layout LyX-Code
print scipy.special.j0(.1)
\end_layout
\begin_layout Standard
In this example
\shape italic
random
\shape default
is a module inside the package
\shape italic
NumPy
\shape default
.
Similarly
\shape italic
special
\shape default
is a module inside the package
\shape italic
Scipy.
\shape default
We use both of them in the package.module.function() format.
But there is some difference.
In the case of Numpy, the random module is loaded by default, importing
scipy does not import the module special by default.
This behavior can be defined while writing the Package and it is upto the
package author.
\end_layout
\begin_layout Section
File Input/Output
\end_layout
\begin_layout Standard
Disk files can be opened using the function named open() that returns a
File object.
Files can be opened for reading or writing.
There are several methods belonging to the File class that can be used
for reading and writing data.
\end_layout
\begin_layout Standard
\align left
\emph on
Example wfile.py
\end_layout
\begin_layout LyX-Code
f = open('test.dat' , 'w')
\end_layout
\begin_layout LyX-Code
f.write ('This is a test file')
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Standard
Above program creates a new file named 'test.dat' (any existing file with
the same name will be deleted) and writes a String to it.
The following program opens this file for reading the data.
\end_layout
\begin_layout Standard
\align left
\emph on
Example rfile.py
\end_layout
\begin_layout LyX-Code
f = open('test.dat' , 'r')
\end_layout
\begin_layout LyX-Code
print f.read()
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Standard
Note that the data written/read are character strings.
read() function can also be used to read a fixed number of characters,
as shown below.
\end_layout
\begin_layout Standard
\align left
\emph on
Example rfile2.py
\end_layout
\begin_layout LyX-Code
f = open('test.dat' , 'r')
\end_layout
\begin_layout LyX-Code
print f.read(7) # get first seven characters
\end_layout
\begin_layout LyX-Code
print f.read() # get the remaining ones
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Standard
Now we will examine how to read a text data from a file and convert it into
numeric type.
First we will create a file with a column of numbers.
\end_layout
\begin_layout Standard
\align left
\emph on
Example wfile2.py
\end_layout
\begin_layout LyX-Code
f = open('data.dat' , 'w')
\end_layout
\begin_layout LyX-Code
for k in range(1,4):
\end_layout
\begin_layout LyX-Code
s = '%3d
\backslash
n' %(k)
\end_layout
\begin_layout LyX-Code
f.write(s)
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Standard
The contents of the file created will look like this.
\end_layout
\begin_layout Standard
1
\end_layout
\begin_layout Standard
2
\end_layout
\begin_layout Standard
3
\end_layout
\begin_layout Standard
\align left
Now we write a program to read this file, line by line, and convert the
string type data to integer type, and print the numbers.
\begin_inset Foot
status collapsed
\begin_layout Standard
This will give error if there is a blank line in the data file.
This can be corrected by changing the comparison statement to if
\shape italic
len(s) < 1:
\shape default
, so that the processing stops at a blank line.
Modify the code to skip a blank line instead of exiting (hint: use continue
).
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example rfile3.py
\end_layout
\begin_layout LyX-Code
f = open('data.dat' , 'r')
\end_layout
\begin_layout LyX-Code
while 1: # infinite loop
\end_layout
\begin_layout LyX-Code
s = f.readline()
\end_layout
\begin_layout LyX-Code
if s == '' : # Empty string means end of file
\end_layout
\begin_layout LyX-Code
break # terminate the loop
\end_layout
\begin_layout LyX-Code
m = int(s) # Convert to integer
\end_layout
\begin_layout LyX-Code
print m * 5
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Subsection
The pickle module
\end_layout
\begin_layout Standard
Strings can easily be written to and read from a file.
Numbers take a bit more effort, since the read() method only returns Strings,
which will have to be converted in to a number explicitly.
However, when you want to save and restore data types like lists, dictionaries,
or class instances, things get a lot more complicated.
Rather than have the users constantly writing and debugging code to save
complicated data types, Python provides a standard module called pickle.
\end_layout
\begin_layout Standard
\align left
\emph on
Example pickledump.py
\end_layout
\begin_layout LyX-Code
import pickle
\end_layout
\begin_layout LyX-Code
f = open('test.pck' , 'w')
\end_layout
\begin_layout LyX-Code
pickle.dump(12.3, f) # write a float type
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Standard
\align left
Now write another program to read it back from the file and check the data
type.
\end_layout
\begin_layout Standard
\align left
\emph on
Example pickleload.py
\end_layout
\begin_layout LyX-Code
import pickle
\end_layout
\begin_layout LyX-Code
f = open('test.pck' , 'r')
\end_layout
\begin_layout LyX-Code
x = pickle.load(f)
\end_layout
\begin_layout LyX-Code
print x , type(x) # check the type of data read
\end_layout
\begin_layout LyX-Code
f.close()
\end_layout
\begin_layout Section
Formatted Printing
\end_layout
\begin_layout Standard
Formatted printing is done by using a format string followed by the % operator
and the values to be printed.
If format requires a single argument, values may be a single variable.
Otherwise, values must be a tuple (just place them inside parenthesis,
separated by commas) with exactly the number of items specified by the
format string.
\end_layout
\begin_layout Standard
\align left
\emph on
Example: format.py
\end_layout
\begin_layout LyX-Code
a = 2.0 /3 # 2/3 will print zero
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
print 'a = %5.3f' %(a) # upto 3 decimal places
\end_layout
\begin_layout Standard
Data can be printed in various formats.
The conversion types are summarized in the following table.
There are several flags that can be used to modify the formatting, like
justification, filling etc.
\end_layout
\begin_layout Standard
\begin_inset Float table
wide false
sideways false
status open
\begin_layout Standard
\align center
\begin_inset Tabular
\begin_inset Text
\begin_layout Standard
Conversion
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
Conversion
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
Example
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
Result
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
d , i
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
signed Integer
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%6d'%(12)
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
12'
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
f
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
floating point decimal
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%6.4f'%(2.0/3)
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
0.667
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
e
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
floating point exponential
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%6.2e'%(2.0/3)
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
6.67e-01
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
x
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
hexadecimal
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%x'%(16)
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
10
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
o
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
octal
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%o'%(8)
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
10
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
s
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
string
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%s'%('abcd')
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
abcd
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
0d
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
modified 'd'
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
'%05d'%(12)
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
00012
\end_layout
\end_inset
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Formatted Printing in Python
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
The following example shows some of the features available with formatted
printing.
\end_layout
\begin_layout Standard
\align left
\emph on
Example: format2.py
\end_layout
\begin_layout LyX-Code
a = 'justify as you like'
\end_layout
\begin_layout LyX-Code
print '%30s'%a # right justified
\end_layout
\begin_layout LyX-Code
print '%-30s'%a # minus sign for left justification
\end_layout
\begin_layout LyX-Code
for k in range(1,11): # A good looking table
\end_layout
\begin_layout LyX-Code
print '5 x %2d = %2d' %(k, k*5)
\end_layout
\begin_layout Standard
The output of
\emph on
format2.py
\emph default
is given below.
\end_layout
\begin_layout LyX-Code
justify as you like
\end_layout
\begin_layout LyX-Code
justify as you like
\end_layout
\begin_layout LyX-Code
5 x 1 = 5
\end_layout
\begin_layout LyX-Code
5 x 2 = 10
\end_layout
\begin_layout LyX-Code
5 x 3 = 15
\end_layout
\begin_layout LyX-Code
5 x 4 = 20
\end_layout
\begin_layout LyX-Code
5 x 5 = 25
\end_layout
\begin_layout LyX-Code
5 x 6 = 30
\end_layout
\begin_layout LyX-Code
5 x 7 = 35
\end_layout
\begin_layout LyX-Code
5 x 8 = 40
\end_layout
\begin_layout LyX-Code
5 x 9 = 45
\end_layout
\begin_layout LyX-Code
5 x 10 = 50
\end_layout
\begin_layout Section
Exception Handling
\end_layout
\begin_layout Standard
Errors detected during execution are called exceptions, like divide by zero.
If the program does not handle exceptions, the Python Interpreter reports
the exception and terminates the program.
We will demonstrate handling exceptions using
\shape italic
try
\shape default
and
\shape italic
except
\shape default
keywords, in the example except.py.
\end_layout
\begin_layout Standard
\align left
\emph on
Example: except.py
\end_layout
\begin_layout LyX-Code
x = input('Enter a number ')
\end_layout
\begin_layout LyX-Code
try:
\end_layout
\begin_layout LyX-Code
print 10.0/x
\end_layout
\begin_layout LyX-Code
except:
\end_layout
\begin_layout LyX-Code
print 'Division by zero not allowed'
\end_layout
\begin_layout Standard
If any exception occurs while running the code inside the try block, the
code inside the except block is executed.
The following program implements error checking on input using exceptions.
\end_layout
\begin_layout Standard
\align left
\emph on
Example: except2.py
\end_layout
\begin_layout LyX-Code
def get_number():
\end_layout
\begin_layout LyX-Code
while 1:
\end_layout
\begin_layout LyX-Code
try:
\end_layout
\begin_layout LyX-Code
a = raw_input('Enter a number ')
\end_layout
\begin_layout LyX-Code
x = atof(a)
\end_layout
\begin_layout LyX-Code
return x
\end_layout
\begin_layout LyX-Code
except:
\end_layout
\begin_layout LyX-Code
print 'Enter a valid number'
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print get_number()
\end_layout
\begin_layout Section
Turtle Graphics
\end_layout
\begin_layout Standard
Turtle Graphics have been noted by many psychologists and educators to be
a powerful aid in teaching geometry, spatial perception, logic skills,
computer programming, and art.
The language LOGO was specifically designed to introduce children to programmin
g, using turtle graphics.
An abstract drawing device, called the Turtle, is used to make programming
attractive for children by concentrating on doing turtle graphics.
It has been used with children as young as 3 and has a track record of
30 years of success in education.
\end_layout
\begin_layout Standard
We will use the Turtle module of Python to play with Turtle Graphics and
practice the logic required for writing computer programs.
Using this module, we will move a
\shape italic
Pen
\shape default
on a two dimensional screen to generate graphical patterns.
The Pen can be controlled using functions like forward(distance), backward(dist
ance), right(angle), left(angle) etc.
\begin_inset Foot
status collapsed
\begin_layout Standard
http://docs.python.org/library/turtle.html
\end_layout
\end_inset
.
Run the program turtle1.py to understand the functions.
This section is included only for those who want to practice programming
in a more interesting manner.
\end_layout
\begin_layout Standard
\align left
\emph on
Example turtle1.py
\end_layout
\begin_layout LyX-Code
from turtle import *
\end_layout
\begin_layout LyX-Code
a = Pen() # Creates a turtle in a window
\end_layout
\begin_layout LyX-Code
a.forward(50)
\end_layout
\begin_layout LyX-Code
a.left(45)
\end_layout
\begin_layout LyX-Code
a.backward(50)
\end_layout
\begin_layout LyX-Code
a.right(45)
\end_layout
\begin_layout LyX-Code
a.forward(50)
\end_layout
\begin_layout LyX-Code
a.circle(10)
\end_layout
\begin_layout LyX-Code
a.up()
\end_layout
\begin_layout LyX-Code
a.forward(50)
\end_layout
\begin_layout LyX-Code
a.down()
\end_layout
\begin_layout LyX-Code
a.color('red')
\end_layout
\begin_layout LyX-Code
a.right(90)
\end_layout
\begin_layout LyX-Code
a.forward(50)
\end_layout
\begin_layout LyX-Code
raw_input('Press Enter')
\end_layout
\begin_layout Standard
\align left
\emph on
Example turtle2.py
\end_layout
\begin_layout LyX-Code
from turtle import *
\end_layout
\begin_layout LyX-Code
a = Pen()
\end_layout
\begin_layout LyX-Code
for k in range(4):
\end_layout
\begin_layout LyX-Code
a.forward(50)
\end_layout
\begin_layout LyX-Code
a.left(90)
\end_layout
\begin_layout LyX-Code
a.circle(25)
\end_layout
\begin_layout LyX-Code
raw_input() # Wait for Key press
\end_layout
\begin_layout Standard
Outputs of the program turtle2.py and turtle3.py are shown in figure
\begin_inset LatexCommand ref
reference "fig:turtle2 and 3 outputs"
\end_inset
.
Try to write more programs like this to generate more complex patterns.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/turtle2.png
width 3cm
\end_inset
\begin_inset Graphics
filename pics/turtle3.png
width 3cm
\end_inset
\begin_inset Graphics
filename pics/turtle4.png
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of turtle2.py (b) turtle3.py (c) turtle4.py
\begin_inset LatexCommand label
name "fig:turtle2 and 3 outputs"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example turtle3.py
\end_layout
\begin_layout LyX-Code
from turtle import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def draw_rectangle():
\end_layout
\begin_layout LyX-Code
for k in range(4):
\end_layout
\begin_layout LyX-Code
a.forward(50)
\end_layout
\begin_layout LyX-Code
a.left(90)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
a = Pen()
\end_layout
\begin_layout LyX-Code
for k in range(36):
\end_layout
\begin_layout LyX-Code
draw_rectangle()
\end_layout
\begin_layout LyX-Code
a.left(10)
\end_layout
\begin_layout LyX-Code
raw_input()
\end_layout
\begin_layout Standard
The program turtle3.py creates a pattern by drwaing 36 squares, each drawn
tilted by
\begin_inset Formula $10^{\circ}$
\end_inset
from the previous one.
The program turtle4.py generates the fractal image as shown in figure
\begin_inset LatexCommand ref
reference "fig:turtle2 and 3 outputs"
\end_inset
(c).
\end_layout
\begin_layout Standard
\align left
\emph on
Example turtle4.py
\end_layout
\begin_layout LyX-Code
from turtle import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def f(length, depth):
\end_layout
\begin_layout LyX-Code
if depth == 0:
\end_layout
\begin_layout LyX-Code
forward(length)
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
f(length/3, depth-1)
\end_layout
\begin_layout LyX-Code
right(60)
\end_layout
\begin_layout LyX-Code
f(length/3, depth-1)
\end_layout
\begin_layout LyX-Code
left(120)
\end_layout
\begin_layout LyX-Code
f(length/3, depth-1)
\end_layout
\begin_layout LyX-Code
right(60)
\end_layout
\begin_layout LyX-Code
f(length/3, depth-1)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
f(500, 4)
\end_layout
\begin_layout LyX-Code
raw_input('Press any Key')
\end_layout
\begin_layout Section
Writing GUI Programs
\end_layout
\begin_layout Standard
Python has several modules that can be used for creating Graphical User
Interfaces.
The intention of this chapter is just to show the ease of making GUI in
Python and we have selected Tkinter
\begin_inset Foot
status collapsed
\begin_layout Standard
http://www.pythonware.com/library/an-introduction-to-tkinter.htm
\end_layout
\begin_layout Standard
http://infohost.nmt.edu/tcc/help/pubs/tkinter/
\end_layout
\begin_layout Standard
http://wiki.python.org/moin/TkInter
\end_layout
\end_inset
, one of the easiest to learn.
The GUI programs are event driven (movement of mouse, clicking a mouse
button, pressing and releasing a key on the keyboard etc.
are called events).
The execution sequence of the program is decided by the events, generated
mostly by the user.
For example, when the user clicks on a Button, the code associated with
that Button is executed.
GUI Programming is about creating Widgets like Button, Label, Canvas etc.
on the screen and executing selected functions in response to events.
After creating all the necessary widgets and displaying them on the screen,
the control is passed on to Tkinter by calling a function named
\shape italic
mainloop
\shape default
.
After that the program flow is decided by the events and associated callback
functions.
\end_layout
\begin_layout Standard
For writing GUI programs, the first step is to create a main graphics window
by calling the function Tk().
After that we create various Widgets and pack them inside the main window.
The example programs given below demonstrate the usage of some of the Tkinter
widgets.The program
\shape italic
tkmain.py
\shape default
is the smallest GUI program one can write using Tkinter.
The output of tkmain.py is shown in figure
\begin_inset LatexCommand ref
reference "fig:tkmain and tklabel outputs"
\end_inset
(a).
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/tkmain.png
width 4cm
\end_inset
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset Graphics
filename pics/tklabel.png
width 4cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Outputs of (a)tkmain.py (b)tklabel.py
\begin_inset LatexCommand label
name "fig:tkmain and tklabel outputs"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example tkmain.py
\end_layout
\begin_layout LyX-Code
from Tkinter import *
\end_layout
\begin_layout LyX-Code
root = Tk()
\end_layout
\begin_layout LyX-Code
root.mainloop()
\end_layout
\begin_layout Standard
\align left
\emph on
Example tklabel.py
\end_layout
\begin_layout LyX-Code
from Tkinter import *
\end_layout
\begin_layout LyX-Code
root = Tk()
\end_layout
\begin_layout LyX-Code
w = Label(root, text="Hello, world")
\end_layout
\begin_layout LyX-Code
w.pack()
\end_layout
\begin_layout LyX-Code
root.mainloop()
\end_layout
\begin_layout Standard
The program tklabel.py will generate the output as shown in figure
\begin_inset LatexCommand ref
reference "fig:tkmain and tklabel outputs"
\end_inset
(b).
Terminate the program by clicking on the x displayed at the top right corner.
In this example, we used a Label widget to display some text.
The next example will show how to use a Button widget.
\end_layout
\begin_layout Standard
A Button widget can have a callback function, hello() in this case, that
gets executed when the user clicks on the Button.
The program will display a Button on the screen.
Every time you click on it, the function
\shape italic
hello
\shape default
will be executed.
The output of the program is shown in figure
\begin_inset LatexCommand ref
reference "fig:tkbutton and canvas"
\end_inset
(a).
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/tkbutton.png
width 4cm
\end_inset
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset Graphics
filename pics/tkcanvas.png
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Outputs of (a) tkbutton.py (b)tkcanvas.py
\begin_inset LatexCommand label
name "fig:tkbutton and canvas"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example tkbutton.py
\end_layout
\begin_layout LyX-Code
from Tkinter import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def hello():
\end_layout
\begin_layout LyX-Code
print 'hello world'
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
w = Tk() # Creates the main Graphics window
\end_layout
\begin_layout LyX-Code
b = Button(w, text = 'Click Me', command = hello)
\end_layout
\begin_layout LyX-Code
b.pack()
\end_layout
\begin_layout LyX-Code
w.mainloop()
\end_layout
\begin_layout Standard
Canvas is another commonly used widget.
Canvas is a drawing area on which we can draw elements like line, arc,
rectangle, text etc.
The program tkcanvas.py creates a Canvas widget and binds the
event to the function draw().
When left mouse button is pressed, a small rectangle are drawn at the cursor
position.
The output of the program is shown in figure
\begin_inset LatexCommand ref
reference "fig:tkbutton and canvas"
\end_inset
(b).
\end_layout
\begin_layout Standard
\align left
\emph on
Example tkcanvas.py
\end_layout
\begin_layout LyX-Code
from Tkinter import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def draw(event):
\end_layout
\begin_layout LyX-Code
c.create_rectangle(event.x,
\backslash
\end_layout
\begin_layout LyX-Code
event.y, event.x+5, event.y+5)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
w = Tk()
\end_layout
\begin_layout LyX-Code
c = Canvas(w, width = 300, height = 200)
\end_layout
\begin_layout LyX-Code
c.pack()
\end_layout
\begin_layout LyX-Code
c.bind("", draw)
\end_layout
\begin_layout LyX-Code
w.mainloop()
\end_layout
\begin_layout Standard
The next program is a modification of tkcanvas.py.
The right mouse-button is bound to remove().
Every time a rectangle is drawn, its return value is added to a list, a
global variable, and this list is used for removing the rectangles when
right button is pressed.
\end_layout
\begin_layout Standard
\align left
\emph on
Example tkcanvas2.py
\end_layout
\begin_layout LyX-Code
from Tkinter import *
\end_layout
\begin_layout LyX-Code
recs = [] # List keeping track of the rectangles
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def remove(event):
\end_layout
\begin_layout LyX-Code
global recs
\end_layout
\begin_layout LyX-Code
if len(recs) > 0:
\end_layout
\begin_layout LyX-Code
c.delete(recs[0]) # delete from Canvas
\end_layout
\begin_layout LyX-Code
recs.pop(0) # delete first item from list
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def draw(event):
\end_layout
\begin_layout LyX-Code
global recs
\end_layout
\begin_layout LyX-Code
r = c.create_rectangle(event.x,
\backslash
\end_layout
\begin_layout LyX-Code
event.y, event.x+5, event.y+5)
\end_layout
\begin_layout LyX-Code
recs.append(r)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
w = Tk()
\end_layout
\begin_layout LyX-Code
c = Canvas(w, width = 300, height = 200)
\end_layout
\begin_layout LyX-Code
c.pack()
\end_layout
\begin_layout LyX-Code
c.bind("", draw)
\end_layout
\begin_layout LyX-Code
c.bind("", remove)
\end_layout
\begin_layout LyX-Code
w.mainloop()
\end_layout
\begin_layout Section
Object Oriented Programming in Python
\end_layout
\begin_layout Standard
OOP is a programming paradigm that uses
\emph on
objects
\emph default
(Structures consisting of variables and methods) and their interactions
to design computer programs.
Python is an object oriented language but it does not force you to make
all programs object oriented and there is no advantage in making small
programs object oriented.
In this section, we will discuss some features of OOP.
\end_layout
\begin_layout Standard
Before going to the new concepts, let us recollect some of the things we
have learned.
We have seen that the effect of operators on different data types is predefined.
For example
\begin_inset Formula $2*3$
\end_inset
results in
\begin_inset Formula $6$
\end_inset
and
\begin_inset Formula $2*'abc'$
\end_inset
results in
\begin_inset Formula $'abcabc'$
\end_inset
.
This behavior has been decided beforehand, based on some logic, by the
language designers.
One of the key features of OOP is the ability to create user defined data
types.
The user will specify, how the new data type will behave under the existing
operators like add, subtract etc.
and also define methods that will belong to the new data type.
\end_layout
\begin_layout Standard
We will design a new data type using the class keyword and define the behavior
of it.
In the program point.py, we define a class named Point.
The variables xpos and ypos are members of Point.
The __init__() function is executed whenever we create an instance of this
class, the member variables are initialized by this function.
The way in which an object belonging to this class is printed is decided
by the __str__ function.
We also have defined the behavior of add (+) and subtract (-) operators
for this class.
The + operator returns a new Point by adding the x and y coordinates of
two Points.
Subtracting a Point from another gives the distance between the two.
The method dist() returns the distance of a Point object from the origin.
We have not defined the behavior of Point under copy operation.
We can use the copy module of Python to copy objects.
\end_layout
\begin_layout Standard
\align left
\emph on
Example point.py
\end_layout
\begin_layout LyX-Code
class Point:
\end_layout
\begin_layout LyX-Code
'''
\end_layout
\begin_layout LyX-Code
This is documentation comment.
\end_layout
\begin_layout LyX-Code
help(Point) will display this.
\end_layout
\begin_layout LyX-Code
'''
\end_layout
\begin_layout LyX-Code
def __init__(self, x=0, y=0):
\end_layout
\begin_layout LyX-Code
self.xpos = x
\end_layout
\begin_layout LyX-Code
self.ypos = y
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def __str__(self): # overloads print
\end_layout
\begin_layout LyX-Code
return 'Point at (%f,%f)'%(self.xpos, self.ypos)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def __add__(self, other): #overloads +
\end_layout
\begin_layout LyX-Code
xpos = self.xpos + other.xpos
\end_layout
\begin_layout LyX-Code
ypos = self.ypos + other.ypos
\end_layout
\begin_layout LyX-Code
return Point(xpos,ypos)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def __sub__(self, other): #overloads -
\end_layout
\begin_layout LyX-Code
import math
\end_layout
\begin_layout LyX-Code
dx = self.xpos - other.xpos
\end_layout
\begin_layout LyX-Code
dy = self.ypos - other.ypos
\end_layout
\begin_layout LyX-Code
return math.sqrt(dx**2+dy**2)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def dist(self):
\end_layout
\begin_layout LyX-Code
import math
\end_layout
\begin_layout LyX-Code
return math.sqrt(self.xpos**2 + self.ypos**2)
\end_layout
\begin_layout Standard
The program point1.py imports the file point.py to use the class Point defined
inside it to demonstrate the properties of the class.
A self.
is prefixed when a method refers to member of the same object.
It refers to the variable used for invoking the method.
\end_layout
\begin_layout Standard
\align left
\emph on
Example point1.py
\end_layout
\begin_layout LyX-Code
from point import *
\end_layout
\begin_layout LyX-Code
origin = Point()
\end_layout
\begin_layout LyX-Code
print origin
\end_layout
\begin_layout LyX-Code
p1 = Point(4,4)
\end_layout
\begin_layout LyX-Code
p2 = Point(8,7)
\end_layout
\begin_layout LyX-Code
print p1
\end_layout
\begin_layout LyX-Code
print p2
\end_layout
\begin_layout LyX-Code
print p1 + p2
\end_layout
\begin_layout LyX-Code
print p1 - p2
\end_layout
\begin_layout LyX-Code
print p1.dist()
\end_layout
\begin_layout Standard
Output of program point1.py is shown below.
\end_layout
\begin_layout Quotation
Point at (0.000000,0.000000)
\end_layout
\begin_layout Quotation
Point at (4.000000,4.000000)
\end_layout
\begin_layout Quotation
Point at (8.000000,7.000000)
\end_layout
\begin_layout Quotation
Point at (12.000000,11.000000)
\end_layout
\begin_layout Quotation
5.0
\end_layout
\begin_layout Quotation
5.65685424949
\end_layout
\begin_layout Standard
In this section, we have demonstrated the OO concepts like class, object
and operator overloading.
\end_layout
\begin_layout Subsection
Inheritance, reusing code
\end_layout
\begin_layout Standard
\align left
Reuse of code is one of the main advantages of object oriented programming.
We can define another class that inherits all the properties of the Point
class, as shown below.
The __init__ function of colPoint calls the __init__ function of Point,
to get all work except initilization of color done.
All other methods and operator overloading defined for Point is inherited
by colPoint.
\end_layout
\begin_layout Standard
\align left
\emph on
Example cpoint.py
\end_layout
\begin_layout LyX-Code
class colPoint(Point): #colPoint inherits Point
\end_layout
\begin_layout LyX-Code
color = 'black'
\end_layout
\begin_layout LyX-Code
def __init__(self,x=0,y=0,col='black'):
\end_layout
\begin_layout LyX-Code
Point.__init__(self,x,y)
\end_layout
\begin_layout LyX-Code
self.color = col
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def __str__(self):
\end_layout
\begin_layout LyX-Code
return '%s colored Point at (%f,%f)'%
\backslash
\end_layout
\begin_layout LyX-Code
(self.color,self.xpos, self.ypos)
\end_layout
\begin_layout Standard
\align left
\emph on
Example point2.py
\end_layout
\begin_layout LyX-Code
from cpoint import *
\end_layout
\begin_layout LyX-Code
p1 = Point(5,5)
\end_layout
\begin_layout LyX-Code
rp1 = colPoint(2,2,'red')
\end_layout
\begin_layout LyX-Code
print p1
\end_layout
\begin_layout LyX-Code
print rp1
\end_layout
\begin_layout LyX-Code
print rp1 + p1
\end_layout
\begin_layout LyX-Code
print rp1.dist()
\end_layout
\begin_layout Standard
The output of point2.py is listed below.
\end_layout
\begin_layout Standard
Point at (5.000000,5.000000)
\end_layout
\begin_layout Standard
red colored Point at (2.000000,2.000000)
\end_layout
\begin_layout Standard
Point at (7.000000,7.000000)
\end_layout
\begin_layout Standard
2.82842712475
\end_layout
\begin_layout Standard
\align left
For a detailed explanation on the object oriented features of Python, refer
to chapters 13, 14 and 15 of the online book http://openbookproject.net//thinkCS
py/
\end_layout
\begin_layout Subsection
A graphics example program
\end_layout
\begin_layout Standard
Object Oriented programming allows us to write Classes with a well defined
external interface hiding all the internal details.
This example shows a Class named 'disp', for drawing curves, providing
the xy coordinates within an arbitrary range .
The the world-to-screen coordinate conversion is performed internally.
The method named line() accepts a list of xy coordinates.
The file
\shape italic
tkplot_class.py
\shape default
defines the 'disp' class and is listed below.
\end_layout
\begin_layout Standard
\align left
\emph on
Example tkplot_class.py
\end_layout
\begin_layout LyX-Code
from Tkinter import *
\end_layout
\begin_layout LyX-Code
from math import *
\end_layout
\begin_layout LyX-Code
class disp:
\end_layout
\begin_layout LyX-Code
def __init__(self, parent, width=400., height=200.):
\end_layout
\begin_layout LyX-Code
self.parent = parent
\end_layout
\begin_layout LyX-Code
self.SCX = width
\end_layout
\begin_layout LyX-Code
self.SCY = height
\end_layout
\begin_layout LyX-Code
self.border = 1
\end_layout
\begin_layout LyX-Code
self.canvas = Canvas(parent, width=width, height=height)
\end_layout
\begin_layout LyX-Code
self.canvas.pack(side = LEFT)
\end_layout
\begin_layout LyX-Code
self.setWorld(0 , 0, self.SCX, self.SCY) # scale factors
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def setWorld(self, x1, y1, x2, y2):
\end_layout
\begin_layout LyX-Code
self.xmin = float(x1)
\end_layout
\begin_layout LyX-Code
self.ymin = float(y1)
\end_layout
\begin_layout LyX-Code
self.xmax = float(x2)
\end_layout
\begin_layout LyX-Code
self.ymax = float(y2)
\end_layout
\begin_layout LyX-Code
self.xscale = (self.xmax - self.xmin) / (self.SCX)
\end_layout
\begin_layout LyX-Code
self.yscale = (self.ymax - self.ymin) / (self.SCY)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def w2s(self, p): #world-to-screen before plotting
\end_layout
\begin_layout LyX-Code
ip = []
\end_layout
\begin_layout LyX-Code
for xy in p:
\end_layout
\begin_layout LyX-Code
ix = self.border + int( (xy[0] - self.xmin) / self.xscale)
\end_layout
\begin_layout LyX-Code
iy = self.border + int( (xy[1] - self.ymin) / self.yscale)
\end_layout
\begin_layout LyX-Code
iy = self.SCY - iy
\end_layout
\begin_layout LyX-Code
ip.append((ix,iy))
\end_layout
\begin_layout LyX-Code
return ip
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def line(self, points, col='blue'):
\end_layout
\begin_layout LyX-Code
ip = self.w2s(points)
\end_layout
\begin_layout LyX-Code
t = self.canvas.create_line(ip, fill=col)
\end_layout
\begin_layout Standard
The program
\shape italic
tkplot.py
\shape default
imports tkplot_class.py and plots two graphs.
The advantage of code reuse is evident from this example.
\begin_inset Foot
status collapsed
\begin_layout Standard
A more sophisticated version of the
\shape italic
disp
\shape default
class program (draw.py) is included in the package 'learn-by-coding', available
on the CD.
\end_layout
\end_inset
.
Output of
\shape italic
tkplot.py
\shape default
is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-tkplot.py"
\end_inset
.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/tkplot.png
width 10cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of tkplot.py
\begin_inset LatexCommand label
name "fig:Output-of-tkplot.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example tkplot.py
\end_layout
\begin_layout LyX-Code
from tkplot_class import *
\end_layout
\begin_layout LyX-Code
from math import *
\end_layout
\begin_layout LyX-Code
w = Tk()
\end_layout
\begin_layout LyX-Code
gw1 = disp(w)
\end_layout
\begin_layout LyX-Code
xy = []
\end_layout
\begin_layout LyX-Code
for k in range(200):
\end_layout
\begin_layout LyX-Code
x = 2 * pi * k/200
\end_layout
\begin_layout LyX-Code
y = sin(x)
\end_layout
\begin_layout LyX-Code
xy.append((x,y))
\end_layout
\begin_layout LyX-Code
gw1.setWorld(0, -1.0, 2*pi, 1.0)
\end_layout
\begin_layout LyX-Code
gw1.line(xy)
\end_layout
\begin_layout LyX-Code
gw2 = disp(w)
\end_layout
\begin_layout LyX-Code
gw2.line([(10,10),(100,100),(350,50)], 'red')
\end_layout
\begin_layout LyX-Code
w.mainloop()
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Enumerate
Generate multiplication table of eight and write it to a file.
\end_layout
\begin_layout Enumerate
Make a list and write it to a file using the pickle module.
\end_layout
\begin_layout Enumerate
Write a Python program to open a file and write 'hello world' to it.
\end_layout
\begin_layout Enumerate
Write a Python program to open a text file and read all lines from it.
\end_layout
\begin_layout Enumerate
Write a program to generate the multiplication table of a number from the
user.
The output should be formatted as shown below
\newline
\InsetSpace ~
\InsetSpace ~
1 x 5 = \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
5
\newline
\InsetSpace ~
\InsetSpace ~
2 x 5 = \InsetSpace ~
10
\end_layout
\begin_layout Enumerate
Define the list [1,2,3,4,5,6] using the range function.
Write code to insert a 10 after 2, delete 4, add 0 at the end and sort
it in the ascending order.
\end_layout
\begin_layout Enumerate
Write Python code to generate the sequence of numbers
\newline
25 20 15 10 5
\newline
using
range function .
Delete 15 from the result and sort it.
Print it using a for loop.
\end_layout
\begin_layout Enumerate
Define a string
\shape italic
s = 'mary had a little lamb'.
\newline
\shape default
a) print it in reverse order
\newline
b) split it using space character as sepatator
\end_layout
\begin_layout Enumerate
Join the elements of the list ['I', 'am', 'in', 'pieces'] using + character.
Do the same using a for loop also.
\end_layout
\begin_layout Enumerate
Create a window with five buttons.
Make each button a different color.
Each button should have some text on it.
\end_layout
\begin_layout Enumerate
Create a program that will put words in alphabetical order.
The program should allow the user to enter as many words as he wants to.
\end_layout
\begin_layout Enumerate
Create a program that will check a sentence to see if it is a palindrome.
A palindrome is a sentence that reads the same backwards and forwards ('malayal
am').
\end_layout
\begin_layout Enumerate
A text file contains two columns of numbers.
Write a program to read them and print the sum of numbers in each row.
\end_layout
\begin_layout Enumerate
Read a String from the keyboard.
Multiply it by an integer to make its length more than 50.
How do you find out the smallest number that does the job.
\end_layout
\begin_layout Enumerate
Write a program to find the length of the hypotenuse of a right triangle
from the length of other two sides, get the input from the user.
\end_layout
\begin_layout Enumerate
Write a program displaying 2 labels and 2 buttons.
It should print two different messages when clicked on the two buttons.
\end_layout
\begin_layout Enumerate
Write a program with a Canvas and a circle drawn on it.
\end_layout
\begin_layout Enumerate
Write a program using for loop to reverse a string.
\end_layout
\begin_layout Enumerate
Write a Python function to calculate the GCD of two numbers
\end_layout
\begin_layout Enumerate
Write a program to print the values of sine function from
\begin_inset Formula $0$
\end_inset
to
\begin_inset Formula $2\pi$
\end_inset
with 0.1 increments.
Find the mean value of them.
\end_layout
\begin_layout Enumerate
Generate N random numbers using random.random() and find out howmay are below
0.5 .
Repeat the same for different values of N to draw some conclusions.
\end_layout
\begin_layout Enumerate
Use the equation
\begin_inset Formula $x=(-b\pm\sqrt{b^{2}-4ac})/2a$
\end_inset
to find the roots of
\begin_inset Formula $3x^{2}+6x+12=0$
\end_inset
\end_layout
\begin_layout Enumerate
Write a program to calculate the distance between points (x1,y1) and (x2,y2)
in a Cartesian plane.
Get the coordinates from the user.
\end_layout
\begin_layout Enumerate
Write a program to evaluate
\begin_inset Formula $y$
\end_inset
=
\begin_inset Formula $\sqrt{2.3a}+a^{2}+34.5$
\end_inset
for a = 1, 2 and 3.
\end_layout
\begin_layout Enumerate
Print Fibanocci numbers upto 100, without using multiple assignment statement.
\end_layout
\begin_layout Enumerate
Draw a chess board pattern using turtle graphics.
\end_layout
\begin_layout Enumerate
Find the syntax error in the following code and correct it.
\newline
x=1
\newline
while x <=
10:
\newline
print x * 5
\end_layout
\begin_layout Chapter
Arrays and Matrices
\begin_inset LatexCommand label
name "sec:Arrays-and-Matrices"
\end_inset
\end_layout
\begin_layout Standard
In the previous chapter, we have learned the essential features of Python
language.
We also used the
\shape italic
math
\shape default
module to calculate trigonometric functions.
Using the tools introduced so far, let us generate the data points to plot
a sine wave.
The program sine.py generates the coordinates to plot a sine wave.
\end_layout
\begin_layout Standard
\align left
\emph on
Example sine.py
\end_layout
\begin_layout LyX-Code
import math
\end_layout
\begin_layout LyX-Code
x = 0.0
\end_layout
\begin_layout LyX-Code
while x < 2 * math.pi:
\end_layout
\begin_layout LyX-Code
print x , math.sin(x)
\end_layout
\begin_layout LyX-Code
x = x + 0.1
\end_layout
\begin_layout Standard
The output to the screen can be redirected to a file as shown below, from
the command prompt.
You can plot the data using some program like xmgrace.
\end_layout
\begin_layout Standard
$ python sine.py > sine.dat
\end_layout
\begin_layout Standard
$ xmgrace sine.dat
\end_layout
\begin_layout Standard
It would be better if we could write such programs without using loops explicitl
y.
Serious scientific computing requires manipulating of large data structures
like matrices.
The
\shape italic
list
\shape default
data type of Python is very flexible but the performance is not acceptable
for large scale computing.
The need of special tools is evident even from the simple example shown
above.
\shape italic
NumPy
\shape default
is a package widely used for scientific computing with Python.
\begin_inset Foot
status collapsed
\begin_layout Standard
http://numpy.scipy.org/
\end_layout
\begin_layout Standard
http://www.scipy.org/Tentative_NumPy_Tutorial
\end_layout
\begin_layout Standard
http://www.scipy.org/Numpy_Functions_by_Category
\end_layout
\begin_layout Standard
http://www.scipy.org/Numpy_Example_List_With_Doc
\end_layout
\end_inset
\end_layout
\begin_layout Section
The NumPy Module
\end_layout
\begin_layout Standard
The
\shape italic
\color black
numpy
\shape default
\color inherit
module supports operations on compound data types like arrays and matrices.
\shape italic
\color black
First thing to learn is how to create arrays and matrices using the numpy
package.
\shape default
\color inherit
Python lists can be converted into multi-dimensional arrays.
There are several other functions that can be used for creating matrices.
The mathematical functions like sine, cosine etc.
of numpy accepts array objects as arguments and return the results as arrays
objects.
NumPy arrays can be indexed, sliced and copied like Python Lists.
\end_layout
\begin_layout Standard
In the examples below, we will import numpy functions as local (using the
syntax
\shape italic
from numpy import *
\shape default
).
Since it is the only package used there is no possibility of any function
name conflicts.
\end_layout
\begin_layout Standard
\align left
\emph on
Example numpy1.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
x = array( [1, 2, 3] ) # Make array from list
\end_layout
\begin_layout LyX-Code
print x , type(x)
\end_layout
\begin_layout Standard
In the above example, we have created an array from a list.
\end_layout
\begin_layout Subsection
Creating Arrays and Matrices
\end_layout
\begin_layout Standard
We can also make multi-dimensional arrays.
Remember that a member of a list can be another list.
The following example shows how to make a two dimensional array.
\end_layout
\begin_layout Standard
\align left
\emph on
Example numpy3.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = [ [1,2] , [3,4] ] # make a list of lists
\end_layout
\begin_layout LyX-Code
x = array(a) # and convert to an array
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout Standard
Other than than
\shape italic
array(),
\shape default
there are several other functions that can be used for creating different
types of arrays and matrices.
Some of them are described below.
\end_layout
\begin_layout Subsubsection
arange(start, stop, step, dtype = None)
\end_layout
\begin_layout Standard
Creates an evenly spaced one-dimensional array.
Start, stop, stepsize and datatype are the arguments.
If datatype is not given, it is deduced from the other arguments.
Note that, the values are generated within the interval, including start
but excluding stop.
\end_layout
\begin_layout Standard
arange(2.0, 3.0, .1) makes the array([ 2.
, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])
\end_layout
\begin_layout Subsubsection
linspace(start, stop, number of elements)
\end_layout
\begin_layout Standard
Similar to arange().
Start, stop and number of samples are the arguments.
\end_layout
\begin_layout Standard
linspace(1, 2, 11) is equivalent to array([ 1.
, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.
])
\end_layout
\begin_layout Subsubsection
zeros(shape, datatype)
\end_layout
\begin_layout Standard
Returns a new array of given shape and type, filled zeros.
The arguments are shape and datatype.
For example
\emph on
\color black
zeros( [3,2], 'float')
\emph default
\color inherit
generates a 3 x 2 array filled with zeros as shown below.
If not specified, the type of elements defaults to int.
\end_layout
\begin_layout Standard
\begin_inset Formula $\begin{array}{ccc}
0.0 & 0.0 & 0.0\\
0.0 & 0.0 & 0.0\end{array}$
\end_inset
\end_layout
\begin_layout Subsubsection
ones(shape, datatype)
\end_layout
\begin_layout Standard
Similar to zeros() except that the values are initialized to 1.
\end_layout
\begin_layout Subsubsection
random.random(shape)
\end_layout
\begin_layout Standard
Similar to the functions above, but the matrix is filled with random numbers
ranging from 0 to 1, of
\emph on
\color black
float
\emph default
\color inherit
type.
For example, random.random([3,3]) will generate the 3x3 matrix;
\end_layout
\begin_layout LyX-Code
array([[ 0.3759652 , 0.58443562, 0.41632997],
\end_layout
\begin_layout LyX-Code
[ 0.88497654, 0.79518478, 0.60402514],
\end_layout
\begin_layout LyX-Code
[ 0.65468458, 0.05818105, 0.55621826]])
\end_layout
\begin_layout Subsubsection
reshape(array, newshape)
\end_layout
\begin_layout Standard
We can also make multi-dimensions arrays by reshaping a one-dimensional
array.
The function
\shape italic
reshape()
\shape default
changes dimensions of an array.
The total number of elements must be preserved.
Working of
\shape italic
reshape()
\shape default
can be understood by looking at
\emph on
\color black
reshape.py
\emph default
\color inherit
and its result.
\end_layout
\begin_layout Standard
\align left
\emph on
Example reshape.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = arange(20)
\end_layout
\begin_layout LyX-Code
b = reshape(a, [4,5])
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout Standard
The result is shown below.
\end_layout
\begin_layout LyX-Code
array([[ 0, 1, 2, 3, 4],
\end_layout
\begin_layout LyX-Code
[ 5, 6, 7, 8, 9],
\end_layout
\begin_layout LyX-Code
[10, 11, 12, 13, 14],
\end_layout
\begin_layout LyX-Code
[15, 16, 17, 18, 19]])
\end_layout
\begin_layout Standard
The program
\shape italic
numpy2.py
\shape default
demonstrates most of the functions discussed so far.
\end_layout
\begin_layout Standard
\align left
\emph on
Example numpy2.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = arange(1.0, 2.0, 0.1)
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
b = linspace(1,2,11)
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout LyX-Code
c = ones(5,'float')
\end_layout
\begin_layout LyX-Code
print c
\end_layout
\begin_layout LyX-Code
d = zeros(5, 'int')
\end_layout
\begin_layout LyX-Code
print d
\end_layout
\begin_layout LyX-Code
e = random.rand(5)
\end_layout
\begin_layout LyX-Code
print e
\end_layout
\begin_layout Standard
Output of this program will look like;
\end_layout
\begin_layout Standard
[ 1.
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9]
\end_layout
\begin_layout Standard
[ 1.
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.
]
\end_layout
\begin_layout Standard
[ 1.
1.
1.
1.
1.]
\end_layout
\begin_layout Standard
[ 0.
0.
0.
0.
0.]
\end_layout
\begin_layout Standard
[ 0.89039193 0.55640332 0.38962117 0.17238343 0.01297415]
\end_layout
\begin_layout Subsection
Copying
\end_layout
\begin_layout Standard
Numpy arrays can be copied using the copy method, as shown below.
\end_layout
\begin_layout Standard
\align left
\emph on
Example array_copy.py
\end_layout
\begin_layout LyX-Code
from mumpy import *
\end_layout
\begin_layout LyX-Code
a = zeros(5)
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
b = a
\end_layout
\begin_layout LyX-Code
c = a.copy()
\end_layout
\begin_layout LyX-Code
c[0] = 10
\end_layout
\begin_layout LyX-Code
print a, c
\end_layout
\begin_layout LyX-Code
b[0] = 10
\end_layout
\begin_layout LyX-Code
print a,c
\end_layout
\begin_layout Standard
The output of the program is shown below.
The statement
\begin_inset Formula $b=a$
\end_inset
does not make a copy of a.
Modifying b affects a, but c is a separate entity.
\end_layout
\begin_layout Standard
[ 0.
0.
0.]
\end_layout
\begin_layout Standard
[ 0.
0.
0.] [ 10.
0.
0.]
\end_layout
\begin_layout Standard
[ 10.
0.
0.] [ 10.
0.
0.]
\end_layout
\begin_layout Subsection
Arithmetic Operations
\end_layout
\begin_layout Standard
Arithmetic operations performed on an array is carried out on all individual
elements.
Adding or multiplying an array object with a number will multiply all the
elements by that number.
However, adding or multiplying two arrays having identical shapes will
result in performing that operation with the corresponding elements.
To clarify the idea, have a look at
\emph on
\color black
aroper.py
\emph default
\color inherit
and its results.
\end_layout
\begin_layout Standard
\align left
\emph on
Example aroper.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = array([[2,3], [4,5]])
\end_layout
\begin_layout LyX-Code
b = array([[1,2], [3,0]])
\end_layout
\begin_layout LyX-Code
print a + b
\end_layout
\begin_layout LyX-Code
print a * b
\end_layout
\begin_layout Standard
The output will be as shown below
\end_layout
\begin_layout LyX-Code
array([[3, 5],
\end_layout
\begin_layout LyX-Code
[7, 5]])
\end_layout
\begin_layout LyX-Code
array([[ 2, 6],
\end_layout
\begin_layout LyX-Code
[12, 0]])
\end_layout
\begin_layout Standard
Modifying this program for more operations is left as an exercise to the
reader.
\end_layout
\begin_layout Subsection
cross product
\end_layout
\begin_layout Standard
Returns the cross product of two vectors, defined by
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
A\times B=\left|\begin{array}{clc}
i & j & k\\
A_{1} & A_{2} & A_{3}\\
B_{1} & B_{2} & B_{3}\end{array}\right|=i(A_{2}B_{3}-A_{3}B_{2})+j(A_{1}B_{3}-A_{3}B_{1})+k(A_{1}B_{2}-A_{2}B_{1})\label{eq:cross product}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
It can be evaluated using the function cross((array1, array2).
The program
\shape italic
cross.py
\shape default
prints [-3, 6, -3]
\end_layout
\begin_layout Standard
\align left
\emph on
Example cross.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = array([1,2,3])
\end_layout
\begin_layout LyX-Code
b = array([4,5,6])
\end_layout
\begin_layout LyX-Code
c = cross(a,b)
\end_layout
\begin_layout LyX-Code
print c
\end_layout
\begin_layout Subsection
dot product
\end_layout
\begin_layout Standard
Returns the dot product of two vectors defined by
\begin_inset Formula $A.B=A_{1}B_{1}+A_{2}B_{2}+A_{3}B_{3}$
\end_inset
.
If you change the fourth line of
\emph on
\color black
cross.py
\emph default
\color inherit
to
\begin_inset Formula $c=dot(a,b)$
\end_inset
, the result will be 32.
\end_layout
\begin_layout Subsection
Saving and Restoring
\end_layout
\begin_layout Standard
An array can be saved to text file using
\shape italic
array.tofile(filename)
\shape default
and it can be read back using
\shape italic
array=fromfile()
\shape default
methods, as shown by the code fileio.py
\end_layout
\begin_layout Standard
\align left
\emph on
Example fileio.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = arange(10)
\end_layout
\begin_layout LyX-Code
a.tofile('myfile.dat')
\end_layout
\begin_layout LyX-Code
b = fromfile('myfile.dat',dtype = 'int')
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout Standard
The function fromfile() sets dtype='float' by default.
In this case we have saved an integer array and need to specify that while
reading the file.
We could have saved it as float the the statement a.tofile('myfile.dat',
'float').
\end_layout
\begin_layout Subsection
Matrix inversion
\end_layout
\begin_layout Standard
The function
\shape italic
linalg.inv(matrix)
\shape default
computes the inverse of a square matrix, if it exists.
We can verify the result by multiplying the original matrix with the inverse.
Giving a singular matrix as the argument should normally result in an error
message.
In some cases, you may get a result whose elements are having very high
values, and it indicates an error.
\end_layout
\begin_layout Standard
\align left
\emph on
Example inv.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = array([ [4,1,-2], [2,-3,3], [-6,-2,1] ], dtype='float')
\end_layout
\begin_layout LyX-Code
ainv = linalg.inv(a)
\end_layout
\begin_layout LyX-Code
print ainv
\end_layout
\begin_layout LyX-Code
print dot(a,ainv)
\end_layout
\begin_layout Standard
Result of this program is printed below.
\end_layout
\begin_layout LyX-Code
[[ 0.08333333 0.08333333 -0.08333333]
\end_layout
\begin_layout LyX-Code
[-0.55555556 -0.22222222 -0.44444444]
\end_layout
\begin_layout LyX-Code
[-0.61111111 0.05555556 -0.38888889]]
\end_layout
\begin_layout LyX-Code
[[ 1.00000000e+00 -1.38777878e-17 0.00000000e+00]
\end_layout
\begin_layout LyX-Code
[-1.11022302e-16 1.00000000e+00 0.00000000e+00]
\end_layout
\begin_layout LyX-Code
[ 0.00000000e+00 2.08166817e-17 1.00000000e+00]]
\end_layout
\begin_layout Section
Vectorized Functions
\end_layout
\begin_layout Standard
The functions like sine, log etc.
from NumPy are capable of accepting arrays as arguments.
This eliminates the need of writing loops in our Python code.
\end_layout
\begin_layout Standard
\align left
\emph on
Example vfunc.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
a = array([1,10,100,1000])
\end_layout
\begin_layout LyX-Code
print log10(a)
\end_layout
\begin_layout Standard
The output of the program is [ 0.
1.
2.
3.] , where the log of each element is calculated and returned in an array.
This feature simplifies the programs a lot.
Numpy also provides a function to vectorize functions written by the user.
\end_layout
\begin_layout Standard
\align left
\emph on
Example vectorize.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def spf(x):
\end_layout
\begin_layout LyX-Code
return 3*x
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
vspf = vectorize(spf)
\end_layout
\begin_layout LyX-Code
a = array([1,2,3,4])
\end_layout
\begin_layout LyX-Code
print vspf(a)
\end_layout
\begin_layout Standard
The output will be [ 3 6 9 12] .
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Enumerate
Write code to make a one dimensional matrix with elements 5,10,15,20 and
25.
make another matrix by slicing the first three elements from it.
\end_layout
\begin_layout Enumerate
Create a
\begin_inset Formula $3\times2$
\end_inset
matrix and print the sum of its elements using for loops.
\end_layout
\begin_layout Enumerate
Create a
\begin_inset Formula $2\times3$
\end_inset
matrix and fill it with random numbers.
\end_layout
\begin_layout Enumerate
Use linspace to make an array from 0 to 10, with stepsize of 0.1
\end_layout
\begin_layout Enumerate
Use arange to make an 100 element array ranging from 0 to 10
\end_layout
\begin_layout Enumerate
Make an array a = [2,3,4,5] and copy it to
\shape italic
b
\shape default
.
change one element of
\shape italic
b
\shape default
and print both.
\end_layout
\begin_layout Enumerate
Make a 3x3 matrix and multipy it by 5.
\end_layout
\begin_layout Enumerate
Create two 3x3 matrices and add them.
\end_layout
\begin_layout Enumerate
Write programs to demonstrate the dot and cross products.
\end_layout
\begin_layout Enumerate
Using matrix inversion, solve the system of equations
\newline
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
4x1 − 2x2 + \InsetSpace ~
\InsetSpace ~
x3 = 11
\newline
−2x1
+ 4x2 − 2x3 = −16
\newline
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
x1 − 2x2 + 4x3 = 17
\end_layout
\begin_layout Enumerate
Find the new values of the coordinate (10,10) under a rotation by angle
\begin_inset Formula $\pi/4$
\end_inset
.
\end_layout
\begin_layout Enumerate
Write a vectorized function to evaluate
\begin_inset Formula $y=x^{2}$
\end_inset
and print the result for x=[1,2,3].
\end_layout
\begin_layout Chapter
Data visualization
\end_layout
\begin_layout Standard
A graph or chart is used to present numerical data in visual form.
A graph is one of the easiest ways to compare numbers.
They should be used to make facts clearer and more understandable.
Results of mathematical computations are often presented in graphical format.
In this chapter, we will explore the Python modules used for generating
two and three dimensional graphs of various types.
\end_layout
\begin_layout Section
The Matplotlib Module
\end_layout
\begin_layout Standard
Matplotlib is a python package that produces publication quality figures
in a variety of hardcopy formats.
It also provides many functions for matrix manipulation.
You can generate plots, histograms, power spectra, bar charts, error-charts,
scatter-plots, etc, with just a few lines of code and have full control
of line styles, font properties, axes properties, etc.
The data points to the plotting functions are supplied as Python lists
or Numpy arrays.
\end_layout
\begin_layout Standard
If you import matplotlib as
\emph on
\color black
pylab,
\emph default
\color inherit
the plotting functions from the submodules
\emph on
\color black
pyplot
\emph default
\color inherit
and matrix manipulation functions from the submodule
\emph on
\color black
mlab
\emph default
\color inherit
will be available as local functions.
Pylab also imports Numpy for you.
Let us start with some simple plots to become familiar with matplotlib.
\begin_inset Foot
status collapsed
\begin_layout Standard
http://matplotlib.sourceforge.net/
\end_layout
\begin_layout Standard
http://matplotlib.sourceforge.net/users/pyplot_tutorial.html
\end_layout
\begin_layout Standard
http://matplotlib.sourceforge.net/examples/index.html
\end_layout
\begin_layout Standard
http://matplotlib.sourceforge.net/api/axes_api.html
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example plot1.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
data = [1,2,5]
\end_layout
\begin_layout LyX-Code
plot(data)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
In the above example, the x-axis of the three points is taken from 0 to
2.
We can specify both the axes as shown below.
\end_layout
\begin_layout Standard
\align left
\emph on
Example plot2.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = [1,2,5]
\end_layout
\begin_layout LyX-Code
y = [4,5,6]
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
By default, the color is blue and the line style is continuous.
This can be changed by an optional argument after the coordinate data,
which is the format string that indicates the color and line type of the
plot.
The default format string is ‘b-‘ (blue, continuous line).
Let us rewrite the above example to plot using red circles.
We will also set the ranges for x and y axes and label them.
\end_layout
\begin_layout Standard
\align left
\emph on
Example plot3.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = [1,2,5]
\end_layout
\begin_layout LyX-Code
y = [4,5,6]
\end_layout
\begin_layout LyX-Code
plot(x,y,'ro')
\end_layout
\begin_layout LyX-Code
xlabel('x-axis')
\end_layout
\begin_layout LyX-Code
ylabel('y-axis')
\end_layout
\begin_layout LyX-Code
axis([0,6,1,7])
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/plot4.png
lyxscale 40
width 4cm
\end_inset
\begin_inset Graphics
filename pics/subplot1.png
lyxscale 40
width 4cm
\end_inset
\begin_inset Graphics
filename pics/piechart.png
lyxscale 40
width 4cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of (a) plot4.py (b) subplot1.py (c) piechart.py
\begin_inset LatexCommand label
name "fig:Output-of-plot4.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
The figure
\begin_inset LatexCommand ref
reference "fig:Output-of-plot4.py"
\end_inset
shows two different plots in the same window, using different markers and
colors.
\end_layout
\begin_layout Standard
\align left
\emph on
Example plot4.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
t = arange(0.0, 5.0, 0.2)
\end_layout
\begin_layout LyX-Code
plot(t, t**2,'x') #
\begin_inset Formula $t^{2}$
\end_inset
\end_layout
\begin_layout LyX-Code
plot(t, t**3,'ro') #
\begin_inset Formula $t^{3}$
\end_inset
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
We have just learned how to draw a simple plot using the pylab interface
of matplotlib.
\end_layout
\begin_layout Subsection
Multiple plots
\end_layout
\begin_layout Standard
Matplotlib allows you to have multiple plots in the same window, using the
subplot() command as shown in the example subplot1.py, whose output is shown
in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-plot4.py"
\end_inset
(b).
\end_layout
\begin_layout Standard
\align left
\emph on
Example subplot1.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
subplot(2,1,1) # the first subplot
\end_layout
\begin_layout LyX-Code
plot([1,2,3,4])
\end_layout
\begin_layout LyX-Code
subplot(2,1,2) # the second subplot
\end_layout
\begin_layout LyX-Code
plot([4,2,3,1])
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The arguments to subplot function are NR (number of rows) , NC (number of
columns) and a figure number, that ranges from 1 to
\begin_inset Formula $NR*NC$
\end_inset
.
The commas between the arguments are optional if
\begin_inset Formula $NR*NC<10$
\end_inset
, ie.
subplot(2,1,1) can be written as subplot(211).
\end_layout
\begin_layout Standard
Another example of subplot is given is
\shape italic
subplot2.py
\shape default
.
You can modify the variable NR and NC to watch the results.
Please note that the % character has different meanings.
In
\shape italic
(pn+1)%5
\shape default
, it is the reminder operator resulting in a number less than 5.
The % character also appears in the String formatting.
\end_layout
\begin_layout Standard
\align left
\emph on
Example subplot2.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
mark = ['x','o','^','+','>']
\end_layout
\begin_layout LyX-Code
NR = 2 # number of rows
\end_layout
\begin_layout LyX-Code
NC = 3 # number of columns
\end_layout
\begin_layout LyX-Code
pn = 1
\end_layout
\begin_layout LyX-Code
for row in range(NR):
\end_layout
\begin_layout LyX-Code
for col in range(NC):
\end_layout
\begin_layout LyX-Code
subplot(NR, NC, pn)
\end_layout
\begin_layout LyX-Code
a = rand(10) * pn
\end_layout
\begin_layout LyX-Code
plot(a, marker = mark[(pn+1)%5])
\end_layout
\begin_layout LyX-Code
xlabel('plot %d X'%pn)
\end_layout
\begin_layout LyX-Code
ylabel('plot %d Y'%pn)
\end_layout
\begin_layout LyX-Code
pn = pn + 1
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Polar plots
\end_layout
\begin_layout Standard
Polar coordinates locate a point on a plane with one distance and one angle.
The distance ‘r’ is measured from the origin.
The angle
\begin_inset Formula $\theta$
\end_inset
is measured from some agreed starting point.
Use the positive part of the
\begin_inset Formula $x-axis$
\end_inset
as the starting point for measuring angles.
Measure positive angles anti-clockwise from the positive
\begin_inset Formula $x-axis$
\end_inset
and negative angles clockwise from it.
\end_layout
\begin_layout Standard
Matplotlib supports polar plots, using the polar(
\begin_inset Formula $\theta,r$
\end_inset
) function.
Let us plot a circle using polar().
For every point on the circle, the value of
\begin_inset Formula $radius$
\end_inset
is the same but the polar angle
\begin_inset Formula $\theta$
\end_inset
changes from
\begin_inset Formula $0$
\end_inset
to
\begin_inset Formula $2\pi$
\end_inset
.
Both the coordinate arguments must be arrays of equal size.
Since
\begin_inset Formula $\theta$
\end_inset
is having 100 points ,
\begin_inset Formula $r$
\end_inset
also must have the same number.
This array can be generated using the
\begin_inset Formula $ones()$
\end_inset
function.
The axis([
\begin_inset Formula $\theta_{min},\theta_{max},r_{min},r_{max}$
\end_inset
) function can be used for setting the scale.
\end_layout
\begin_layout Standard
\align left
\emph on
Example polar.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
th = linspace(0,2*pi,100)
\end_layout
\begin_layout LyX-Code
r = 5 * ones(100) # radius = 5
\end_layout
\begin_layout LyX-Code
polar(th,r)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Pie Charts
\end_layout
\begin_layout Standard
An example of a pie chart is given below.
The percentage of different items and their names are given as arguments.
The output is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-plot4.py"
\end_inset
(c).
\end_layout
\begin_layout Standard
\align left
\emph on
Example piechart.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
\end_layout
\begin_layout LyX-Code
fracs = [25, 25, 30, 20]
\end_layout
\begin_layout LyX-Code
pie(fracs, labels=labels)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Plotting mathematical functions
\end_layout
\begin_layout Standard
One of our objectives is to understand different mathematical functions
better, by plotting them graphically.
We will use the
\shape italic
arange
\shape default
,
\shape italic
linspace
\shape default
and
\shape italic
logspace
\shape default
functions from
\shape italic
numpy
\shape default
to generate the input data and also the vectorized versions of the mathematical
functions.
For arange(), the third argument is the stepsize.
The total number of elements is calculated from start, stop and stepsize.
In the case of linspace(), we provide start, stop and the total number
of points.
The step size is calculated from these three parameters.
Please note that to create a data set ranging from 0 to 1 (including both)
with a stepsize of 0.1, we need to specify linspace(0,1,11) and not linspace(0,1
,10).
\end_layout
\begin_layout Subsection
Sine function and friends
\end_layout
\begin_layout Standard
Let the first example be the familiar sine function.
The input data is from
\begin_inset Formula $-\pi$
\end_inset
to
\begin_inset Formula $+\pi$
\end_inset
radians
\begin_inset Foot
status collapsed
\begin_layout Standard
Why do we need to give the angles in radians and not in degrees.
Angle in radian is the length of the arc defined by the given angle, with
unit radius.
Degree is just an arbitrary unit.
\end_layout
\end_inset
.
To make it a bit more interesting we are plotting
\begin_inset Formula $\sin x^{2}$
\end_inset
also.
The objective is to explain the concept of odd and even functions.
Mathematically, we say that a function
\begin_inset Formula $f(x)$
\end_inset
is even if
\begin_inset Formula $f(x)=f(-x)$
\end_inset
and is odd if
\begin_inset Formula $f(-x)=-f(x)$
\end_inset
.
Even functions are functions for which the left half of the plane looks
like the mirror image of the right half of the plane.
From the figure
\begin_inset LatexCommand ref
reference "fig:Sine and Circ"
\end_inset
(a) you can see that
\begin_inset Formula $\sin x$
\end_inset
is odd and
\begin_inset Formula $\sin x^{2}$
\end_inset
is even.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/npsin.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/circ.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
(a) Output of npsin.py (b) Output of circ.py
\begin_inset LatexCommand label
name "fig:Sine and Circ"
\end_inset
.
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example npsin.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = linspace(-pi, pi , 200)
\end_layout
\begin_layout LyX-Code
y = sin(x)
\end_layout
\begin_layout LyX-Code
y1 = sin(x*x)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
plot(x,y1,'r')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
Exercise: Modify the program
\emph on
\color black
npsin.py
\emph default
\color inherit
to plot
\begin_inset Formula $\sin^{2}x$
\end_inset
,
\begin_inset Formula $\cos x$
\end_inset
,
\begin_inset Formula $\sin x^{3}$
\end_inset
etc.
\end_layout
\begin_layout Subsection
Trouble with Circle
\end_layout
\begin_layout Standard
Equation of a circle is
\begin_inset Formula $x^{2}+y^{2}=a^{2}$
\end_inset
, where a is the radius and the circle is located at the origin of the
coordinate system.
In order to plot it using Cartesian coordinates, we need to express
\begin_inset Formula $y$
\end_inset
in terms of
\begin_inset Formula $x$
\end_inset
, and is given by
\begin_inset Formula \[
y=\sqrt{a^{2}-x^{2}}\]
\end_inset
\end_layout
\begin_layout Standard
We will create the x-coordinates ranging from
\begin_inset Formula $-a$
\end_inset
to
\begin_inset Formula $+a$
\end_inset
and calculate the corresponding values of y.
This will give us only half of the circle, since for each value of x, there
are two values of y (+y and -y).
The following program
\emph on
\color black
circ.py
\emph default
\color inherit
creates both to make the complete circle as shown in figure
\begin_inset LatexCommand ref
reference "fig:Sine and Circ"
\end_inset
(b).
Any multi-valued function will have this problem while plotting.
Such functions can be plotted better using parametric equations or using
the polar plot options, as explained in the coming sections.
\end_layout
\begin_layout Standard
\align left
\emph on
Example circ.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 10.0
\end_layout
\begin_layout LyX-Code
x = linspace(-a, a , 200)
\end_layout
\begin_layout LyX-Code
yupper = sqrt(a**2 - x**2)
\end_layout
\begin_layout LyX-Code
ylower = -sqrt(a**2 - x**2)
\end_layout
\begin_layout LyX-Code
plot(x,yupper)
\end_layout
\begin_layout LyX-Code
plot(x,ylower)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Parametric plots
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/circpar.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/arcs.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
(a)Output of circpar.py.
(b)Output of arcs.py
\begin_inset LatexCommand label
name "fig:(a)Circpar and Arc"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
The circle can be represented using the equations
\begin_inset Formula $x=a\cos\theta$
\end_inset
and
\begin_inset Formula $y=a\sin\theta$
\end_inset
.
To get the complete circle
\begin_inset Formula $\theta$
\end_inset
should vary from zero to
\begin_inset Formula $2\pi$
\end_inset
radians.
The output of circpar.py is shown in figure
\begin_inset LatexCommand ref
reference "fig:(a)Circpar and Arc"
\end_inset
(a).
\end_layout
\begin_layout Standard
\align left
\emph on
Example circpar.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 10.0
\end_layout
\begin_layout LyX-Code
th = linspace(0, 2*pi, 200)
\end_layout
\begin_layout LyX-Code
x = a * cos(th)
\end_layout
\begin_layout LyX-Code
y = a * sin(th)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
Changing the range of
\begin_inset Formula $\theta$
\end_inset
to less than
\begin_inset Formula $2\pi$
\end_inset
radians will result in an arc.
The following example plots several arcs with different radii.
The
\emph on
\color black
for
\emph default
\color inherit
loop will execute four times with the values of radius 5,10,15 and 20.
The range of
\begin_inset Formula $\theta$
\end_inset
also depends on the loop variable.
For the next three values it will be
\begin_inset Formula $\pi,1.5\pi and2\pi$
\end_inset
respectively.
The output is shown in figure
\begin_inset LatexCommand ref
reference "fig:(a)Circpar and Arc"
\end_inset
(b).
\end_layout
\begin_layout Standard
\align left
\emph on
Example arcs.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 10.0
\end_layout
\begin_layout LyX-Code
for a in range(5,21,5):
\end_layout
\begin_layout LyX-Code
th = linspace(0, pi * a/10, 200)
\end_layout
\begin_layout LyX-Code
x = a * cos(th)
\end_layout
\begin_layout LyX-Code
y = a * sin(th)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Famous Curves
\end_layout
\begin_layout Standard
Connection between different branches of mathematics like trigonometry,
algebra and geometry can be understood by geometrically representing the
equations.
You will find a large number of equations generating geometric patterns
having interesting symmetries.
A collection of them is available on the Internet
\begin_inset LatexCommand cite
key "wikipedia"
\end_inset
\begin_inset LatexCommand cite
key "gap-system"
\end_inset
.
We will select some of them and plot here.
Exploring them further is left as an exercise to the reader.
\end_layout
\begin_layout Subsection
Astroid
\end_layout
\begin_layout Standard
The astroid was first discussed by Johann Bernoulli in 1691-92.
It also appears in Leibniz's correspondence of 1715.
It is sometimes called the tetracuspid for the obvious reason that it has
four cusps.
A circle of radius 1/4 rolls around inside a circle of radius 1 and a point
on its circumference traces an astroid.
The Cartesian equation is
\begin_inset Formula \begin{equation}
x^{\frac{2}{3}}+y^{\frac{2}{3}}=a^{\frac{2}{3}}\label{eq:Astroid-cart}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The parametric equations are
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
x=a\cos^{3}(t),y=a\sin^{3}(t)\label{eq:Astroid-Par}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
In order to plot the curve in the Cartesian system, we rewrite equation
\begin_inset LatexCommand ref
reference "eq:Astroid-cart"
\end_inset
as
\end_layout
\begin_layout Standard
\begin_inset Formula \[
y=(a^{\frac{2}{3}}-x^{\frac{2}{3}})^{\frac{3}{2}}\]
\end_inset
\end_layout
\begin_layout Standard
The program
\emph on
\color black
astro.py
\emph default
\color inherit
plots the part of the curve in the first quadrant.
The program
\emph on
\color black
astropar.py
\emph default
\color inherit
uses the parametric equation and plots the complete curve.
Both are shown in figure
\begin_inset LatexCommand ref
reference "fig:(a)Astro.py"
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example astro.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 2
\end_layout
\begin_layout LyX-Code
x = linspace(0,a,100)
\end_layout
\begin_layout LyX-Code
y = ( a**(2.0/3) - x**(2.0/3) )**(3.0/2)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\align left
\emph on
Example astropar.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 2
\end_layout
\begin_layout LyX-Code
t = linspace(-2*a,2*a,101)
\end_layout
\begin_layout LyX-Code
x = a * cos(t)**3
\end_layout
\begin_layout LyX-Code
y = a * sin(t)**3
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Ellipse
\end_layout
\begin_layout Standard
The ellipse was first studied by Menaechmus
\begin_inset LatexCommand cite
key "ellipse"
\end_inset
.
Euclid wrote about the ellipse and it was given its present name by Apollonius.
The focus and directrix of an ellipse were considered by Pappus.
Kepler, in 1602, said he believed that the orbit of Mars was oval, then
he later discovered that it was an ellipse with the sun at one focus.
In fact Kepler introduced the word
\emph on
\color black
focus
\emph default
\color inherit
and published his discovery in 1609.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/astro.png
lyxscale 30
width 4cm
\end_inset
\begin_inset Graphics
filename pics/astropar.png
lyxscale 40
width 4cm
\end_inset
\begin_inset Graphics
filename pics/lissa.png
lyxscale 40
width 4cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
(a)Output of astro.py (b) astropar.py (c) lissa.py
\begin_inset LatexCommand label
name "fig:(a)Astro.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
The Cartesian equation is
\begin_inset Formula \begin{equation}
\frac{x^{2}}{a^{2}}+\frac{y^{2}}{b^{2}}=1\label{eq:Ellipse-cart}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The parametric equations are
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
x=a\cos(t),y=b\sin(t)\label{eq:Ellipse-Par}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The program
\emph on
\color black
ellipse.py
\emph default
\color inherit
uses the parametric equation to plot the curve.
Modifying the parametric equations will result in Lissajous figures.
The output of lissa.py are shown in figure
\begin_inset LatexCommand ref
reference "fig:(a)Astro.py"
\end_inset
(c).
\end_layout
\begin_layout Standard
\align left
\emph on
Example ellipse.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 2
\end_layout
\begin_layout LyX-Code
b = 3
\end_layout
\begin_layout LyX-Code
t = linspace(0, 2 * pi, 100)
\end_layout
\begin_layout LyX-Code
x = a * sin(t)
\end_layout
\begin_layout LyX-Code
y = b * cos(t)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\align left
\emph on
Example lissa.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 2
\end_layout
\begin_layout LyX-Code
b = 3
\end_layout
\begin_layout LyX-Code
t= linspace(0, 2*pi,100)
\end_layout
\begin_layout LyX-Code
x = a * sin(2*t)
\end_layout
\begin_layout LyX-Code
y = b * cos(t)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
x = a * sin(3*t)
\end_layout
\begin_layout LyX-Code
y = b * cos(2*t)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The Lissajous curves are closed if the ratio of the arguments for sine and
cosine functions is an integer.
Otherwise open curves will result, both are shown in figure
\begin_inset LatexCommand ref
reference "fig:(a)Astro.py"
\end_inset
(c).
\end_layout
\begin_layout Subsection
Spirals of Archimedes and Fermat
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/archi.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/fermat.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
(a)Archimedes Spiral (b)Fermat's Spiral (c)Polar Rose
\begin_inset LatexCommand label
name "fig:(a)Archimedes-Fermat"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
The spiral of Archimedes is represented by the equation
\begin_inset Formula $r=a\theta$
\end_inset
.
Fermat's Spiral is given by
\begin_inset Formula $r^{2}=a^{2}\theta$
\end_inset
.
The output of archi.py and fermat.py are shown in figure
\begin_inset LatexCommand ref
reference "fig:(a)Archimedes-Fermat"
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\emph on
Example archi.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 2
\end_layout
\begin_layout LyX-Code
th= linspace(0, 10*pi,200)
\end_layout
\begin_layout LyX-Code
r = a*th
\end_layout
\begin_layout LyX-Code
polar(th,r)
\end_layout
\begin_layout LyX-Code
axis([0, 2*pi, 0, 70])
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\align left
\emph on
Example fermat.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = 2
\end_layout
\begin_layout LyX-Code
th= linspace(0, 10*pi,200)
\end_layout
\begin_layout LyX-Code
r = sqrt(a**2 * th)
\end_layout
\begin_layout LyX-Code
polar(th,r)
\end_layout
\begin_layout LyX-Code
polar(th, -r)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Polar Rose
\end_layout
\begin_layout Standard
A rose or rhodonea curve is a sinusoid
\begin_inset Formula $r=\cos(k\theta)$
\end_inset
plotted in polar coordinates.
If k is an even integer, the curve will have
\begin_inset Formula $2k$
\end_inset
petals and
\begin_inset Formula $k$
\end_inset
petals if it is odd.
If k is rational, then the curve is closed and has finite length.
If k is irrational, then it is not closed and has infinite length.
\end_layout
\begin_layout Standard
\align left
\emph on
Example rose.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
k = 4
\end_layout
\begin_layout LyX-Code
th = linspace(0, 10*pi,1000)
\end_layout
\begin_layout LyX-Code
r = cos(k*th)
\end_layout
\begin_layout LyX-Code
polar(th,r)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
There are dozens of other famous curves whose details are available on the
Internet.
It may be an interesting exercise for the reader.
For more details refer to
\begin_inset LatexCommand cite
key "gap-system,wikipedia,wolfram"
\end_inset
on the Internet.
\end_layout
\begin_layout Section
Power Series
\begin_inset LatexCommand label
name "sec:Power-Series"
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/series_sin.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/rose.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Outputs of (a)series_sin.py (b) rose.py
\begin_inset LatexCommand label
name "fig:Functions-Series"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
Trigonometric functions like sine and cosine sounds very familiar to all
of us, due to our interaction with them since high school days.
However most of us would find it difficult to obtain the numerical values
of , say
\begin_inset Formula $\sin5^{0}$
\end_inset
, without trigonometric tables or a calculator.
We know that differentiating a sine function twice will give you the original
function, with a sign reversal, which implies
\end_layout
\begin_layout Standard
\begin_inset Formula \[
\frac{d^{2}y}{dx^{2}}+y=0\]
\end_inset
\end_layout
\begin_layout Standard
which has a series solution of the form
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
y=a_{0}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n}}{(2n)!}+a_{1}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n+1}}{(2n+1)!}\label{eq:Trig Series}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
These are the Maclaurin series for sine and cosine functions.
The following code plots several terms of the sine series and their sum.
\end_layout
\begin_layout Standard
\align left
\emph on
Example series_sin.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from scipy import factorial
\end_layout
\begin_layout LyX-Code
x = linspace(-pi, pi, 50)
\end_layout
\begin_layout LyX-Code
y = zeros(50)
\end_layout
\begin_layout LyX-Code
for n in range(5):
\end_layout
\begin_layout LyX-Code
term = (-1)**(n) * (x**(2*n+1)) / factorial(2*n+1)
\end_layout
\begin_layout LyX-Code
y = y + term
\end_layout
\begin_layout LyX-Code
#plot(x,term) #uncomment to see each term
\end_layout
\begin_layout LyX-Code
plot(x, y, '+b')
\end_layout
\begin_layout LyX-Code
plot(x, sin(x),'r') # compare with the real one
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The output of
\emph on
\color black
series_sin.py
\emph default
\color inherit
is shown in figure
\begin_inset LatexCommand ref
reference "fig:Functions-Series"
\end_inset
(a).
For comparison the
\begin_inset Formula $\sin$
\end_inset
function from the library is plotted.
The values calculated by using the series becomes closer to the actual
value with more and more number of terms.
The error can be obtained by adding the following lines to
\emph on
series_sin.py
\emph default
and the effect of number of terms on the error can be studied.
\end_layout
\begin_layout LyX-Code
err = y - sin(x)
\end_layout
\begin_layout LyX-Code
plot(x,err)
\end_layout
\begin_layout LyX-Code
for k in err:
\end_layout
\begin_layout LyX-Code
print k
\end_layout
\begin_layout Section
Fourier Series
\end_layout
\begin_layout Standard
A Fourier series is an expansion of a periodic function
\begin_inset Formula $f(x)$
\end_inset
in terms of an infinite sum of sines and cosines.
The computation and study of Fourier series is known as harmonic analysis
and is extremely useful as a way to break up an arbitrary periodic function
into a set of simple terms that can be plugged in, solved individually,
and then recombined to obtain the solution to the original problem or an
approximation to it to whatever accuracy is desired or practical.
\end_layout
\begin_layout Standard
The examples below shows how to generate a square wave and sawtooth wave
using this technique.
To make the output better, increase the number of terms by changing the
argument of the range() function, used in the for loop.
The output of the programs are shown in figure
\begin_inset LatexCommand ref
reference "fig:Square-and-Sawtooth"
\end_inset
.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/sawtooth.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/square.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Sawtooth and Square waveforms generated using Fourier series
\begin_inset LatexCommand label
name "fig:Square-and-Sawtooth"
\end_inset
.
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example fourier_square.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
N = 100 # number of points
\end_layout
\begin_layout LyX-Code
x = linspace(0.0, 2 * pi, N)
\end_layout
\begin_layout LyX-Code
y = zeros(N)
\end_layout
\begin_layout LyX-Code
for n in range(5):
\end_layout
\begin_layout LyX-Code
term = sin((2*n+1)*x) / (2*n+1)
\end_layout
\begin_layout LyX-Code
y = y + term
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\align left
\emph on
Example fourier_sawtooth.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
N = 100 # number of points
\end_layout
\begin_layout LyX-Code
x = linspace(-pi, pi, N)
\end_layout
\begin_layout LyX-Code
y = zeros(N)
\end_layout
\begin_layout LyX-Code
for n in range(1,10):
\end_layout
\begin_layout LyX-Code
term = (-1)**(n+1) * sin(n*x) / n
\end_layout
\begin_layout LyX-Code
y = y + term
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
2D plot using colors
\end_layout
\begin_layout Standard
A two dimensional matrix can be represented graphically by assigning a color
to each point proportional to the value of that element.
The program imshow1.py makes a
\begin_inset Formula $50\times50$
\end_inset
matrix filled with random numbers and uses
\shape italic
imshow()
\shape default
to plot it.
The result is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-imshow1.py"
\end_inset
(a).
\end_layout
\begin_layout Standard
\align left
\emph on
Example imshow1.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
m = random([50,50])
\end_layout
\begin_layout LyX-Code
imshow(m)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/imshow.png
lyxscale 70
width 4cm
\end_inset
\begin_inset Graphics
filename pics/julia.png
lyxscale 40
width 4cm
\end_inset
\begin_inset Graphics
filename pics/mgrid2.png
lyxscale 70
width 4cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Outputs of (a) imshow1.py (b) julia.py (c) mgrid2.py
\begin_inset LatexCommand label
name "fig:Output-of-imshow1.py"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Section
Fractals
\end_layout
\begin_layout Standard
Fractals
\begin_inset Foot
status collapsed
\begin_layout Standard
http://en.wikipedia.org/wiki/Fractal
\end_layout
\end_inset
are a part of fractal geometry, which is a branch of mathematics concerned
with irregular patterns made of parts that are in some way similar to the
whole (e.g.: twigs and tree branches).
A fractal is a design of infinite details.
It is created using a mathematical formula.
No matter how closely you look at a fractal, it never loses its detail.
It is infinitely detailed, yet it can be contained in a finite space.
Fractals are generally self-similar and independent of scale.
The theory of fractals was developed from Benoit Mandelbrot's study of
complexity and chaos.
Complex numbers are required to compute the Mandelbrot and Julia Set fractals
and it is assumed that the reader is familiar with the basics of complex
numbers.
\end_layout
\begin_layout Standard
To compute the basic Mandelbrot (or Julia) set one uses the equation
\begin_inset Formula $f(z)\rightarrow z^{2}+c$
\end_inset
, where both z and c are complex numbers.
The function is evaluated in an iterative manner, ie.
the result is assigned to
\begin_inset Formula $z$
\end_inset
and the process is repeated.
The purpose of the iteration is to determine the behavior of the values
that are put into the function.
If the value of the function goes to infinity (practically to some fixed
value, like 1 or 2) after few iterations for a particular value of
\begin_inset Formula $z$
\end_inset
, that point is considered to be outside the Set.
A Julia set can be defined as the set of all the complex numbers
\begin_inset Formula $(z)$
\end_inset
such that the iteration of
\begin_inset Formula $f(z)\rightarrow z^{2}+c$
\end_inset
is bounded for a particular value of c.
\end_layout
\begin_layout Standard
To generate the fractal the number of iterations required to diverge is
calculated for a set of points in the selected region in the complex plane.
The number of iterations taken for diverging decides the color of each
point.
The points that did not diverge, belonging to the set, are plotted with
the same color.
The program
\emph on
julia.py
\emph default
generates a fractal using a julia set.
The program creates a 2D array (200 x 200 elements).
For our calculations, this array represents a rectangular region on the
complex plane centered at the origin whose lower left corner is (-1,-j)
and the upper right corner is (1+j).
For 200x200 equidistant points in this plane the number of iterations are
calculated and that value is given to the corresponding element of the
2D matrix.
The plotting is taken care by the imshow function.
The output is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-imshow1.py"
\end_inset
(b).
Change the value of
\begin_inset Formula $c$
\end_inset
and run the program to generate more patterns.
The equation also may be changed.
\end_layout
\begin_layout Standard
\align left
\emph on
Example julia.py
\end_layout
\begin_layout LyX-Code
'''
\end_layout
\begin_layout LyX-Code
Region of a complex plane ranging from -1 to +1 in both real
\end_layout
\begin_layout LyX-Code
and imaginary axes is represented using a 2D matrix
\end_layout
\begin_layout LyX-Code
having X x Y elements.For X and Y equal to 200,the stepsize
\end_layout
\begin_layout LyX-Code
in the complex plane is 2.0/200 = 0.01.
\end_layout
\begin_layout LyX-Code
The nature of the pattern depends much on the value of c.
\end_layout
\begin_layout LyX-Code
'''
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
X = 200
\end_layout
\begin_layout LyX-Code
Y = 200
\end_layout
\begin_layout LyX-Code
MAXIT = 100
\end_layout
\begin_layout LyX-Code
MAXABS = 2.0
\end_layout
\begin_layout LyX-Code
c = 0.02 - 0.8j # The constant in equation z**2 + c
\end_layout
\begin_layout LyX-Code
m = zeros([X,Y]) # A two dimensional array
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def numit(x,y): # number of iterations to diverge
\end_layout
\begin_layout LyX-Code
z = complex(x,y)
\end_layout
\begin_layout LyX-Code
for k in range(MAXIT):
\end_layout
\begin_layout LyX-Code
if abs(z) <= MAXABS:
\end_layout
\begin_layout LyX-Code
z = z**2 + c
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
return k # diverged after k trials
\end_layout
\begin_layout LyX-Code
return MAXIT # did not diverge,
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
for x in range(X):
\end_layout
\begin_layout LyX-Code
for y in range(Y):
\end_layout
\begin_layout LyX-Code
re = 0.01 * x - 1.0 # complex number for
\end_layout
\begin_layout LyX-Code
im = 0.01 * y - 1.0 # this (x,y) coordinate
\end_layout
\begin_layout LyX-Code
m[x][y] = numit(re,im) # get the color for (x,y)
\end_layout
\begin_layout LyX-Code
imshow(m) # Colored plot using the 2D matrix
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Meshgrids
\end_layout
\begin_layout Standard
in order to make contour and 3D plots, we need to understand the meshgrid.
Consider a rectangular area on the X-Y plane.
Assume there are m divisions in the X direction and n divisions in the
Y direction.
We now have a
\begin_inset Formula $m\times n$
\end_inset
mesh.
A meshgrid is the coordinates of a grid in a 2D plane, x coordinates of
each mesh point is held in one matrix and y coordinates are held in another.
\end_layout
\begin_layout Standard
The NumPy function meshgrid() creates two 2x2 matrices from two 1D arrays,
as shown in the example below.
This can be used for plotting surfaces and contours, by assigning a Z coordinat
e to every mesh point.
\end_layout
\begin_layout Standard
\align left
\emph on
Example mgrid1.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
x = arange(0, 3, 1)
\end_layout
\begin_layout LyX-Code
y = arange(0, 3, 1)
\end_layout
\begin_layout LyX-Code
gx, gy = meshgrid(x, y)
\end_layout
\begin_layout LyX-Code
print gx
\end_layout
\begin_layout LyX-Code
print gy
\end_layout
\begin_layout Standard
\align block
The outputs are as shown below, gx(i,j) contains the x-coordinate and gx(i,j)
contains the y-coordinate of the point (i,j).
\end_layout
\begin_layout Standard
[[0 1 2]
\end_layout
\begin_layout Standard
[0 1 2]
\end_layout
\begin_layout Standard
[0 1 2]]
\end_layout
\begin_layout Standard
[[0 0 0]
\end_layout
\begin_layout Standard
[1 1 1]
\end_layout
\begin_layout Standard
[2 2 2]]
\end_layout
\begin_layout Standard
\align block
We can evaluate a function at all points of the meshgrid by passing the
meshgrid as an argument.
The program mgrid2.py plots the sum of sines of the x and y coordinates,
using imshow to get a result as shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-imshow1.py"
\end_inset
(c).
\end_layout
\begin_layout Standard
\align left
\emph on
Example mgrid2.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = arange(-3*pi, 3*pi, 0.1)
\end_layout
\begin_layout LyX-Code
y = arange(-3*pi, 3*pi, 0.1)
\end_layout
\begin_layout LyX-Code
xx, yy = meshgrid(x, y)
\end_layout
\begin_layout LyX-Code
z = sin(xx) + sin(yy)
\end_layout
\begin_layout LyX-Code
imshow(z)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
3D Plots
\end_layout
\begin_layout Standard
Matplotlib supports several types of 3D plots, using the Axes3D class.
The following three lines of code are required in every program making
3D plots using matplotlib.
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout
\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout
\begin_layout Subsection
Surface Plots
\end_layout
\begin_layout Standard
The example mgrid2.py is re-written to make a surface plot using the same
equation in surface3d.py and the result is shown in figure
\begin_inset LatexCommand ref
reference "fig:Suface3d and Line3d"
\end_inset
(a).
\end_layout
\begin_layout Standard
\align left
\emph on
Example sufrace3d.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout
\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout
\begin_layout LyX-Code
x = arange(-3*pi, 3*pi, 0.1)
\end_layout
\begin_layout LyX-Code
y = arange(-3*pi, 3*pi, 0.1)
\end_layout
\begin_layout LyX-Code
xx, yy = meshgrid(x, y)
\end_layout
\begin_layout LyX-Code
z = sin(xx) + sin(yy)
\end_layout
\begin_layout LyX-Code
ax.plot_surface(xx, yy, z, cmap=cm.jet, cstride=1)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/surface3d.png
width 5cm
\end_inset
\begin_inset Graphics
filename pics/line3d.png
width 5cm
\end_inset
\end_layout
\begin_layout Standard
Output of (a)surface3d.py (b)line3d.py
\begin_inset LatexCommand label
name "fig:Suface3d and Line3d"
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Subsection
Line Plots
\end_layout
\begin_layout Standard
Example of a line plot is shown in line3d.py along with the output in figure
\begin_inset LatexCommand ref
reference "fig:Suface3d and Line3d"
\end_inset
(b).
\end_layout
\begin_layout Standard
\align left
\emph on
Example line3d.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout
\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
phi = linspace(0, 2*pi, 400)
\end_layout
\begin_layout LyX-Code
x = cos(phi)
\end_layout
\begin_layout LyX-Code
y = sin(phi)
\end_layout
\begin_layout LyX-Code
z = 0
\end_layout
\begin_layout LyX-Code
ax.plot(x, y, z, label = 'x')# circle
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
z = sin(4*phi) # modulated in z plane
\end_layout
\begin_layout LyX-Code
ax.plot(x, y, z, label = 'x')
\end_layout
\begin_layout LyX-Code
ax.set_xlabel('X')
\end_layout
\begin_layout LyX-Code
ax.set_ylabel('Y')
\end_layout
\begin_layout LyX-Code
ax.set_zlabel('Z')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
Modify the code to make x = sin(2*phi) to observe Lissajous figures
\end_layout
\begin_layout Subsection
Wire-frame Plots
\end_layout
\begin_layout Standard
Data for a sphere is generated using the outer product of matrices and plotted,
by sphere.py.
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout
\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout
\begin_layout LyX-Code
phi = linspace(0, 2 * pi, 100)
\end_layout
\begin_layout LyX-Code
theta = linspace(0, pi, 100)
\end_layout
\begin_layout LyX-Code
x = 10 * outer(cos(phi), sin(theta))
\end_layout
\begin_layout LyX-Code
y = 10 * outer(sin(phi), sin(theta))
\end_layout
\begin_layout LyX-Code
z = 10 * outer(ones(size(phi)), cos(theta))
\end_layout
\begin_layout LyX-Code
ax.plot_wireframe(x,y,z, rstride=2, cstride=2)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Mayavi, 3D visualization
\end_layout
\begin_layout Standard
For more efficient and advanced 3D visualization, use Mayavi that is available
on most of the GNU/Linux platforms.
Program ylm20.py plots the spherical harmonics
\begin_inset Formula $Y_{m}^{l}$
\end_inset
for
\begin_inset Formula $l=2,m=0$
\end_inset
, using mayavi.
The plot of
\begin_inset Formula $Y_{2}^{0}=\frac{1}{4}\sqrt{\frac{5}{\pi}}(3\cos^{2}\phi-1)$
\end_inset
is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-ylm20.py"
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\emph on
Example ylm20.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
from enthought.mayavi import mlab
\end_layout
\begin_layout LyX-Code
polar = linspace(0,pi,100)
\end_layout
\begin_layout LyX-Code
azimuth = linspace(0, 2*pi,100)
\end_layout
\begin_layout LyX-Code
phi,th = meshgrid(polar, azimuth)
\end_layout
\begin_layout LyX-Code
r = 0.25 * sqrt(5.0/pi) * (3*cos(phi)**2 - 1)
\end_layout
\begin_layout LyX-Code
x = r*sin(phi)*cos(th)
\end_layout
\begin_layout LyX-Code
y = r*cos(phi)
\end_layout
\begin_layout LyX-Code
z = r*sin(phi)*sin(th)
\end_layout
\begin_layout LyX-Code
mlab.mesh(x, y, z)
\end_layout
\begin_layout LyX-Code
mlab.show()
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/ylm20.png
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of ylm20.py
\begin_inset LatexCommand label
name "fig:Output-of-ylm20.py"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Enumerate
Plot a sine wave using markers +, o and x using three different colors.
\end_layout
\begin_layout Enumerate
Plot
\begin_inset Formula $\tan\theta$
\end_inset
from
\begin_inset Formula $\theta$
\end_inset
from
\begin_inset Formula $-2\pi$
\end_inset
to
\begin_inset Formula $2\pi$
\end_inset
, watch for singular points.
\end_layout
\begin_layout Enumerate
Plot a circle using the polar() function.
\end_layout
\begin_layout Enumerate
Plot the following from the list of Famous curves at reference
\begin_inset LatexCommand cite
key "gap-system"
\end_inset
\newline
a)
\begin_inset Formula $r^{2}=a^{2}\cos2\theta$
\end_inset
, Lemniscate of Bernoulli
\newline
b)
\begin_inset Formula $y=\sqrt{2\pi}e^{-x^{2}/2}$
\end_inset
Frequency curve
\newline
c)
\begin_inset Formula $a\cosh(x/a)$
\end_inset
catenary
\newline
d)
\begin_inset Formula $\sin(a\theta)$
\end_inset
for a = 2, 3, and 4.
Rhodonea curves
\end_layout
\begin_layout Enumerate
Generate a triangular wave using Fourier series.
\end_layout
\begin_layout Enumerate
Evaluate
\begin_inset Formula $y=\sum_{n=1}^{n=\infty}\frac{(-1)^{n}x^{2n+1}}{(2n+1)!}$
\end_inset
for 10 terms.
\end_layout
\begin_layout Enumerate
Write a Python program to calculate sine function using series expansion
and plot it.
\end_layout
\begin_layout Enumerate
Write a Python program to plot
\begin_inset Formula $y=5x^{2}+3x+2$
\end_inset
(for x from 0 to 5, 20 points),using pylab, with axes and title.
Use red colored circles to mark the points.
\end_layout
\begin_layout Enumerate
Write a Python program to plot a Square wave using Fourier series, number
of terms should be a variable.
\end_layout
\begin_layout Enumerate
Write a Python program to read the x and y coordinates from a file, in a
two column format, and plot them.
\end_layout
\begin_layout Enumerate
Plot
\begin_inset Formula $x^{2}+y^{2}+z^{2}=25$
\end_inset
using mayavi.
\end_layout
\begin_layout Enumerate
Make a plot z = sin(x) + sin(y) using imshow() , from
\begin_inset Formula $-4\pi to4\pi$
\end_inset
for both x and y.
\end_layout
\begin_layout Enumerate
Write Python code to plot
\begin_inset Formula $y=x^{2}$
\end_inset
, with the axes labelled
\end_layout
\begin_layout Chapter
Type setting using LaTeX
\end_layout
\begin_layout Standard
LaTeX is a powerful typesetting system, used for producing scientific and
mathematical documents of high typographic quality.
LaTeX is not a word processor! Instead, LaTeX encourages authors not to
worry too much about the appearance of their documents but to concentrate
on getting the right content.
You prepare your document using a plain text editor, and the formatting
is specified by commands embedded in your document.
The appearance of your document is decided by LaTeX, but you need to specify
it using some commands.
In this chapter, we will discuss some of these commands mainly to typeset
mathematical equations.
\begin_inset Foot
status collapsed
\begin_layout Standard
http://www.latex-project.org/
\end_layout
\begin_layout Standard
http://mirror.ctan.org/info/lshort/english/lshort.pdf
\end_layout
\begin_layout Standard
http://en.wikibooks.org/wiki/LaTeX
\end_layout
\end_inset
\end_layout
\begin_layout Section
Document classes
\end_layout
\begin_layout Standard
LaTeX provides several predefined document classes (book, article, letter,
report, etc.) with extensive sectioning and cross-referencing capabilities.
Title, chapter, section, subsection, paragraph, subparagraph etc.
are specified by commands and it is the job of LaTeX to format them properly.
It does the numbering of sections automatically and can generate a table
of contents if requested.
Figures and tables are also numbered and placed without the user worrying
about it.
\end_layout
\begin_layout Standard
The latex source document (the .tex file) is compiled by the latex program
to generate a device independent (the .dvi file) output.
From that you can generate postscript or PDF versions of the document.
We will start with a simple example
\shape italic
hello.tex
\shape default
to demonstrate this process.
In a line, anything after a % sign is taken as a comment.
\end_layout
\begin_layout Standard
\align left
\emph on
Example hello.tex
\end_layout
\begin_layout LyX-Code
\backslash
documentclass{article}
\end_layout
\begin_layout LyX-Code
\backslash
begin{document}
\end_layout
\begin_layout LyX-Code
Small is beautiful.
% I am just a comment
\end_layout
\begin_layout LyX-Code
\backslash
end{document}
\end_layout
\begin_layout Standard
Compile, view and make a PDF file using the following commands:
\end_layout
\begin_layout Standard
$ latex hello.tex
\end_layout
\begin_layout Standard
$ xdvi hello.dvi
\end_layout
\begin_layout Standard
$ dvipdf hello.dvi
\end_layout
\begin_layout Standard
\align left
The output will look like : Small is beautiful.
\end_layout
\begin_layout Section
Modifying Text
\end_layout
\begin_layout Standard
In the next example
\shape italic
texts.tex
\shape default
we will demonstrate different types of text.
We will
\backslash
newline or
\backslash
\backslash
to generate a line break.
A blank line will start a new paragraph.
\end_layout
\begin_layout Standard
\align left
\emph on
Example texts.tex
\end_layout
\begin_layout Quotation
\backslash
documentclass{article}
\end_layout
\begin_layout Quotation
\backslash
begin{document}
\end_layout
\begin_layout Quotation
This is normal text.
\end_layout
\begin_layout Quotation
\backslash
newline
\end_layout
\begin_layout Quotation
\backslash
textbf{This is bold face text.}
\end_layout
\begin_layout Quotation
\backslash
textit{This is italic text.}
\backslash
\backslash
\end_layout
\begin_layout Quotation
\backslash
tiny{This is tiny text.}
\end_layout
\begin_layout Quotation
\backslash
large{This is large text.}
\end_layout
\begin_layout Quotation
\backslash
underline{This is underlined text.}
\end_layout
\begin_layout Quotation
\backslash
end{document}
\end_layout
\begin_layout Standard
\align left
Compiling
\shape italic
texts.tex,
\shape default
as explained in the previous example, will genearte the following output.
\end_layout
\begin_layout Standard
\lyxline
\end_layout
\begin_layout Standard
\begin_inset ERT
status collapsed
\begin_layout Standard
\backslash
textnormal{This is normal text.}
\end_layout
\begin_layout Standard
\backslash
newline
\end_layout
\begin_layout Standard
\backslash
textbf{This is bold face text.}
\end_layout
\begin_layout Standard
\backslash
textit{This is italic text.}
\backslash
\backslash
\end_layout
\begin_layout Standard
\backslash
tiny{This is tiny text.}
\end_layout
\begin_layout Standard
\backslash
large{This is large text.}
\end_layout
\begin_layout Standard
\backslash
underline{This is underlined text.}
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\lyxline
\end_layout
\begin_layout Section
Dividing the document
\end_layout
\begin_layout Standard
A document is generally organized in to sections, subsections, paragraphs
etc.
and Latex allows us to do this by inserting commands like section subsection
etc.
If the document class is book, you can have chapters also.
There is a command to generate the table of contents from the sectioning
information.
\begin_inset Foot
status collapsed
\begin_layout Standard
To generate the table of contents, you may have to compile the document
two times.
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/sections.png
width 12cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of sections.tex
\begin_inset LatexCommand label
name "fig:Output-of-sections.tex"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example sections.tex
\end_layout
\begin_layout Quotation
\backslash
documentclass{article}
\end_layout
\begin_layout Quotation
\backslash
begin{document}
\end_layout
\begin_layout Quotation
\backslash
tableofcontents
\end_layout
\begin_layout Quotation
\backslash
section{Animals}
\end_layout
\begin_layout Quotation
This document defines sections.
\end_layout
\begin_layout Quotation
\backslash
subsection{Domestic}
\end_layout
\begin_layout Quotation
This document also defines subsections.
\end_layout
\begin_layout Quotation
\backslash
subsubsection{cats and dogs}
\end_layout
\begin_layout Quotation
Cats and dogs are Domestic animals.
\end_layout
\begin_layout Quotation
\backslash
end{document}
\end_layout
\begin_layout Standard
The output of sections.tex is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-sections.tex"
\end_inset
.
\end_layout
\begin_layout Section
Environments
\end_layout
\begin_layout Standard
Environments decide the way in which your text is formatted : numbered lists,
tables, equations, quotations, justifications, figure, etc.
are some of the environments.
Environments are defined like :
\end_layout
\begin_layout Standard
\backslash
begin{environment_name} your text
\backslash
end{environment_name}
\end_layout
\begin_layout Standard
\align block
The example program
\shape italic
environ.tex
\shape default
demonstrates some of the environments.
\end_layout
\begin_layout Standard
\align left
\emph on
Example environs.tex
\end_layout
\begin_layout Standard
\backslash
documentclass{article}
\end_layout
\begin_layout Standard
\backslash
begin{document}
\end_layout
\begin_layout Standard
\backslash
begin{flushleft} A bulleted list.
\backslash
end{flushleft}
\end_layout
\begin_layout Standard
\backslash
begin{itemize}
\backslash
item dog
\backslash
item cat
\backslash
end{itemize}
\end_layout
\begin_layout Standard
\backslash
begin{center} A numbered List.
\backslash
end{center}
\end_layout
\begin_layout Standard
\backslash
begin{enumerate}
\backslash
item dog
\backslash
item cat
\backslash
end{enumerate}
\end_layout
\begin_layout Standard
\backslash
begin{flushright} This text is right justified.
\backslash
end{flushright}
\end_layout
\begin_layout Standard
\backslash
begin{quote}
\end_layout
\begin_layout Standard
Any text inside quote
\backslash
\backslash
environment will appe-
\backslash
\backslash
ar as typed.
\backslash
\backslash
\end_layout
\begin_layout Standard
\backslash
end{quote}
\end_layout
\begin_layout Standard
\backslash
begin{verbatim}
\end_layout
\begin_layout Standard
x = 1
\end_layout
\begin_layout Standard
while x <= 10:
\end_layout
\begin_layout Standard
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
print x * 5
\end_layout
\begin_layout Standard
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
x = x + 1
\end_layout
\begin_layout Standard
\backslash
end{verbatim}
\end_layout
\begin_layout Standard
\backslash
end{document}
\end_layout
\begin_layout Standard
\align block
The enumerate and itemize are used for making numbered and non-numbered
lists.
Flushleft, flushright and center are used for specifying text justification.
Quote and verbatim are used for portions where we do not want LaTeX to
do the formatting.
The output of environs.tex is shown below.
\end_layout
\begin_layout Standard
\lyxline
\end_layout
\begin_layout Standard
\align block
\begin_inset ERT
status collapsed
\begin_layout Standard
\backslash
begin{flushleft} A bulleted list.
\backslash
end{flushleft}
\end_layout
\begin_layout Standard
\backslash
begin{itemize}
\backslash
item dog
\backslash
item cat
\backslash
end{itemize}
\end_layout
\begin_layout Standard
\backslash
begin{center} A numbered List.
\backslash
end{center}
\end_layout
\begin_layout Standard
\backslash
begin{enumerate}
\backslash
item dog
\backslash
item cat
\backslash
end{enumerate}
\end_layout
\begin_layout Standard
\backslash
begin{flushright} This text is right justified.
\backslash
end{flushright}
\end_layout
\begin_layout Standard
\backslash
begin{quote}
\end_layout
\begin_layout Standard
Any text inside quote
\backslash
\backslash
environment will appe-
\backslash
\backslash
ar as typed.
\backslash
\backslash
\end_layout
\begin_layout Standard
\backslash
end{quote}
\end_layout
\begin_layout Standard
\backslash
begin{verbatim}
\end_layout
\begin_layout Standard
x = 1 # a Python program
\end_layout
\begin_layout Standard
while x <= 10:
\end_layout
\begin_layout Standard
print x * 5
\end_layout
\begin_layout Standard
x = x + 1
\end_layout
\begin_layout Standard
\backslash
end{verbatim}
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\lyxline
\end_layout
\begin_layout Section
Typesetting Equations
\end_layout
\begin_layout Standard
There two ways to typeset mathematical formulae: in-line within a paragraph,
or in a separate line.
In-line equations are entered between
\shape italic
two $ symbols
\shape default
.
The equations in a separate line can be done within the
\shape italic
equation
\shape default
environment.
Both are demonstrated in math1.tex.
\shape italic
We use the amsmath package in this example.
\end_layout
\begin_layout Standard
\align left
\emph on
Example math1.tex
\end_layout
\begin_layout Quotation
\backslash
documentclass{article}
\end_layout
\begin_layout Quotation
\backslash
usepackage{amsmath}
\end_layout
\begin_layout Quotation
\backslash
begin{document}
\end_layout
\begin_layout Quotation
The equation $a^2 + b^2 = c^2$ is typeset as inline.
\end_layout
\begin_layout Quotation
The same can be done in a separate line using
\end_layout
\begin_layout Quotation
\backslash
begin{equation}
\end_layout
\begin_layout Quotation
a^2 + b^2 = c^2
\end_layout
\begin_layout Quotation
\backslash
end{equation}
\end_layout
\begin_layout Quotation
\backslash
end{document}
\end_layout
\begin_layout Standard
The output of this file is shown below.
\end_layout
\begin_layout Standard
\lyxline
\begin_inset ERT
status collapsed
\begin_layout Standard
The equation $a^2 + b^2 = c^2$ is typeset as inline.
\end_layout
\begin_layout Standard
The same can be done in a separate line using
\end_layout
\begin_layout Standard
\backslash
begin{equation}
\end_layout
\begin_layout Standard
a^2 + b^2 = c^2
\end_layout
\begin_layout Standard
\backslash
end{equation}
\end_layout
\end_inset
\lyxline
\end_layout
\begin_layout Standard
The equation number becomes 5.1 because this happens to be the first equation
in chapter 5.
\end_layout
\begin_layout Subsection
Building blocks for typesetting equations
\end_layout
\begin_layout Standard
To typeset equations, we need to know the commands to make constructs like
fraction, sqareroot, integral etc.
The following list shows several commands and corresponding outputs.
For each item, the output of the command, between the two $ signs, is shown
on the right side.
The reader is expected to insert then inside the body of a document, compile
the file and view the output for practicing.
\end_layout
\begin_layout Enumerate
Extra space
\begin_inset Foot
status collapsed
\begin_layout Standard
\backslash
quad is for inserting space, the size of a
\backslash
quad corresponds to the width of the character ‘M’ of the current font.
Use
\backslash
qquad for larger space.
\end_layout
\end_inset
: $A
\backslash
quad B
\backslash
qquad C$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$A
\backslash
quad B
\backslash
qquad C$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Greek letters : $
\backslash
alpha
\backslash
beta
\backslash
gamma
\backslash
pi$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
alpha
\backslash
beta
\backslash
gamma
\backslash
pi$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Subscript and Exponents : $A_n
\backslash
quad A^m $\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$A_n
\backslash
quad A^m$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Multiple Exponents : $a^b
\backslash
quad a^{b^c}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$a^b
\backslash
quad a^{b^c}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Fractions : $
\backslash
frac{3}{5}$ \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
frac{3}{5}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Dots : $n! = 1
\backslash
cdot 2
\backslash
cdots (n-1)
\backslash
cdot n$ \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$n! = 1
\backslash
cdot 2
\backslash
cdots (n-1)
\backslash
cdot n$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Under/over lines : $0.
\backslash
overline{3} =
\backslash
underline{1/3}}$ \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$0.
\backslash
overline{3} =
\backslash
underline{1/3}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Vectors : $
\backslash
vec{a}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
vec{a}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Functions : $
\backslash
sin x +
\backslash
arctan y$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
sin x +
\backslash
arctan y$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Square root : $
\backslash
sqrt{x^2+y^2}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
sqrt{x^2+y^2}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Higher roots : $z=
\backslash
sqrt[3]{x^{2} +
\backslash
sqrt{y}}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$z=
\backslash
sqrt[3]{x^{2} +
\backslash
sqrt{y}}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Equalities : $A
\backslash
neq B
\backslash
quad A
\backslash
approx C$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$A
\backslash
neq B
\backslash
quad A
\backslash
approx C
\backslash
quad $
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Arrows : $
\backslash
Leftrightarrow
\backslash
quad
\backslash
Downarrow$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
Leftrightarrow
\backslash
quad
\backslash
Downarrow$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Partial derivative : $
\backslash
frac{
\backslash
partial ^2A}{
\backslash
partial x^2}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
frac{
\backslash
partial ^2A}{
\backslash
partial x^2}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Summation : $
\backslash
sum_{i=1}^n$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
sum_{i=1}^n$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Integration : $
\backslash
int_0^{
\backslash
frac{
\backslash
pi}{2}
\backslash
sin x}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
int_0^{
\backslash
frac{
\backslash
pi}{2}} sin x$
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Product : $
\backslash
prod_
\backslash
epsilon$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
prod_
\backslash
epsilon$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Big brackets : $
\backslash
Big((x+1)(x-1)
\backslash
Big)^{2}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
Big((x+1)(x-1)
\backslash
Big)^{2}$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Integral : $
\backslash
int_a^b f(x) dx$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
int _a^b f(x)dx$
\end_layout
\end_inset
\end_layout
\begin_layout Enumerate
Operators : $
\backslash
pm
\backslash
div
\backslash
times
\backslash
cup
\backslash
ast
\backslash
$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\backslash
pm
\backslash
div
\backslash
times
\backslash
cup
\backslash
ast $
\end_layout
\end_inset
\end_layout
\begin_layout Section
Arrays and matrices
\end_layout
\begin_layout Standard
To typeset arrays, use the array environment, that is similar to the tabular
environment.
Within an array environment, & character separates columns,
\backslash
\backslash
starts a new line.
The command
\backslash
hline inserts a horizontal line.
Alignment of the columns is shown inside braces using characters (lcr)
and the | symbol is used for adding vertical lines.
An example of making a table is shown below.
\end_layout
\begin_layout Quotation
$
\backslash
begin{array}{|l|cr|}
\backslash
hline
\end_layout
\begin_layout Quotation
person & sex & age
\backslash
\backslash
\end_layout
\begin_layout Quotation
John & male & 20
\backslash
\backslash
\end_layout
\begin_layout Quotation
Mary & female & 10
\backslash
\backslash
\end_layout
\begin_layout Quotation
Gopal & male & 30
\backslash
\backslash
\end_layout
\begin_layout Quotation
\backslash
hline
\end_layout
\begin_layout Quotation
\backslash
end{array} $
\end_layout
\begin_layout Standard
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\end_layout
\begin_layout Standard
\backslash
begin{array}{|l|cr|}
\backslash
hline
\end_layout
\begin_layout Standard
person & sex & age
\backslash
\backslash
\end_layout
\begin_layout Standard
John & male & 7
\backslash
\backslash
\end_layout
\begin_layout Standard
Mary & female & 20
\backslash
\backslash
\end_layout
\begin_layout Standard
Gopal & male & 30
\backslash
\backslash
\end_layout
\begin_layout Standard
\backslash
hline
\end_layout
\begin_layout Standard
\backslash
end{array}
\end_layout
\begin_layout Standard
$
\end_layout
\end_inset
\end_layout
\begin_layout Standard
The first column is left justified, second is centered and the third is
right justified (decided by the {|l|cr|}).
If you insert a | character between c and r, it will add a vertical line
between second and third columns.
\end_layout
\begin_layout Standard
Let us make a matrix using the same command.
\end_layout
\begin_layout Quotation
$ A =
\backslash
left(
\end_layout
\begin_layout Quotation
\backslash
begin{array}{ccc}
\end_layout
\begin_layout Quotation
x_1 & x_2 &
\backslash
ldots
\backslash
\backslash
\end_layout
\begin_layout Quotation
y_1 & y_2 &
\backslash
ldots
\backslash
\backslash
\end_layout
\begin_layout Quotation
\backslash
vdots &
\backslash
vdots &
\backslash
ddots
\backslash
\backslash
\end_layout
\begin_layout Quotation
\backslash
end{array}
\end_layout
\begin_layout Quotation
\backslash
right) $
\end_layout
\begin_layout Standard
The output is shown below.
The
\backslash
left( and
\backslash
right) provides the enclosure.
All the columns are centered.
We have also used horizontal, vertical and diagonal dots in this example.
\end_layout
\begin_layout Standard
\begin_inset ERT
status collapsed
\begin_layout Standard
$
\end_layout
\begin_layout Standard
A =
\backslash
left(
\end_layout
\begin_layout Standard
\backslash
begin{array}{ccc}
\end_layout
\begin_layout Standard
x_1 & x_2 &
\backslash
ldots
\backslash
\backslash
\end_layout
\begin_layout Standard
y_1 & y_2 &
\backslash
ldots
\backslash
\backslash
\end_layout
\begin_layout Standard
\backslash
vdots &
\backslash
vdots &
\backslash
ddots
\backslash
\backslash
\end_layout
\begin_layout Standard
\backslash
end{array}
\end_layout
\begin_layout Standard
\backslash
right) $
\end_layout
\end_inset
\end_layout
\begin_layout Section
Floating bodies, Inserting Images
\end_layout
\begin_layout Standard
Figures and tables need special treatment, because they cannot be broken
across pages.
One method would be to start a new page every time a figure or a table
is too large to fit on the present page.
This approach would leave pages partially empty, which looks very bad.
The easiest solution is to
\shape italic
float
\shape default
them and let LaTeX decide the position.
( You can influence the placement of the floats using the arguments [htbp],
here, top, bottom or special page).
Any material enclosed in a figure or table environment will be treated
as floating matter.
The
\shape italic
graphicsx
\shape default
packages is required in this case.
\end_layout
\begin_layout Standard
\backslash
usepackage{graphicx}
\end_layout
\begin_layout Standard
\backslash
text{Learn how to insert pictures with caption inside the figure environment.}
\end_layout
\begin_layout Standard
\backslash
begin{figure}[h]
\end_layout
\begin_layout Standard
\backslash
centering
\end_layout
\begin_layout Standard
\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/arcs.png}
\end_layout
\begin_layout Standard
\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/sawtooth.png}
\end_layout
\begin_layout Standard
\backslash
caption{Picture of Arc and Sawtooth, inserted with [h] option.}
\end_layout
\begin_layout Standard
\backslash
end{figure}
\end_layout
\begin_layout Standard
\align left
The result is shown below.
\lyxline
\end_layout
\begin_layout Standard
\begin_inset ERT
status open
\begin_layout Standard
\backslash
textit{Learn how to insert pictures with caption inside the figure environment.}
\end_layout
\begin_layout Standard
\backslash
begin{figure}[h]
\end_layout
\begin_layout Standard
\backslash
centering
\end_layout
\begin_layout Standard
\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/arcs.png}
\end_layout
\begin_layout Standard
\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/sawtooth.png}
\end_layout
\begin_layout Standard
\backslash
caption{Picture of Arc and Sawtooth, inserted with [h] option.}
\end_layout
\begin_layout Standard
\backslash
end{figure}
\end_layout
\end_inset
\lyxline
\end_layout
\begin_layout Section
Example Application
\end_layout
\begin_layout Standard
Latex source code for a simple question paper listed below.
\end_layout
\begin_layout Standard
\align left
\emph on
Example qpaper.tex
\end_layout
\begin_layout Quotation
\backslash
documentclass{article}
\end_layout
\begin_layout Quotation
\backslash
usepackage{amsmath}
\end_layout
\begin_layout Quotation
begin{document}
\end_layout
\begin_layout Quotation
\backslash
begin{center}
\end_layout
\begin_layout Quotation
\backslash
large{
\backslash
textbf{Sample Question Paper
\backslash
\backslash
for
\backslash
\backslash
\end_layout
\begin_layout Quotation
Mathematics using Python}}
\end_layout
\begin_layout Quotation
\backslash
end{center}
\end_layout
\begin_layout Quotation
\backslash
begin{tabular}{p{8cm}r}
\end_layout
\begin_layout Quotation
\backslash
textbf{Duration:3 Hrs} &
\backslash
textbf{30 weightage}
\end_layout
\begin_layout Quotation
\backslash
end{tabular}
\backslash
\backslash
\end_layout
\begin_layout Quotation
\backslash
section{Answer all Questions.
$4
\backslash
times 1
\backslash
frac{1}{2}$}
\end_layout
\begin_layout Quotation
\backslash
begin{enumerate}
\end_layout
\begin_layout Quotation
\backslash
item What are the main document classes in LaTeX.
\end_layout
\begin_layout Quotation
\backslash
item Typeset $
\backslash
sin^{2}x+
\backslash
cos^{2}x=1$ using LaTeX.
\end_layout
\begin_layout Quotation
\backslash
item Plot a circle using the polar() function.
\end_layout
\begin_layout Quotation
\backslash
item Write code to print all perfect cubes upto 2000.
\end_layout
\begin_layout Quotation
\backslash
end{enumerate}
\end_layout
\begin_layout Quotation
\backslash
section{Answer any two Questions.
$3
\backslash
times 5$}
\end_layout
\begin_layout Quotation
\backslash
begin{enumerate}
\end_layout
\begin_layout Quotation
\backslash
item Set a sample question paper using LaTeX.
\end_layout
\begin_layout Quotation
\backslash
item Using Python calculate the GCD of two numbers
\end_layout
\begin_layout Quotation
\backslash
item Write a program with a Canvas and a circle.
\end_layout
\begin_layout Quotation
\backslash
end{enumerate}
\end_layout
\begin_layout Quotation
\backslash
begin{center}
\backslash
text{End}
\backslash
end{center}
\end_layout
\begin_layout Quotation
\backslash
end{document}
\end_layout
\begin_layout Standard
The formatted output is shown below.
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/qpaper.png
width 12cm
\end_inset
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Enumerate
What are the main document classes supported by LaTeX.
\end_layout
\begin_layout Enumerate
How does Latex differ from other word processor programs.
\end_layout
\begin_layout Enumerate
Write a .tex file to typeset 'All types of Text Available' in tiny, large,
underline and italic.
\end_layout
\begin_layout Enumerate
Rewrite the previous example to make the output a list of numbered lines.
\end_layout
\begin_layout Enumerate
Generate an article with section and subsections with table of contents.
\end_layout
\begin_layout Enumerate
Typeset 'All types of justifications' to print it three times; left, right
and centered.
\end_layout
\begin_layout Enumerate
Write a .tex file that prints 12345 in five lines (one character per line).
\end_layout
\begin_layout Enumerate
Typeset a Python program to generate the multiplication table of 5, using
verbatim.
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $\sin^{2}x+\cos^{2}x=1$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $\left(\sqrt{x^{2}+y^{2}}\right)^{2}=x^{2}+y^{2}$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $\sum_{n=1}^{\infty}\left(1+\frac{1}{n}\right)^{n}$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $\frac{\partial A}{\partial x}=A$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $\int_{0}^{\pi}\cos x.dx$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $x=\frac{-b\pm\sqrt{b^{2}-4ac}}{2a}$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $A=\left(\begin{array}{cc}
1 & 2\\
3 & 4\end{array}\right)$
\end_inset
\end_layout
\begin_layout Enumerate
Typeset
\begin_inset Formula $R=\left(\begin{array}{cc}
\sin\theta & \cos\theta\\
\cos\theta & \sin\theta\end{array}\right)$
\end_inset
\end_layout
\begin_layout Chapter
Numerical methods
\end_layout
\begin_layout Standard
Solving mathematical equations is an important requirement for various branches
of science but many of them evade an analytic solution.
The field of numerical analysis explores the techniques that give approximate
but accurate solutions to such problems.
\begin_inset Foot
status collapsed
\begin_layout Standard
Introductory methods of numerical analysis by S.S.Sastry
\end_layout
\begin_layout Standard
http://ads.harvard.edu/books/1990fnmd.book/
\end_layout
\end_inset
Even when they have a solution, for all practical purposes we need to evaluate
the numeric value of the result, with the desired accuracy.
We will focus on developing simple working programs rather than going into
the theoretical details.
The mathematical equations giving numerical solutions will be explored
by changing various parameters and nature of input data.
\end_layout
\begin_layout Section
Derivative of a function
\end_layout
\begin_layout Standard
The mathematical definition of the derivative of a function
\begin_inset Formula $f(x)$
\end_inset
at point
\begin_inset Formula $x$
\end_inset
can be approximated by equation
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
{lim\atop \Delta x\rightarrow0}\frac{f(x+\frac{\triangle x}{2})-f(x-\frac{\triangle x}{2})}{\triangle x}\label{eq:derivative}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
neglecting the higher order terms.
The accuracy of the derivative calculated using discrete values
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
depends on the stepsize
\begin_inset Formula $\triangle x$
\end_inset
.
It will also depends on the number of higher order derivatives the function
has.
We will try to explore these aspects using the program
\family default
\series default
\shape default
\size default
\emph on
\bar default
\noun default
\color black
diff.py
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
, which evaluates the derivatives of few functions using two different
stepsizes (0.1 ans 0.01).
The input values to function deriv() are the function to be differentiated,
the point at which the derivative is to be found and the stepsize
\begin_inset Formula $\triangle x$
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\emph on
Example diff.py
\end_layout
\begin_layout LyX-Code
def f1(x):
\end_layout
\begin_layout LyX-Code
return x**2
\end_layout
\begin_layout LyX-Code
def f2(x):
\end_layout
\begin_layout LyX-Code
return x**4
\end_layout
\begin_layout LyX-Code
def f3(x):
\end_layout
\begin_layout LyX-Code
return x**10
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def deriv(func, x, dx=0.1):
\end_layout
\begin_layout LyX-Code
df = func(x+dx/2)-func(x-dx/2)
\end_layout
\begin_layout LyX-Code
return df/dx
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print deriv(f1, 1.0), deriv(f1, 1.0, 0.01)
\end_layout
\begin_layout LyX-Code
print deriv(f2, 1.0), deriv(f2, 1.0, 0.01)
\end_layout
\begin_layout LyX-Code
print deriv(f3, 1.0), deriv(f3, 1.0, 0.01)
\end_layout
\begin_layout Standard
The output of the program is shown below.
Comparing the two numbers on the same line shows the effect of stepsize.
Comparing the first number on each row shows the effect of the number of
higher order derivatives the function has.
For the same stepsize
\begin_inset Formula $x^{4}$
\end_inset
gives much less error than
\begin_inset Formula $x^{10}$
\end_inset
.
Second derivative of
\begin_inset Formula $x^{2}$
\end_inset
is constant and the result becomes exact, result on the first line.
\end_layout
\begin_layout Quotation
2.0 2.0
\end_layout
\begin_layout Quotation
4.01 4.0001
\end_layout
\begin_layout Quotation
10.3015768754 10.0030001575
\end_layout
\begin_layout Standard
You may explore other functions by modifying the program.
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
It can be seen that the function deriv(), evaluates the function at two
points to calculate the derivative.
The higher order terms can be calculated by evaluating the function at
more points.
Techniques used for this will be discussed in section
\begin_inset LatexCommand ref
reference "sec:Interpolation"
\end_inset
, on interpolation.
\end_layout
\begin_layout Subsection
Differentiate Sine to get Cosine
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/vdiff.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/vdiff_bigerror.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Outputs of vdiff.py (a)for
\begin_inset Formula $\triangle x=0.005$
\end_inset
(b) for
\begin_inset Formula $\triangle x=1.0$
\end_inset
\begin_inset LatexCommand label
name "fig:Outputs-of-vdiff.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
The program
\emph on
\color black
diff.py
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
in the previous example can only calculate the value of the derivative
at a given point.
In the program
\family default
\series default
\shape default
\size default
\emph on
\bar default
\noun default
\color black
vdiff.py
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
, we use a vectorized version of our deriv() function.
The defined function is sine and the derivative is calculated using the
vectorized version of deriv().
The actual cosine function also is plotted for comparison.
The output of vdiff.py is shown in
\begin_inset LatexCommand ref
reference "fig:Outputs-of-vdiff.py"
\end_inset
(a).
\end_layout
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
The value of
\begin_inset Formula $\triangle x$
\end_inset
is increased to 1.0
\family default
\series default
\shape default
\size default
\emph default
\bar default
\noun default
\color inherit
by changing one line of code as
\begin_inset Formula $y=vecderiv(x,1.0)$
\end_inset
and the result is shown in
\begin_inset LatexCommand ref
reference "fig:Outputs-of-vdiff.py"
\end_inset
(b).
The values calculated using our function is shown using
\begin_inset Formula $+$
\end_inset
marker, while the continuous curve is the expected result , ie.
the cosine curve.
\end_layout
\begin_layout Standard
\align left
\emph on
Example vdiff.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
def f(x):
\end_layout
\begin_layout LyX-Code
return sin(x)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def deriv(x,dx=0.005):
\end_layout
\begin_layout LyX-Code
df = f(x+dx/2)-f(x-dx/2)
\end_layout
\begin_layout LyX-Code
return df/dx
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
vecderiv = vectorize(deriv)
\end_layout
\begin_layout LyX-Code
x = linspace(-2*pi, 2*pi, 200)
\end_layout
\begin_layout LyX-Code
y = vecderiv(x)
\end_layout
\begin_layout LyX-Code
plot(x,y,'+')
\end_layout
\begin_layout LyX-Code
plot(x,cos(x))
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Numerical Integration
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/integ1.png
lyxscale 50
width 5cm
\end_inset
\begin_inset Graphics
filename pics/integ2.png
lyxscale 50
width 5cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Area under the curve is divided it in to a large number of intervals.
Area of each of them is calculated by assuming them to be trapezoids.
\begin_inset LatexCommand label
name "fig:Integration"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
Numerical integration constitutes a broad family of algorithms for calculating
the numerical value of a definite integral.
The objective is to find the area under the curve as shown in figure
\begin_inset LatexCommand ref
reference "fig:Integration"
\end_inset
.
One method is to divide this area in to large number of sub-intervals and
find the sum of their areas.
The interval
\begin_inset Formula $a\leq x\leq b$
\end_inset
is divided in to
\begin_inset Formula $n$
\end_inset
sub-intervals, each of length
\begin_inset Formula $h=(b-a)/n$
\end_inset
, and area of a sub-interval is approximated by
\begin_inset Formula \[
\int_{x_{n-1}}^{x_{n}}ydx=\frac{h}{2}(y_{n-1}+y_{n})\]
\end_inset
the integral is given by
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
\int_{a}^{b}ydx=\frac{h}{2}\left[y_{0}+2(y_{1}+y_{2}+\ldots+y_{n-1})+y_{n}\right]\label{eq:Trapez}\end{equation}
\end_inset
This is the sum of the areas of the individual trapezoids.
The error in using the trapezoid rule is approximately proportional to
\begin_inset Formula $1/n^{2}$
\end_inset
.
If the number of sub-intervals is doubled, the error is reduced by a factor
of 4.
The program
\emph on
trapez.py
\emph default
does integration of a given function using equation
\begin_inset LatexCommand ref
reference "eq:Trapez"
\end_inset
.
We will choose an example where the results can be cross checked easily,
the value of
\begin_inset Formula $\pi$
\end_inset
is calculated by evaluating the area of a unit circle by integrating the
equation of a circle.
\end_layout
\begin_layout Standard
\align left
\emph on
Example trapez.py
\end_layout
\begin_layout LyX-Code
from math import *
\end_layout
\begin_layout LyX-Code
def y(x): # equation of a circle
\end_layout
\begin_layout LyX-Code
return sqrt(1.0 - x**2)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def trapez(f, a, b, n):
\end_layout
\begin_layout LyX-Code
h = (b-a) / n
\end_layout
\begin_layout LyX-Code
sum = 0
\end_layout
\begin_layout LyX-Code
x = 0.5 * h # f(x) at middle of the slice
\end_layout
\begin_layout LyX-Code
for i in range (1,n):
\end_layout
\begin_layout LyX-Code
sum = sum + h * f(x)
\end_layout
\begin_layout LyX-Code
x = x + h
\end_layout
\begin_layout LyX-Code
return sum
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print 4 * trapez(y, 0.0, 1.0,1000)
\end_layout
\begin_layout LyX-Code
print 4 * trapez(y, 0.0, 1.0,10000)
\end_layout
\begin_layout LyX-Code
print trapez(sin,0,2,1000) # Why the error ?
\end_layout
\begin_layout Standard
The output is shown below.
The result gets better by increasing
\begin_inset Formula $n$
\end_inset
thus resulting in smaller
\begin_inset Formula $h$
\end_inset
.
The last line shows, how things can go wrong if the arguments are given
in the integer format.
Learn how to avoid such pitfalls while writing programs.
It is left as an exercise to the reader to modify the function trapez()
to accept integer arguments also.
\end_layout
\begin_layout Standard
3.14041703178
\end_layout
\begin_layout Standard
3.14155546691
\end_layout
\begin_layout Standard
0.0
\end_layout
\begin_layout Section
Ordinary Differential Equations
\end_layout
\begin_layout Standard
Differential equations are one of the most important mathematical tools
used in producing models for physical and biological processes.
In this section, we will discuss the numerical methods for solving the
initial value problem for first-order ordinary differential equations.
Consider the equation,
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
\frac{dy}{dx}=f(x,y);\,\,\,\, y(x_{0})=y_{0}\label{eq:ODE}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
where the derivative of the function
\begin_inset Formula $f(x,y)$
\end_inset
is known and the value of the function at some value of
\begin_inset Formula $x=x_{0}$
\end_inset
also is known.
The objective is to find out the value of the function for other values
of
\begin_inset Formula $x$
\end_inset
.
The underlying idea of any routine for solving the initial value problem
is to rewrite the
\begin_inset Formula $dy$
\end_inset
and
\begin_inset Formula $dx$
\end_inset
as finite steps
\begin_inset Formula $\triangle y$
\end_inset
and
\begin_inset Formula $\triangle x$
\end_inset
, and multiply the equations by
\begin_inset Formula $\triangle x$
\end_inset
.
This gives algebraic formulas for the change in the value of
\begin_inset Formula $y(x)$
\end_inset
when
\begin_inset Formula $x$
\end_inset
is changed by one stepsize
\begin_inset Formula $\triangle x$
\end_inset
.
In the limit of making the stepsize very small, a good approximation to
the underlying differential equation is achieved.
\end_layout
\begin_layout Standard
Implementation of this procedure results in the Euler’s method, which is
conceptually very important, but not recommended for any practical use.
In this section we will discuss Euler's method and the Runge-Kutta method
with the help of example programs.
For detailed information refer to
\begin_inset LatexCommand cite
key "numerical recepies,mathcs.emory"
\end_inset
.
\end_layout
\begin_layout Subsection
Euler method
\end_layout
\begin_layout Standard
The equations of Euler's method can be obtained as follows.
By the definition of derivative,
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
y^{'}(x_{n},y_{n})={lim\atop h\rightarrow0}\frac{y(x_{n}+h)-y(x_{n})}{h}\label{eq:Euler}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
For sufficiently small values of
\begin_inset Formula $h$
\end_inset
, we can write,
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
y(x_{n}+h)=y(x_{n},y_{n})+hy^{'}(x_{n})\label{eq:Euler2}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The above equations implies that, if the value of the function
\begin_inset Formula $y(x)$
\end_inset
is known to be
\begin_inset Formula $y_{n}$
\end_inset
at the point
\begin_inset Formula $x_{n}$
\end_inset
, its value at a nearby point
\begin_inset Formula $x_{n+1}$
\end_inset
is given by
\begin_inset Formula $y_{n}+h\times y^{'}.$
\end_inset
The program
\emph on
euler.py
\emph default
calculates the value of sine function using its derivative, ie.
the cosine function.
We start from
\begin_inset Formula $x=0$
\end_inset
, where
\begin_inset Formula $\sin(x)=0$
\end_inset
and compute the subsequent values using the derivative,
\begin_inset Formula $cos(x)$
\end_inset
, and compare the result with the actual sine function.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/euler.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/rkmethod.png
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
(a)Output of euler.py (b)Four intermediate steps of RK4 method
\begin_inset LatexCommand label
name "fig:Output-of-euler.py"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example euler.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
h = 0.01 # stepsize
\end_layout
\begin_layout LyX-Code
x = 0.0 # initial values
\end_layout
\begin_layout LyX-Code
y = 0.0
\end_layout
\begin_layout LyX-Code
ax = [] # Lists to store x and y
\end_layout
\begin_layout LyX-Code
ay = []
\end_layout
\begin_layout LyX-Code
while x < 2*pi:
\end_layout
\begin_layout LyX-Code
y = y + h * math.cos(x) # Euler equation
\end_layout
\begin_layout LyX-Code
x = x + h
\end_layout
\begin_layout LyX-Code
ax.append(x)
\end_layout
\begin_layout LyX-Code
ay.append(y)
\end_layout
\begin_layout LyX-Code
plot(ax,ay)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The output of
\emph on
euler.py
\emph default
is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-euler.py"
\end_inset
.
\end_layout
\begin_layout Subsection
Runge-Kutta method
\end_layout
\begin_layout Standard
The formula
\begin_inset LatexCommand ref
reference "eq:Euler"
\end_inset
used by Euler method which advances a solution from
\begin_inset Formula $x_{n}tox_{n+1}$
\end_inset
is not symmetric, it advances the solution through an interval
\begin_inset Formula $h$
\end_inset
, but uses derivative information only at the beginning of that interval.
Better results are obtained if we take
\shape italic
trial
\shape default
step to the midpoint of the interval and use the value of both
\begin_inset Formula $x$
\end_inset
and
\begin_inset Formula $y$
\end_inset
at that midpoint to compute the
\shape italic
real
\shape default
step across the whole interval.
This is called the second-order Runge-Kutta or the midpoint method.
This procedure can be further extended to higher orders.
\end_layout
\begin_layout Standard
The fourth order Runge-Kutta method is the most popular one and is commonly
referred as the Runge-Kutta method.
In each step the derivative is evaluated four times as shown in figure
\begin_inset LatexCommand ref
reference "fig:Outputs-of-(a)rk4.py"
\end_inset
(a).
Once at the initial point, twice at trial midpoints, and once at a trial
endpoint.
Every trial evaluation uses the value of the function from the previous
trial point, ie.
\begin_inset Formula $k_{2}$
\end_inset
is evaluated using
\begin_inset Formula $k_{1}$
\end_inset
and not using
\begin_inset Formula $y_{n}$
\end_inset
.
From these derivatives the final function value is calculated, The calculation
is done using the equations,
\end_layout
\begin_layout Standard
\align center
\begin_inset Formula $\begin{array}{c}
k_{1}=hf(x_{n},y_{n})\\
k_{2}=hf(x_{n}+\frac{h}{2},y_{n}+\frac{k_{1}}{2})\\
k_{3}=hf(x_{n}+\frac{h}{2},y_{n}+\frac{k_{2}}{2})\\
k_{4}=hf(x_{n}+h,y_{n}+k_{3})\end{array}$
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
y_{n+1}=y_{n}+\frac{1}{6}\left(k_{1}+2k_{2}+2k_{3}+k_{4}\right)\label{eq:Runge-Kutta4}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The program rk4.py listed below uses the equations shown above to calculate
the sine function, by integrating the cosine.
The output is shown in figure
\begin_inset LatexCommand ref
reference "fig:Outputs-of-(a)rk4.py"
\end_inset
(a).
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/rk4.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/eurk4.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Outputs of (a)rk4.py (b) compareEuRK4.py
\begin_inset LatexCommand label
name "fig:Outputs-of-(a)rk4.py"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example rk4.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def rk4(x, y, fx, h = 0.1): # x, y , f(x), stepsize
\end_layout
\begin_layout LyX-Code
k1 = h * fx(x)
\end_layout
\begin_layout LyX-Code
k2 = h * fx(x + h/2.0)
\end_layout
\begin_layout LyX-Code
k3 = h * fx(x + h/2.0)
\end_layout
\begin_layout LyX-Code
k4 = h * fx(x + h)
\end_layout
\begin_layout LyX-Code
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
h = 0.01 # stepsize
\end_layout
\begin_layout LyX-Code
x = 0.0 # initial values
\end_layout
\begin_layout LyX-Code
y = 0.0
\end_layout
\begin_layout LyX-Code
ax = [x]
\end_layout
\begin_layout LyX-Code
ay = [y]
\end_layout
\begin_layout LyX-Code
while x < math.pi:
\end_layout
\begin_layout LyX-Code
y = rk4(x,y,math.cos)
\end_layout
\begin_layout LyX-Code
x = x + h
\end_layout
\begin_layout LyX-Code
ax.append(x)
\end_layout
\begin_layout LyX-Code
ay.append(y)
\end_layout
\begin_layout LyX-Code
plot(ax,ay)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The program compareEuRK4.py calculates the values of Sine by integrating
Cosine.
The errors in both cases are evaluated at every step, by comparing it with
the sine function, and plotted as shown in figure
\begin_inset LatexCommand ref
reference "fig:Outputs-of-(a)rk4.py"
\end_inset
(b).
The accuracy of Runge-Kutta method is far superior to that of Euler's method,
for the same step size.
\end_layout
\begin_layout Standard
\align left
\emph on
Example compareEuRK4.py
\end_layout
\begin_layout LyX-Code
from scipy import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def rk4(x, y, fx, h = 0.1): # x, y , f(x), stepsize
\end_layout
\begin_layout LyX-Code
k1 = h * fx(x)
\end_layout
\begin_layout LyX-Code
k2 = h * fx(x + h/2.0)
\end_layout
\begin_layout LyX-Code
k3 = h * fx(x + h/2.0)
\end_layout
\begin_layout LyX-Code
k4 = h * fx(x + h)
\end_layout
\begin_layout LyX-Code
return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
h = 0.1 # stepsize
\end_layout
\begin_layout LyX-Code
x = 0.0 # initial values
\end_layout
\begin_layout LyX-Code
ye = 0.0 # for Euler
\end_layout
\begin_layout LyX-Code
yr = 0.0 # for RK4
\end_layout
\begin_layout LyX-Code
ax = [] # Lists to store results
\end_layout
\begin_layout LyX-Code
euerr = []
\end_layout
\begin_layout LyX-Code
rkerr = []
\end_layout
\begin_layout LyX-Code
while x < 2*pi:
\end_layout
\begin_layout LyX-Code
ye = ye + h * math.cos(x) # Euler method
\end_layout
\begin_layout LyX-Code
yr = rk4(x, yr, cos, h) # RK4 method
\end_layout
\begin_layout LyX-Code
x = x + h
\end_layout
\begin_layout LyX-Code
ax.append(x)
\end_layout
\begin_layout LyX-Code
euerr.append(ye - sin(x))
\end_layout
\begin_layout LyX-Code
rkerr.append(yr - sin(x))
\end_layout
\begin_layout LyX-Code
plot(ax,euerr,'o')
\end_layout
\begin_layout LyX-Code
plot(ax, rkerr,'+')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Function depending on the integral
\end_layout
\begin_layout Standard
In the previous section, the program
\shape italic
rk4.py
\shape default
implemented a simplified version of the Runge-Kutta method, the function
was assumed to depend on the independent variable only.
The program
\shape italic
rk4_proper.py
\shape default
listed below implements it properly.
The functions
\begin_inset Formula $f(x,y)=1+y^{2}$
\end_inset
and
\begin_inset Formula $f(x,y)=(y-x)/y+x)$
\end_inset
are used for testing.
Readers may verify the results by manual computing.
\end_layout
\begin_layout Standard
\align left
\emph on
Example rk4_proper.py
\end_layout
\begin_layout LyX-Code
def f1(x,y):
\end_layout
\begin_layout LyX-Code
return 1 + y**2
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def f2(x,y):
\end_layout
\begin_layout LyX-Code
return (y-x)/(y+x)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def rk4(x, y, fxy, h): # x, y , f(x,y), step
\end_layout
\begin_layout LyX-Code
k1 = h * fxy(x, y)
\end_layout
\begin_layout LyX-Code
k2 = h * fxy(x + h/2.0, y+k1/2)
\end_layout
\begin_layout LyX-Code
k3 = h * fxy(x + h/2.0, y+k2/2)
\end_layout
\begin_layout LyX-Code
k4 = h * fxy(x + h, y+k3)
\end_layout
\begin_layout LyX-Code
ny = y + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout
\begin_layout LyX-Code
#print x,y,k1,k2,k3,k4, ny
\end_layout
\begin_layout LyX-Code
return ny
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
h = 0.2 # stepsize
\end_layout
\begin_layout LyX-Code
x = 0.0 # initial values
\end_layout
\begin_layout LyX-Code
y = 0.0
\end_layout
\begin_layout LyX-Code
print rk4(x,y, f1, h)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
h = 1
\end_layout
\begin_layout LyX-Code
x = 0.0 # initial values
\end_layout
\begin_layout LyX-Code
y = 1.0
\end_layout
\begin_layout LyX-Code
print rk4(x,y,f2,h)
\end_layout
\begin_layout Standard
The results are shown below.
\end_layout
\begin_layout Standard
0.202707408081
\end_layout
\begin_layout Standard
1.5056022409
\end_layout
\begin_layout Section
Polynomials
\begin_inset LatexCommand label
name "sec:Polynomials"
\end_inset
\end_layout
\begin_layout Standard
A polynomial is a mathematical expression involving a sum of powers in one
or more variables multiplied by coefficients.
A polynomial in one variable with constant coefficients is given by
\begin_inset Formula \begin{equation}
a_{n}x^{n}+...+a_{2}x^{2}+a_{1}x+a_{0}\label{eq:Polinomial}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The derivative of
\begin_inset LatexCommand ref
reference "eq:Polinomial"
\end_inset
is,
\end_layout
\begin_layout Standard
\begin_inset Formula \[
na_{n}x^{n-1}+...+2a_{2}x+a_{1}\]
\end_inset
\end_layout
\begin_layout Standard
It is easy to find the derivative of a polynomial.
Complicated functions can be analyzed by approximating them with polynomials.
Taylor's theorem states that any sufficiently smooth function can locally
be approximated by a polynomial.
Computers use this property to evaluate trigonometric, logarithmic and
exponential functions.
\end_layout
\begin_layout Standard
One dimensional polynomials can be explored using the
\begin_inset Formula $poly1d$
\end_inset
function from Numpy.
You can define a polynomial by supplying the coefficient as a list.
For example , the statement p = poly1d([3,4,7]) constructs the polynomial
\begin_inset Formula $3x^{2}+4x+7$
\end_inset
.
Numpy supports several polynomial operations.
The following example demonstrates evaluation at a particular value, multiplica
tion, differentiation, integration and division of polynomials using
\shape italic
poly1d
\shape default
.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/polyplot.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of polyplot.py
\begin_inset LatexCommand label
name "fig:Output-of-polyplot.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example poly.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
a = poly1d([3,4,5])
\end_layout
\begin_layout LyX-Code
b = poly1d([6,7])
\end_layout
\begin_layout LyX-Code
c = a * b + 5
\end_layout
\begin_layout LyX-Code
d = c/a
\end_layout
\begin_layout LyX-Code
print a
\end_layout
\begin_layout LyX-Code
print a(0.5)
\end_layout
\begin_layout LyX-Code
print b
\end_layout
\begin_layout LyX-Code
print a * b
\end_layout
\begin_layout LyX-Code
print a.deriv()
\end_layout
\begin_layout LyX-Code
print a.integ()
\end_layout
\begin_layout LyX-Code
print d[0], d[1]
\end_layout
\begin_layout Standard
The output of
\emph on
\color black
poly.py
\emph default
\color inherit
is shown below.
\end_layout
\begin_layout Standard
\begin_inset Formula $\begin{array}[b]{l}
3x^{2}+4x+5\\
7.75\\
6x+7\\
18x^{3}+45x^{2}+58x+35\\
6x+4\\
1x^{3}+2x^{2}+5x\\
6x+7\\
5\end{array}$
\end_inset
\end_layout
\begin_layout Standard
The last two lines show the result of the polynomial division, quotient
and reminder.
Note that a polynomial can take an array argument for evaluation to return
the results in an array.
The program
\emph on
\color black
polyplot.py
\emph default
\color inherit
evaluates polynomial
\begin_inset LatexCommand ref
reference "eq:polynomial of Sine"
\end_inset
and its first derivative.
\begin_inset Formula \begin{equation}
x-\frac{x^{3}}{6}+\frac{x^{5}}{120}-\frac{x^{7}}{5040}\label{eq:polynomial of Sine}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The results are shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-polyplot.py"
\end_inset
.
The equation
\begin_inset LatexCommand ref
reference "eq:polynomial of Sine"
\end_inset
is the first four terms of series representing sine wave (7! = 5040).
The derivative looks like cosine as expected.
Try adding more terms and change the limits to see the effects.
\end_layout
\begin_layout Standard
\align left
\emph on
Example polyplot.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
x = linspace(-pi, pi, 100)
\end_layout
\begin_layout LyX-Code
a = poly1d([-1.0/5040,0,1.0/120,0,-1.0/6,0,1,0])
\end_layout
\begin_layout LyX-Code
da = a.deriv()
\end_layout
\begin_layout LyX-Code
y = a(x)
\end_layout
\begin_layout LyX-Code
y1 = da(x)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
plot(x,y1)
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Subsection
Taylor's Series
\begin_inset LatexCommand label
name "sub:Taylor's-Series"
\end_inset
\end_layout
\begin_layout Standard
If a function and its derivatives are known at some point
\begin_inset Formula $x=a$
\end_inset
, we can express
\begin_inset Formula $f(x)$
\end_inset
in the vicinity of that point using a polynomial.
The Taylor series expansion is given by,
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
f(x)=f(a)+(x-a)f^{'}(a)+\frac{(x-a)^{2}}{2!}f^{''}(a)+\cdots+\frac{(x-a)^{n}}{n!}f^{n}(a)\label{eq:Taylor's Series}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
For example let us consider the equation
\begin_inset Formula \begin{equation}
f(x)=x^{3}+x^{2}+x\label{eq:xcube}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
We can see that
\begin_inset Formula $f(0)=0$
\end_inset
and the derivatives are
\begin_inset Formula \[
f'(x)=3x^{2}+2x+1;\,\,\,\,\,\,\,\,\,\,\, f''(x)=6x+2;\,\,\,\,\,\, f'''(x)=6\]
\end_inset
\end_layout
\begin_layout Standard
Using the values of the derivatives at
\begin_inset Formula $x=0$
\end_inset
and equation
\begin_inset LatexCommand ref
reference "eq:Taylor's Series"
\end_inset
, we evaluate the function at
\begin_inset Formula $x=.5$
\end_inset
, using the polynomial expression,
\end_layout
\begin_layout Standard
\begin_inset Formula \[
f(0.5)=0+0.5\times1+\frac{0.5^{2}\times2}{2!}+\frac{0.5^{3}\times6}{3!}=.875\]
\end_inset
\end_layout
\begin_layout Standard
The result is same as
\begin_inset Formula $0.5^{3}+0.5^{2}+0.5=.875$
\end_inset
.
We have calculated it manually for
\begin_inset Formula $x=.5$
\end_inset
.
We can also do this using Numpy as shown in the program taylor.py.
\end_layout
\begin_layout Standard
\align left
\emph on
Example taylor.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
p = poly1d([1,1,1,0])
\end_layout
\begin_layout LyX-Code
dp = p.deriv()
\end_layout
\begin_layout LyX-Code
dp2 = dp.deriv()
\end_layout
\begin_layout LyX-Code
dp3 = dp2.deriv()
\end_layout
\begin_layout LyX-Code
a = 0 # The known point
\end_layout
\begin_layout LyX-Code
x = 0 # Evaluate at x
\end_layout
\begin_layout LyX-Code
while x < .5:
\end_layout
\begin_layout LyX-Code
tay = p(a) + (x-a)* dp(a) +
\backslash
\end_layout
\begin_layout LyX-Code
(x-a)**2 * dp2(a) / 2 + (x-a)**3 * dp3(a)/6
\end_layout
\begin_layout LyX-Code
print '%5.1f %8.5f
\backslash
t%8.5f'%(x, p(x), tay)
\end_layout
\begin_layout LyX-Code
x = x + .1
\end_layout
\begin_layout Standard
The result is shown below.
\end_layout
\begin_layout Quotation
0.0 0.00000 0.00000
\end_layout
\begin_layout Quotation
0.1 0.11100 0.11100
\end_layout
\begin_layout Quotation
0.2 0.24800 0.24800
\end_layout
\begin_layout Quotation
0.3 0.41700 0.41700
\end_layout
\begin_layout Quotation
0.4 0.62400 0.62400
\end_layout
\begin_layout Subsection
Sine and Cosine Series
\end_layout
\begin_layout Standard
In the equation
\begin_inset LatexCommand ref
reference "eq:Taylor's Series"
\end_inset
, let us choose
\begin_inset Formula $f(x)=sin(x)$
\end_inset
and
\begin_inset Formula $a=0$
\end_inset
.
If
\begin_inset Formula $a=0$
\end_inset
, then the series is known as the Maclaurin Series.
The first term will become
\begin_inset Formula $sin(0)$
\end_inset
, which is just zero.
The other terms involve the derivatives of
\begin_inset Formula $sin(x)$
\end_inset
.
The first, second and third derivatives of
\begin_inset Formula $sin(x)$
\end_inset
are
\begin_inset Formula $cos(x)$
\end_inset
,
\begin_inset Formula $-sin(x)$
\end_inset
and
\begin_inset Formula $-cos(x)$
\end_inset
, respectively.
Evaluating each of these at zero, we get 1, 0 and -1 respectively.
The terms with even powers vanish, resulting in,
\begin_inset Formula \begin{equation}
\sin(x)=x-\frac{x^{3}}{3!}+\frac{x^{5}}{5!}+\cdots\,\,\,\,\,=\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n+1}}{(2n+1)!}\label{eq:Taylor Sine}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
We can find the cosine series in a similar manner, to get
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
\cos(x)=1-\frac{x^{2}}{2!}+\frac{x^{4}}{4!}+\cdots\,\,\,\,\,=\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n}}{(2n)!}\label{eq:Taylor cosine}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The program series_sc.py evaluates the sine and cosine series.
The output is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-series_sc.py"
\end_inset
.
Compare the output of polyplot.py from section
\begin_inset LatexCommand ref
reference "sec:Polynomials"
\end_inset
with this.
In both cases, we have evaluated the polynomial of sine function.
In the present case, we can easily modify the number of terms and the logic
is simpler.
\end_layout
\begin_layout Standard
\align left
\emph on
Example series_sc.py
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/series_sc.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of series_sc.py
\begin_inset LatexCommand label
name "fig:Output-of-series_sc.py"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def f(n): # Factorial function
\end_layout
\begin_layout LyX-Code
if n == 0:
\end_layout
\begin_layout LyX-Code
return 1
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
return n * f(n-1)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
NP = 100
\end_layout
\begin_layout LyX-Code
x = linspace(-pi, pi, NP)
\end_layout
\begin_layout LyX-Code
sinx = zeros(NP)
\end_layout
\begin_layout LyX-Code
cosx = zeros(NP)
\end_layout
\begin_layout LyX-Code
for n in range(10):
\end_layout
\begin_layout LyX-Code
sinx += (-1)**(n) * (x**(2*n+1)) / f(2*n+1)
\end_layout
\begin_layout LyX-Code
cosx += (-1)**(n) * (x**(2*n)) / f(2*n)
\end_layout
\begin_layout LyX-Code
plot(x, sinx)
\end_layout
\begin_layout LyX-Code
plot(x, cosx,'r')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Section
Finding roots of an equation
\end_layout
\begin_layout Standard
In general, an equation may have any number of roots, or no roots at all.
For example
\begin_inset Formula $f(x)=x^{2}$
\end_inset
has a single root whereas
\begin_inset Formula $f(x)=sin(x)$
\end_inset
has an infinite number of roots.
The roots can be located visually, by looking at the intersections with
the x-axis.
Another useful tool for detecting and bracketing roots is the incremental
search method.
The basic idea behind the incremental search method is simple: if
\begin_inset Formula $f(x1)$
\end_inset
and
\begin_inset Formula $f(x2)$
\end_inset
have opposite signs, then there is at least one root in the interval
\begin_inset Formula $(x1,x2)$
\end_inset
.
If the interval is small enough, it is likely to contain a single root.
Thus the zeroes of
\begin_inset Formula $f(x)$
\end_inset
can be detected by evaluating the function at intervals of
\begin_inset Formula $\Delta x$
\end_inset
and looking for change in sign.
\end_layout
\begin_layout Standard
There are several potential problems with the incremental search method:
It is possible to miss two closely spaced roots if the search increment
\begin_inset Formula $\Delta x$
\end_inset
is larger than the spacing of the roots.
Certain singularities of
\begin_inset Formula $f(x)$
\end_inset
can be mistaken for roots.
For example,
\begin_inset Formula $f(x)=tan(x)$
\end_inset
changes sign at odd multiples of
\begin_inset Formula $\pi/2$
\end_inset
, but these locations are not true zeroes as shown in figure
\begin_inset LatexCommand ref
reference "fig:NRplot"
\end_inset
(b).
\end_layout
\begin_layout Standard
Example
\shape italic
rootsearch.py
\shape default
implements the function
\begin_inset Formula $root()$
\end_inset
that searches the roots of a function
\begin_inset Formula $f(x)$
\end_inset
from
\begin_inset Formula $x=a$
\end_inset
to
\begin_inset Formula $x=b$
\end_inset
, incrementing it by
\begin_inset Formula $dx$
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\emph on
Example rootsearch.py
\end_layout
\begin_layout LyX-Code
def func(x):
\end_layout
\begin_layout LyX-Code
return x**3-10.0*x*x + 5
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def root(f,a,b,dx):
\end_layout
\begin_layout LyX-Code
x = a
\end_layout
\begin_layout LyX-Code
while True:
\end_layout
\begin_layout LyX-Code
f1 = f(x)
\end_layout
\begin_layout LyX-Code
f2 = f(x+dx)
\end_layout
\begin_layout LyX-Code
if f1*f2 < 0:
\end_layout
\begin_layout LyX-Code
return x, x + dx
\end_layout
\begin_layout LyX-Code
x = x + dx
\end_layout
\begin_layout LyX-Code
if x >= b:
\end_layout
\begin_layout LyX-Code
return (None,None)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
x,y = root(func, 0.0, 1.0,.1)
\end_layout
\begin_layout LyX-Code
print x,y
\end_layout
\begin_layout LyX-Code
x,y = root(math.cos, 0.0, 4,.1)
\end_layout
\begin_layout LyX-Code
print x,y
\end_layout
\begin_layout Standard
The outputs are (0.7 , 0.8) and (1.5 , 1.6).
The root of cosine,
\begin_inset Formula $\pi/2$
\end_inset
, is between 1.5 and 1.6.
After the root has been located roughly, we can find the root with any
specified accuracy, using bisection method, Newton-Raphson method etc.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/nrplot.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/tanx.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
(a)Function
\begin_inset Formula $2x^{2}-3x-5$
\end_inset
and its tangents at
\begin_inset Formula $x=4$
\end_inset
and
\begin_inset Formula $x=4$
\end_inset
(b) tan(x)
\begin_inset LatexCommand label
name "fig:NRplot"
\end_inset
.
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Subsection
Method of Bisection
\end_layout
\begin_layout Standard
The method of bisection finds the root by successively halving the interval
until it becomes sufficiently small.
Bisection is not the fastest method available for computing roots, but
it is the most reliable.
Once a root has been bracketed, bisection will always find it.
The method of bisection works in the following manner.
If there is a root between
\begin_inset Formula $x1$
\end_inset
and
\begin_inset Formula $x2$
\end_inset
, then
\begin_inset Formula $f(x1)\times f(x2)<0$
\end_inset
.
Next, we compute
\begin_inset Formula $f(x3)$
\end_inset
, where
\begin_inset Formula $x3=(x1+x2)/2$
\end_inset
.
If
\begin_inset Formula $f(x2)\times f(x3)<0$
\end_inset
, then the root must be in
\begin_inset Formula $(x2,x3)$
\end_inset
and we replace the original bound
\begin_inset Formula $x1$
\end_inset
by
\begin_inset Formula $x3$
\end_inset
.
Otherwise, the root lies between
\begin_inset Formula $x1$
\end_inset
and
\begin_inset Formula $x3$
\end_inset
, in that case
\begin_inset Formula $x2$
\end_inset
is replaced by
\begin_inset Formula $x3$
\end_inset
.
This process is repeated until the interval has been reduced to the specified
value, say
\begin_inset Formula $\varepsilon$
\end_inset
.
\end_layout
\begin_layout Standard
The number of bisections required to reach a prescribed limit,
\begin_inset Formula $\varepsilon,$
\end_inset
is given by equation
\begin_inset LatexCommand ref
reference "eq:bisection"
\end_inset
.
\begin_inset Formula \begin{equation}
n=\frac{\ln(|\triangle x|)/\varepsilon}{\ln2}\label{eq:bisection}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The program
\shape italic
bisection.py
\shape default
finds the root of the equation
\begin_inset Formula $x^{3}-10x^{2}+5$
\end_inset
.
The starting values are found using the program
\shape italic
rootsearch.py
\shape default
.
The results are printed for two different accuracies.
\end_layout
\begin_layout Standard
\align left
\emph on
Example bisection.py
\end_layout
\begin_layout LyX-Code
import math def func(x):
\end_layout
\begin_layout LyX-Code
return x**3 - 10.0* x*x + 5
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def bisect(f, x1, x2, epsilon=1.0e-9):
\end_layout
\begin_layout LyX-Code
f1 = f(x1)
\end_layout
\begin_layout LyX-Code
f2 = f(x2)
\end_layout
\begin_layout LyX-Code
if f1*f2 > 0.0:
\end_layout
\begin_layout LyX-Code
print 'x1 and x2 are on the same side of x-axis'
\end_layout
\begin_layout LyX-Code
return
\end_layout
\begin_layout LyX-Code
n = math.ceil(math.log(abs(x2 - x1)/epsilon)/math.log(2.0))
\end_layout
\begin_layout LyX-Code
n = int(n)
\end_layout
\begin_layout LyX-Code
for i in range(n):
\end_layout
\begin_layout LyX-Code
x3 = 0.5 * (x1 + x2)
\end_layout
\begin_layout LyX-Code
f3 = f(x3)
\end_layout
\begin_layout LyX-Code
if f3 == 0.0: return x3
\end_layout
\begin_layout LyX-Code
if f2*f3 < 0.0:
\end_layout
\begin_layout LyX-Code
x1 = x3
\end_layout
\begin_layout LyX-Code
f1 = f3
\end_layout
\begin_layout LyX-Code
else:
\end_layout
\begin_layout LyX-Code
x2 = x3
\end_layout
\begin_layout LyX-Code
f2 = f3
\end_layout
\begin_layout LyX-Code
return (x1 + x2)/2.0
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print bisect(func, 0.70, 0.8, 1.0e-4)
\end_layout
\begin_layout LyX-Code
print bisect(func, 0.70, 0.8, 1.0e-9)
\end_layout
\begin_layout Subsection
Newton-Raphson Method
\end_layout
\begin_layout Standard
The Newton–Raphson algorithm requires the derivative of the function also
to evaluate the roots.
Therefore, it is usable only in problems where
\begin_inset Formula $f'(x)$
\end_inset
can be readily computed.
It does not require the value at two points to start with.
We start with an initial guess which is reasonably close to the true root.
Then the function is approximated by its tangent line and the x-intercept
of the tangent line is calculated.
This value is taken as the next guess and the process is repeated.
The Newton-Raphson formula is shown below.
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
x_{i+1}=x_{i}-\frac{f(x_{i})}{f'(x_{i})}\label{eq:Newton-Raphson}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
Figure
\begin_inset LatexCommand ref
reference "fig:NRplot"
\end_inset
(a) shows the graph of the quadratic equation
\begin_inset Formula $2x^{2}-3x-5=0$
\end_inset
and its two tangents.
It can be seen that the zeros are at x = -1 and x = 2.5, and we use the
program newraph.py shown below to find the roots.
The function nr() is called twice, and we get the roots nearer to the correspon
ding starting values.
\end_layout
\begin_layout Standard
\align left
\emph on
Example newraph.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
def f(x):
\end_layout
\begin_layout LyX-Code
return 2.0 * x**2 - 3*x - 5
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def df(x):
\end_layout
\begin_layout LyX-Code
return 4.0 * x - 3
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def nr(x, tol = 1.0e-9):
\end_layout
\begin_layout LyX-Code
for i in range(30):
\end_layout
\begin_layout LyX-Code
dx = -f(x)/df(x)
\end_layout
\begin_layout LyX-Code
#print x
\end_layout
\begin_layout LyX-Code
x = x + dx
\end_layout
\begin_layout LyX-Code
if abs(dx) < tol:
\end_layout
\begin_layout LyX-Code
return x
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
print nr(4)
\end_layout
\begin_layout LyX-Code
print nr(0)
\end_layout
\begin_layout Standard
The output is shown below.
\end_layout
\begin_layout Standard
2.5
\end_layout
\begin_layout Standard
-1.0
\end_layout
\begin_layout Standard
\align block
Uncomment the print statement inside nr() to view how fast this method converges
, compared to the bisection method.
The program newraph_plot.py, listed below is used for generating the figure
\begin_inset LatexCommand ref
reference "fig:NRplot"
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\emph on
Example newraph_plot.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
def f(x):
\end_layout
\begin_layout LyX-Code
return 2.0 * x**2 - 3*x - 5
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def df(x):
\end_layout
\begin_layout LyX-Code
return 4.0 * x - 3
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
vf = vectorize(f)
\end_layout
\begin_layout LyX-Code
x = linspace(-2, 5, 100)
\end_layout
\begin_layout LyX-Code
y = vf(x)
\end_layout
\begin_layout LyX-Code
# Tangents at x=3 and 4, using one point slope formula
\end_layout
\begin_layout LyX-Code
x1 = 4
\end_layout
\begin_layout LyX-Code
tg1 = df(x1)*(x-x1) + f(x1)
\end_layout
\begin_layout LyX-Code
x1 = 3
\end_layout
\begin_layout LyX-Code
tg2 = df(x1)*(x-x1) + f(x1)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
grid(True)
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
plot(x,tg1)
\end_layout
\begin_layout LyX-Code
plot(x,tg2)
\end_layout
\begin_layout LyX-Code
ylim([-20,40])
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
\align left
We have defined the function
\begin_inset Formula $f(x)=2x^{2}-3x-5$
\end_inset
and vectorized it.
The derivative
\begin_inset Formula $4x^{2}-3$
\end_inset
also is defined by
\begin_inset Formula $df(x)$
\end_inset
, which is the slope of
\begin_inset Formula $f(x)$
\end_inset
.
The tangents are drawn at
\begin_inset Formula $x=4$
\end_inset
and
\begin_inset Formula $x=3$
\end_inset
, using the point slope formula for a line
\begin_inset Formula $y=m(x-x1)+y1$
\end_inset
.
\end_layout
\begin_layout Section
System of Linear Equations
\end_layout
\begin_layout Standard
A system of
\begin_inset Formula $m$
\end_inset
linear equations with
\begin_inset Formula $n$
\end_inset
unknowns can be written in a matrix form and can be solved by using several
standard techniques like Gaussian elimination.
In this section, the matrix inversion method, using Numpy, is demonstrated.
For more information see reference
\begin_inset LatexCommand cite
key "Kiusalas"
\end_inset
.
\end_layout
\begin_layout Subsection
Equation solving using matrix inversion
\end_layout
\begin_layout Standard
Non-homogeneous matrix equations of the form
\begin_inset Formula $Ax=b$
\end_inset
can be solved by matrix inversion to obtain
\begin_inset Formula $x=A^{-1}b$
\end_inset
.
The system of equations
\end_layout
\begin_layout Standard
\align center
\begin_inset Formula $\begin{array}[b]{r}
4x+y\,-2z=0\\
2x-3y+3z=9\\
-6x-2y\,+z=0\end{array}$
\end_inset
\end_layout
\begin_layout Standard
can be represented in the matrix form as
\end_layout
\begin_layout Standard
\align center
\begin_inset Formula \begin{eqnarray*}
\left(\begin{array}{rrr}
4 & 1 & -2\\
2 & -3 & 3\\
-6 & -2 & 1\end{array}\right)\left(\begin{array}{c}
x\\
y\\
z\end{array}\right) & = & \left(\begin{array}{c}
0\\
9\\
0\end{array}\right)\end{eqnarray*}
\end_inset
\end_layout
\begin_layout Standard
and can be solved by finding the inverse of the coefficient matrix.
\end_layout
\begin_layout Standard
\begin_inset Formula \[
\left(\begin{array}{c}
x\\
y\\
z\end{array}\right)=\left(\begin{array}{rrr}
4 & 1 & -2\\
2 & -3 & 3\\
-6 & -2 & 1\end{array}\right)^{-1}\left(\begin{array}{c}
0\\
9\\
0\end{array}\right)\]
\end_inset
\end_layout
\begin_layout Standard
Using numpy we can solve this as shown in solve_eqn.py
\end_layout
\begin_layout Standard
\align left
Example solve_eqn.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
b = array([0,9,0])
\end_layout
\begin_layout LyX-Code
A = array([ [4,1,-2], [2,-3,3],[-6,-2,1]])
\end_layout
\begin_layout LyX-Code
print dot(linalg.inv(A),b)
\end_layout
\begin_layout Standard
The result will be [ 0.75 -2.
0.5 ], that means
\begin_inset Formula $x=0.75,y=-2,z=0.5$
\end_inset
.
This can be verified by substituting them back in to the equations.
\end_layout
\begin_layout Standard
Exercise: solve x+y+3z = 6; 2x+3y-4z=6;3x+2y+7z=0
\end_layout
\begin_layout Section
Least Squares Fitting
\end_layout
\begin_layout Standard
A mathematical procedure for finding the best-fitting curve
\begin_inset Formula $f(x)$
\end_inset
for a given set of points
\begin_inset Formula $(x_{n},y_{n})$
\end_inset
by minimizing the sum of the squares of the vertical offsets of the points
from the curve is called least squares fitting.
The least square fit is obtained by minimizing the function,
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
S(a_{0},a_{1},\ldots,a_{m})=\sum_{i=0}^{n}\left[y_{i}-f(x_{i})\right]^{2}\label{eq:Least square}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
with respect to each
\begin_inset Formula $a_{i}$
\end_inset
and the condition for that is
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
\frac{\partial S}{\partial a_{i}}=0,\,\,\,\,\, i=0,1,\ldots m\label{eq:LS2}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
For a linear fit, the equation is
\begin_inset Formula \[
f(a,b)=a+bx\]
\end_inset
\end_layout
\begin_layout Standard
Solving the equations
\begin_inset Formula $\frac{\partial S}{\partial a}=0$
\end_inset
and
\begin_inset Formula $\frac{\partial S}{\partial b}=0$
\end_inset
will give the result,
\begin_inset Formula \begin{equation}
b=\frac{\sum y_{i}(x-\overline{x})}{\sum x_{i}(x-\overline{x})},\,\,\,\, and\,\,\,\, a=\overline{y}-\overline{x}b\label{eq:LS3}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
where
\begin_inset Formula $\overline{x}$
\end_inset
and
\begin_inset Formula $\overline{y}$
\end_inset
are the mean values defined by the equations,
\begin_inset Formula \begin{equation}
\overline{x}=\frac{1}{n+1}\sum_{i=0}^{n}x_{i},\,\,\,\,\,\,\overline{y}=\frac{1}{n+1}\sum_{i=0}^{n}y{}_{i}\label{eq:LS4}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The program lsfit.py demonstrates the usage of equations
\begin_inset LatexCommand ref
reference "eq:LS3"
\end_inset
and
\begin_inset LatexCommand ref
reference "eq:LS4"
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/lsfit.png
lyxscale 50
width 7cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of lsfit.py
\begin_inset LatexCommand label
name "fig:Output-of-lsfit.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example lsfit.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
NP = 50
\end_layout
\begin_layout LyX-Code
r = 2*ranf([NP]) - 0.5
\end_layout
\begin_layout LyX-Code
x = linspace(0,10,NP)
\end_layout
\begin_layout LyX-Code
data = 3 * x + 2 + r
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
xbar = mean(x)
\end_layout
\begin_layout LyX-Code
ybar = mean(data)
\end_layout
\begin_layout LyX-Code
b = sum(data*(x-xbar)) / sum(x*(x-xbar))
\end_layout
\begin_layout LyX-Code
a = ybar - xbar * b
\end_layout
\begin_layout LyX-Code
print a,b
\end_layout
\begin_layout LyX-Code
y = a + b * x
\end_layout
\begin_layout LyX-Code
plot(x,y)
\end_layout
\begin_layout LyX-Code
plot(x,data,'ob')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
The raw data is made by adding random numbers (between -1 and 1) to the
\begin_inset Formula $y$
\end_inset
coordinates generated by
\begin_inset Formula $y=3*x+2$
\end_inset
.
The Numpy functions mean() and sum() are used.
The output is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-lsfit.py"
\end_inset
.
\end_layout
\begin_layout Section
Interpolation
\begin_inset LatexCommand label
name "sec:Interpolation"
\end_inset
\end_layout
\begin_layout Standard
Interpolation is the process of constructing a function
\begin_inset Formula $f(x)$
\end_inset
from a set of data points
\begin_inset Formula $(x_{i},y_{i})$
\end_inset
, in the interval
\begin_inset Formula $a
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $x_{0}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $x_{0}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{0}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $x_{1}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $y{}_{1}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
\begin_inset Formula $\left[y_{1}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{0},y_{1}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $x_{2}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $y_{2}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{2}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{1},y_{2}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{0},y_{1},y_{2}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $x_{3}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $y_{3}$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{3}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{2},y_{3}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{1},y_{2},y_{3}\right]$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\left[y_{0},y_{1},y_{2},y_{3}\right]$
\end_inset
\end_layout
\end_inset
\end_inset
\end_layout
\begin_layout Standard
\align center
\begin_inset Tabular
\begin_inset Text
\begin_layout Standard
0
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
0
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
1
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\frac{3-0}{1-0}=3$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
2
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
14
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\frac{14-3}{2-1}=11$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\frac{11-3}{2-0}=4$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
3
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
39
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\frac{39-14}{3-2}=25$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\frac{25-11}{3-1}=7$
\end_inset
\end_layout
\end_inset
\begin_inset Text
\begin_layout Standard
\begin_inset Formula $\frac{7-4}{3-0}=1$
\end_inset
\end_layout
\end_inset
\end_inset
\end_layout
\begin_layout Standard
The table given above shows the divided difference table for the data set
x = [0,1,2,3] and y = [0,3,14,39], calculated manually.
The program newpoly.py can be used for calculating the coefficients, which
prints the output [0, 3, 4, 1].
\end_layout
\begin_layout Standard
\align left
\emph on
Example newpoly.py
\end_layout
\begin_layout LyX-Code
from copy import copy
\end_layout
\begin_layout LyX-Code
def coef(x,y):
\end_layout
\begin_layout LyX-Code
a = copy(y)
\end_layout
\begin_layout LyX-Code
m = len(x)
\end_layout
\begin_layout LyX-Code
for k in range(1,m):
\end_layout
\begin_layout LyX-Code
tmp = copy(a)
\end_layout
\begin_layout LyX-Code
for i in range(k,m):
\end_layout
\begin_layout LyX-Code
tmp[i] = (a[i] - a[i-1])/(x[i]-x[i-k])
\end_layout
\begin_layout LyX-Code
a = copy(tmp)
\end_layout
\begin_layout LyX-Code
return a
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
x = [0,1,2,3]
\end_layout
\begin_layout LyX-Code
y = [0,3,14,39]
\end_layout
\begin_layout LyX-Code
print coef(x,y)
\end_layout
\begin_layout Standard
We start by copying the list
\begin_inset Formula $y$
\end_inset
to coefficient
\begin_inset Formula $a$
\end_inset
, the first element
\begin_inset Formula $a_{0}=y_{0}$
\end_inset
.
While calculating the differences, we have used two loops and a temporary
list.
The same can be done in a better way using arrays of Numpy
\begin_inset Foot
status collapsed
\begin_layout Standard
This function is from reference
\begin_inset LatexCommand cite
key "Kiusalas"
\end_inset
, some PDF versions of this book are available on the web.
\end_layout
\end_inset
, as shown in newpoly2.py.
\end_layout
\begin_layout Standard
\align left
\emph on
Example newpoly2.py
\end_layout
\begin_layout LyX-Code
from numpy import *
\end_layout
\begin_layout LyX-Code
def coef(x,y):
\end_layout
\begin_layout LyX-Code
a = copy(y)
\end_layout
\begin_layout LyX-Code
m = len(x)
\end_layout
\begin_layout LyX-Code
for k in range(1,m):
\end_layout
\begin_layout LyX-Code
a[k:m] = (a[k:m] - a[k-1])/(x[k:m]-x[k-1])
\end_layout
\begin_layout LyX-Code
return a
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
x = array([0,1,2,3])
\end_layout
\begin_layout LyX-Code
y = array([0,3,14,39])
\end_layout
\begin_layout LyX-Code
print coef(x,y)
\end_layout
\begin_layout Standard
The next step is to calculate the value of
\begin_inset Formula $y$
\end_inset
for any given value of
\begin_inset Formula $x$
\end_inset
, using the coefficients already calculated.
The program
\shape italic
newinterpol.py
\shape default
calculates the coefficients using the four data points.
The function eval() uses the recurrence relation
\end_layout
\begin_layout Standard
\begin_inset Formula \begin{equation}
P_{k}(x)=a_{n-k}+(x-x_{n-k})P_{k-1}(x),\,\,\,\, k=1,2,\ldots n\label{eq:NPrecur}\end{equation}
\end_inset
\end_layout
\begin_layout Standard
The program generates 20 new values of
\begin_inset Formula $x$
\end_inset
, and calculate corresponding values of
\begin_inset Formula $y$
\end_inset
and plots them along with the original data points, as shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-newton_in3.py"
\end_inset
.
\end_layout
\begin_layout Standard
\align left
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/newton_in3.png
lyxscale 50
width 8cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Output of newton_in3.py
\begin_inset LatexCommand label
name "fig:Output-of-newton_in3.py"
\end_inset
\end_layout
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\align left
\emph on
Example newinterpol.py
\end_layout
\begin_layout LyX-Code
from pylab import *
\end_layout
\begin_layout LyX-Code
def eval(a,xpoints,x):
\end_layout
\begin_layout LyX-Code
n = len(xpoints) - 1
\end_layout
\begin_layout LyX-Code
p = a[n]
\end_layout
\begin_layout LyX-Code
for k in range(1,n+1):
\end_layout
\begin_layout LyX-Code
p = a[n-k] + (x -xpoints[n-k]) * p
\end_layout
\begin_layout LyX-Code
return p
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
def coef(x,y):
\end_layout
\begin_layout LyX-Code
a = copy(y)
\end_layout
\begin_layout LyX-Code
m = len(x)
\end_layout
\begin_layout LyX-Code
for k in range(1,m):
\end_layout
\begin_layout LyX-Code
a[k:m] = (a[k:m] - a[k-1])/(x[k:m]-x[k-1])
\end_layout
\begin_layout LyX-Code
return a
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
x = array([0,1,2,3])
\end_layout
\begin_layout LyX-Code
y = array([0,3,14,39])
\end_layout
\begin_layout LyX-Code
coef = coef(x,y)
\end_layout
\begin_layout LyX-Code
\end_layout
\begin_layout LyX-Code
NP = 20
\end_layout
\begin_layout LyX-Code
newx = linspace(0,3, NP) # New x-values
\end_layout
\begin_layout LyX-Code
newy = zeros(NP)
\end_layout
\begin_layout LyX-Code
for i in range(NP): # evaluate y-values
\end_layout
\begin_layout LyX-Code
newy[i] = eval(coef, x, newx[i])
\end_layout
\begin_layout LyX-Code
plot(newx, newy,'-x')
\end_layout
\begin_layout LyX-Code
plot(x, y,'ro')
\end_layout
\begin_layout LyX-Code
show()
\end_layout
\begin_layout Standard
You may explore the results for new points outside the range by changing
the second argument of line
\shape italic
newx = linspace(0,3,NP)
\shape default
to a higher value.
\end_layout
\begin_layout Standard
Look for similarities between Taylor's series discussed in section
\begin_inset LatexCommand ref
reference "sub:Taylor's-Series"
\end_inset
that and polynomial interpolation process.
The derivative of a function represents an infinitesimal change in the
function with respect to one of its variables.
The finite difference is the discrete analog of the derivative.
Using the divided difference method, we are in fact calculating the derivatives
in the discrete form.
\end_layout
\begin_layout Section
Exercises
\end_layout
\begin_layout Enumerate
Differentiate
\begin_inset Formula $5x^{2}+3x+5$
\end_inset
numerically and evaluate at
\begin_inset Formula $x=2$
\end_inset
and
\begin_inset Formula $x=-2$
\end_inset
.
\end_layout
\begin_layout Enumerate
Write code to numerically differentiate
\begin_inset Formula $\sin(x^{2})$
\end_inset
and plot it by vectorizing the function.
Compare with the analytical result.
\end_layout
\begin_layout Enumerate
Integrate
\begin_inset Formula $\ln x$
\end_inset
,
\begin_inset Formula $e^{x}$
\end_inset
from
\begin_inset Formula $x=1$
\end_inset
to
\begin_inset Formula $2$
\end_inset
.
\end_layout
\begin_layout Enumerate
Solve
\begin_inset Formula $2x+y=3;-x+4y=0;3+3y=-1$
\end_inset
using matrices.
\end_layout
\begin_layout Enumerate
Modify the program julia.py,
\begin_inset Formula $c=0.2-0.8j$
\end_inset
and
\begin_inset Formula $z=z^{6}+c$
\end_inset
\end_layout
\begin_layout Enumerate
Write Python code, using pylab, to solve the following equations using matrices
\newline
\begin_inset Formula $\begin{array}[b]{r}
4x+y\,-2z=0\\
2x-3y+3z=9\\
-6x-2y\,+z=0\end{array}$
\end_inset
\end_layout
\begin_layout Enumerate
Find the roots of
\begin_inset Formula $5x^{2}+3x-6$
\end_inset
using bisection method.
\end_layout
\begin_layout Enumerate
Find the all the roots of
\begin_inset Formula $sin(x)$
\end_inset
between 0 and 10, using Newton-Raphson method.
\end_layout
\begin_layout Chapter*
Appendix A : Installing GNU/Linux
\begin_inset ERT
status collapsed
\begin_layout Standard
\backslash
addcontentsline{toc}{chapter}{Appendix A}
\end_layout
\end_inset
\begin_inset ERT
status collapsed
\begin_layout Standard
\backslash
markboth{Appendix A}{Installing Ubuntu}
\end_layout
\end_inset
\end_layout
\begin_layout Standard
Programming can be learned better by practicing and it requires an operating
system, and Python interpreter along with some library modules.
All these requirements are packaged on the Live CD comes along with this
book.
You can boot any PC from this CD and start working.
However, it is better to install the whole thing to a harddisk.
The following section explains howto install GNU/Linux.
We have selected the Ubuntu distribution due to its relatively simple installat
ion procedure, ease of maintenanace and support for most of the hardware
available in the market.
\end_layout
\begin_layout Section
Installing Ubuntu
\end_layout
\begin_layout Standard
Most of the users prefer a dual boot system, to keep their MSWindows working.
We will explain the installation process keeping that handicap in mind.
All we need is an empty partition of minimum 5 GB size to install Ubuntu.
Free space inside a Windows partition will not do, we need to format the
partition to install Ubuntu.
The Ubuntu installer will make the system multi-boot by searching through
all the partitions for installed operating systems.
\end_layout
\begin_layout Standard
\align left
\shape italic
\bar under
The System
\end_layout
\begin_layout Standard
This section will describe how Ubuntu was installed on a system, with MSWindows,
having the following partitions:
\end_layout
\begin_layout Standard
C: (GNU/Linux calls it /dev/sda1) 20 GB
\end_layout
\begin_layout Standard
D: ( /dev/sda5) 20 GB
\end_layout
\begin_layout Standard
E: (/dev/sda6) 30 GB
\end_layout
\begin_layout Standard
We will use the partition E: to install Ubuntu, it will be formatted.
\end_layout
\begin_layout Standard
\align left
\shape italic
\bar under
The Procedure
\end_layout
\begin_layout Standard
Set the first boot device CD ROM from the BIOS.
Boot the PC from the Ubuntu installation CD, we have used Phoenix Live
CD (a modified version on Ubuntu 9.1).
After 2 to 3 minutes a desktop as shown below will appear.
Click on the Installer icon, the window shown next will pop up.
Screens will appear to select the language, time zone and keyboard layout
as shown in the figures below.
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/desktop.png
lyxscale 30
width 6cm
\end_inset
\begin_inset Graphics
filename pics/inst1.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/inst2.png
lyxscale 50
width 6cm
\end_inset
\begin_inset Graphics
filename pics/inst3.png
lyxscale 50
width 6cm
\end_inset
\end_layout
\begin_layout Standard
Now we proceed to the important part, choosing a partition to install Ubuntu.
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/inst_disk1.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
The bar on the top graphically displays the existing partitions.
Below that there are three options provided :
\end_layout
\begin_layout Enumerate
Install them side by side.
\end_layout
\begin_layout Enumerate
Erase and use the entire disk.
\end_layout
\begin_layout Enumerate
Specify partitions manually.
\end_layout
\begin_layout Standard
If you choose the first option, the Installer will resize and repartition
the disk to make some space for the new system.
By default this option is marked as selected.
The bar at the bottom shows the proposed partition scheme.
In the present example, the installer plans to divide the C: drive in to
two partitions to put ubuntu on the second.
\end_layout
\begin_layout Standard
We are going to choose the third option, choose the partition manually.
We will use the last partition (drive E: ) for installing Ubuntu.
Once you choose that and click forward, a screen will appear where we can
add, delete and change partitions.
We have selected the third partition and clicked on Change.
A pop-up window appeared.
Using that we selected the file-system type to ext3, marked the format
option, and selected the mount point as / .
The screen with the pop-up window is shown below.
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/inst_disk2.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
\align left
If we proceed with this, a warning will appear complaining about the absence
of swap partitions.
The swap partition is used for supplementing the RAM with some virtual
memory.
When RAM is full, processes started but not running will be swapped out.
One can install a system without swap partition but it is a good idea to
have one.
\end_layout
\begin_layout Standard
We decide to go back on the warning, to delete the E: drive, create two
new partitions in that space and make one of them as swap.
This also demonstrates how to make new partitions.
The screen after deleting E: , with the pop-up window to make the swap
partition is shown below.
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/inst_makeswap.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
We made a 2 GB swap.
The remaining space is used for making one more partition, as shown in
the figure
\begin_inset LatexCommand ref
reference "fig:Making-the-partition"
\end_inset
.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/inst_disk3.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Making the partition to install Ubuntu
\begin_inset LatexCommand label
name "fig:Making-the-partition"
\end_inset
.
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
Once disk partitioning is over, you will be presented with a screen to enter
a user name and password.
\begin_inset Foot
status collapsed
\begin_layout Standard
All GNU/Linux installations ask for a root password during installation.
For simplicity, Ubuntu has decided to hide this information.
The first user created during installation has special privileges and that
password is asked, instead of the root password, for all system administration
jobs, like installing new software.
\end_layout
\end_inset
A warning will be issued if the password is less than 8 characters in length.
You will be given an option to import desktop settings from other installations
already on the disk, choose this if you like.
The next screen will confirm the installation.
After the installation is over, mat take 10 to 15 minutes, you will be
prompted to reboot the system.
On rebooting you will be presented with a menu, to choose the operating
system to boot.
First item in the menu will be the newly installed Ubuntu.
\end_layout
\begin_layout Section
Package Management
\end_layout
\begin_layout Standard
The Ubuntu install CD contains some common application programs like web
browser, office package, document viewer, image manipulation program etc.
After installing Ubuntu, you may want to add more applications.
The Ubuntu repository has an enormous number of packages, that can be installed
very easily.
You need to have a reasonably fast Internet connection for this purpose.
\end_layout
\begin_layout Standard
From the main menu, open System->Administration->Synaptic package manager.
After providing the pass word (of the first user, created during installation),
the synaptic window will popup as shown in figure
\begin_inset LatexCommand ref
reference "fig:Synaptic-package-manager"
\end_inset
.
\end_layout
\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/synaptic1.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
\begin_inset Caption
\begin_layout Standard
Synaptic package manager window
\begin_inset LatexCommand label
name "fig:Synaptic-package-manager"
\end_inset
\end_layout
\end_inset
\end_layout
\begin_layout Standard
\end_layout
\end_inset
\end_layout
\begin_layout Standard
Select Settings->Repositories to get a pop-up window as shown below.
Tick the four repositories, close the pop-up window and Click on Reload.
Synaptic will now try to download the index files from all these repositories.
It may take several minute.
\end_layout
\begin_layout Standard
\align center
\begin_inset Graphics
filename pics/synaptic2.png
lyxscale 50
width 12cm
\end_inset
\end_layout
\begin_layout Standard
Now, you are ready to install any package from the Ubuntu repository.
Search for any package by name, from these repositories, and install it.
If you have done the installation from original Ubuntu CD, you may require
the following packges:
\end_layout
\begin_layout Itemize
lyx : A latex front-end.
Latex will be installed since lyx dpends on latex.
\end_layout
\begin_layout Itemize
python-matplotlib : The graphics library
\end_layout
\begin_layout Itemize
python-visual : 3D graphics
\end_layout
\begin_layout Itemize
python-imaging-tk : Tkinter, Python Imaging Library etc.
will be installed
\end_layout
\begin_layout Itemize
build-essential : C compiler and related tools.
\end_layout
\begin_layout Subsection
Install from repository CD
\end_layout
\begin_layout Standard
We can also install packages from repository CDs.
Insert the CD in the drive and Select Add CDROM from the Edit menu of Synaptic.
Now all the packages on the CD will be available for search and install.
\end_layout
\begin_layout Subsubsection
Installing from the Terminal
\end_layout
\begin_layout Standard
You can install packages from the terminal also.
You have to become the root user by giving the sudo command;
\end_layout
\begin_layout Standard
$ sudo -s
\end_layout
\begin_layout Standard
enter password :
\end_layout
\begin_layout Standard
#
\end_layout
\begin_layout Standard
Note that the prompt changes from $ to #, when you become root.
\end_layout
\begin_layout Standard
Install packages using the command :
\end_layout
\begin_layout Standard
#apt-cdrom add
\end_layout
\begin_layout Standard
#apt-get install mayavi2
\end_layout
\begin_layout Subsection
Behind the scene
\end_layout
\begin_layout Standard
Even though there are installation programs that performs all these steps
automatically,it is better to know what is really happening.
Installing an operating system involves;
\end_layout
\begin_layout Itemize
Partitioning of the hard disk
\end_layout
\begin_layout Itemize
Formatting the partitions
\end_layout
\begin_layout Itemize
Copying the operating system files
\end_layout
\begin_layout Itemize
Installing a boot loader program
\end_layout
\begin_layout Standard
The storage space of a hard disk drive can be divided into separate data
areas, known as partitions.
You can create primary partitions and extended partitions.
Logical drives (secondary partitions can be created inside the extended
partitions).
On a disk, you can have up to 4 partitions, where one of them could be
an extended partition.
You can have many logical drives inside the extended partition.
\end_layout
\begin_layout Standard
On a MSWindows system, the primary partition is called the C: drive.
The logical drives inside the extended partition are named from D: onwards.
GNU/Linux uses a different naming convention.
The individual disks are named as /dev/sda , /dev/sdb etc.
and the partitions inside them are named as /dev/sda1, /dev/sda2 etc.
The numbering of secondary partitions inside the logical drive starts at
/dev/sda5.
(1 to 4 are reserved for primary and extended).
Hard disk partitioning can be done using the fdisk program.
The installation program also does this for you.
\end_layout
\begin_layout Standard
The process of making a file system on a partition is called formatting.
There are many different types of file systems.
MSWindows use file systems like FAT32, NTFS etc.
and GNU/Linux mostly uses file systems like ext3, ext4 etc.
\end_layout
\begin_layout Standard
The operating system files are kept in directories named boot, sbin, bin,
etc etc.
The kernel that loads while booting the system is kept in /boot.
The configuration files are kept in /etc.
/sbin and /bin holds programs that implements many of the shell commands.
Most of the application programs are kept in /usr/bin area.
\end_layout
\begin_layout Standard
The boot loader program is the one provides the selection of OS to boot,
when you power on the system.
GRUB is the boot loader used by most of the GNU/Linux systems.
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "2"
key "wikipedia"
\end_inset
http://en.wikipedia.org/wiki/List_of_curves
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "3"
key "gap-system"
\end_inset
http://www.gap-system.org/~history/Curves/Curves.html
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "4"
key "ellipse"
\end_inset
http://www.gap-system.org/~history/Curves/Ellipse.html
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "5"
key "wolfram"
\end_inset
http://mathworld.wolfram.com/
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "6"
key "numpy examples"
\end_inset
http://www.scipy.org/Numpy_Example_List
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "7"
key "scipy/doc"
\end_inset
http://docs.scipy.org/doc/
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "8"
key "Numerical Integration"
\end_inset
http://numericalmethods.eng.usf.edu/mws/gen/07int/index.html
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "9"
key "fractals"
\end_inset
http://www.angelfire.com/art2/fractals/lesson2.htm
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "10"
key "numerical recepies"
\end_inset
http://www.fizyka.umk.pl/nrbook/bookcpdf.html
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "11"
key "mathcs.emory"
\end_inset
http://www.mathcs.emory.edu/ccs/ccs315/ccs315/ccs315.html
\end_layout
\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "12"
key "Kiusalas"
\end_inset
Numerical Methods in Engineering with Python by Jaan Kiusalaas
\end_layout
\end_body
\end_document
pycode-browser-1.02/pybooksrc/pics/ 0000775 0000000 0000000 00000000000 12544046010 0017345 5 ustar 00root root 0000000 0000000 pycode-browser-1.02/pybooksrc/pics/archi.png 0000775 0000000 0000000 00000244277 12544046010 0021164 0 ustar 00root root 0000000 0000000 PNG
IHDR X vp sBIT|d pHYs a a?i IDATx{\WtN)9 6sP˘l6f3299r#D!D|>]i1}}xs_]T9鈢(H
t."""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R"""""R""*/W^033C5"88?~011F2ǝ:u
͚51,UDD$#""*Pt ;v@E{ )ulPP;;;߿˗/{丬,xxxHMMŔ)Suz鈢(]i{֭[ 77o&x
={: //]Zѹsg^9 88ƍ˗ ׯ_qm5uDD.!"r9w}ݒ ; @\\.]Ç puuE&MgϞΝ;8q222qF4iD}_]5 ""PTTT*|<-<< jժ̱-[,5gsE>}P(ШQ#9rDE_iQ8::p.Ο? HII)¢9,,,JjҤIx1F|"" DDT.ƍ͛71yd 11ƍý{ pS>i/'"r9r$.\
~zɪU 0 eΑZ<UM DDTnӦMCJJ
3g 55h߾= տݸqy""@xvO?իW t۶m %;wC҉Hp""*7obpqqnܸ'OqɱAAAx/>}:jժK.A___Ư BDDѣGC
Ga022*s1k,nnnXd j-CDD)@Hm8ԆԆԆԆԆԆԆԆԆԆԆԆԆԆԆԦ),,D$%%!55HKKCFF233l塰(BX .ttt``` ###F033C͚5QV-XXXVVV6l3DD@|DDD <<QQQw␘dgg#?? \::: z%B:::%a$//b_WWիWG5`ii kkk888Ahܸ1CCÊHtħ/OQ'O"88ׯ_Gtt4`CCCԨQFѸqc888v%=ְJjǏXT{.~M055
5jVZK.֭TR;8y$^۷o#..P(5665LLLмys4oM6E-Ú
ׯݻAll,bbbc:ZjY&ѬY3m\\\˩DD BDAw^;wHII
`aah߾=GG*S-"""pI\t aaax!rrrPXXXr,--ѴiSt[oUDD BDA^6tuuaii͛sѣ:u9`9rHLLDzzzɰ.""c !"Bݻ燐$$$
kFfoch>-A+Ww^