## Thursday, June 30, 2011

### Animation with matplotlib, bringin the Sierpinski triangle to life

Few post ago we have seen how to plot the Sierpinski triangle. This post is an update that shows how to create an animation where at each step a new point of the fractal is plotted:
```from numpy import *
import pylab

x = [0, 0];

A = [ [.5, 0], [0, .5] ];
b1 = [0, 0];
b2 = [.5, 0];
b3 = [.25, sqrt(3)/4];

pylab.ion() # animation on

#Note the comma after line. This is placed here because plot returns a list of lines that are drawn.
line, = pylab.plot(x[0],x[1],'m.',markersize=6)
pylab.axis([0,1,0,1])

data1 = []
data2 = []
iter = 0

while True:
r = fix(random.rand()*3)
if r==0:
x = dot(A,x)+b1
if r==1:
x = dot(A,x)+b2
if r==2:
x = dot(A,x)+b3
data1.append(x[0])
data2.append(x[1])
line.set_xdata(data1)  # update the data
line.set_ydata(data2)
pylab.draw() # draw the points again
iter += 1
print iter
```
This is the result:

## Tuesday, June 28, 2011

### Searching for IP address using regular expression

This snippet finds an IP address in a string using regex:
```import re
ip = re.compile('(([2][5][0-5]\.)|([2][0-4][0-9]\.)|([0-1]?[0-9]?[0-9]\.)){3}'
+'(([2][5][0-5])|([2][0-4][0-9])|([0-1]?[0-9]?[0-9]))')

if match:
print match.group(), # matching substring
print 'at position',match.span() # indexes of the substring found
else:
```
The output will be
```IP address found: 192.168.0.1 at position (19, 30)
```

## Thursday, June 9, 2011

### Crawling the web with SGMLParser

In this example we will use SGMLParser in order to build a simple web crawler.
```import urllib
from random import choice
from sgmllib import SGMLParser

def reset(self):
SGMLParser.reset(self)
self.links = [] # list with the urls

def start_a(self, attrs):
for k in attrs:
if k[0] == 'href' and k[1].startswith('http'):

def explore(parser,s_url,maxvisit=10,iter=0):
""" pick a random link in the page s_url
if iter < maxvisit: # it will stop after maxvisit iteration
print '(',iter,') I am in',s_url
parser.reset() # reset the list
parser.feed(usock.read()) # parse the current page
else: # if the page has no links to follow
print 'the page has no links'

# test the crawler starting from the python's website
explore(parser,"http://www.python.org/")
```
Let's go!
```( 0 ) I am in http://www.python.org/
( 1 ) I am in http://wiki.python.org/moin/NumericAndScientific
( 2 ) I am in http://numpy.scipy.org/
( 3 ) I am in http://sphinx.pocoo.org/
( 4 ) I am in http://www.bitbucket.org/birkenfeld/sphinx/issues/
( 5 ) I am in http://blog.bitbucket.org
( 6 ) I am in http://haproxy.1wt.eu/
( 7 ) I am in http://www.olivepeak.com/blog/posts/read/free-your-port-80-with-haproxy
( 8 ) I am in http://www.olivepeak.com/peaknotes/
( 9 ) I am in http://notes.olivepeak.com/account/create
```

## Tuesday, June 7, 2011

### Sierpinski fractal

As described in the introduction of Numerical Computing in Matlab we can generate fractals using affine transformations. The following script uses it to generate the famous Sierpinski triangle:
```from numpy import *
import pylab

x = [0, 0];

A = [ [.5, 0], [0, .5] ];
b1 = [0, 0];
b2 = [.5, 0];
b3 = [.25, sqrt(3)/4];

for i in range(3000): # 3000 points will be generated
r = fix(random.rand()*3)
if r==0:
x = dot(A,x)+b1
if r==1:
x = dot(A,x)+b2
if r==2:
x = dot(A,x)+b3
pylab.plot(x[0],x[1],'m.',markersize=2)

pylab.show()
```
It will take a while, here's the result

## Friday, June 3, 2011

### The Collatz conjecture

The Collatz conjecture is a famous unsolved problem in number theory. Start with any
positive integer n. Repeat the following steps:
• If n = 1, stop.
• If n is even, replace it with n/2.
• If n is odd, replace it with 3n + 1

The unanswered question is, does the process always terminate?

Let to see a script that generate the sequence of number involved by the algorithm:

```import sys
from pylab import *

# take n from the command line
n = int(sys.argv[1])

i = 0
old_n = n
while n > 1:
if n%2 == 0: # if n is even
n = n/2
else:
n = 3*n+1
i += 1;
plot([i-1, i],[old_n,n],'-ob')
old_n = n

title('hailstone sequence for '+sys.argv[1]+', length is '+str(i))
show()
```
The script will plot the sequence:
`\$ python collatz.py 25`

The Collatz conjecture is is also known as the 3n + 1 conjecture, the Ulam conjecture, Kakutani's problem, the Thwaites conjecture, Hasse's algorithm, or the Syracuse problem; the sequence of numbers involved is referred to as the hailstone sequence or hailstone numbers, or as wondrous numbers.

References

## Thursday, June 2, 2011

### Integration of a function using quad from scipy

Example of integration of a function using scipy:
```from scipy.integrate import quad

f = lambda x: 4-x*x # function to integrate
p = lambda x: (-x*x*x)/3 + 4*x # the primitive of f

# let's try to integrate f in the interval [0 2]
r_analytic = p(2.0)-p(0.0) # analytic integration

print 'Results'
print r[0]
print r_analytic
```
Numerical and analytic result compared:
```Results
5.33333333333
5.33333333333
```