Algorithm Blogs » fractal

Fractals in 10 minutes No. 5: Sierpinski Chaos Game

lorg — Thu, 25 Dec 2008 07:44:55 +0000

A few years back, I was in some course where they also taught me some Matlab. One of the exercises was to draw the Sierpinski triangle using a method of progressing a point randomly. I was quite surprised at the time, because I thought the Sierpinski triangle was more of an analytical thing: you drew it using inverted triangles.

I wanted to check up on it, and it turns out the method has a name: Chaos Game.
To generate a Sierpinski triangle using this method, one starts with a some point inside the triangle. Then, at each step, the next point is half the distance from the current point to one of the corners selected at random. I think this method of generating the Sierpinski triangle is even easier than the analytical one.

I used pylab (matplotlib) to create this image.
As I usually do, I also wanted to draw it using ascii-art. However, I must confess, I am not satisfied with the result:

              %6
             6*%8
            %8  66
           %6%*6%%6
          6%'    '66
         6866'  '6%86
        %6* 86 '%8 *66
       %**%%'***%6***%%
      8'6            6*8
     6%%*8          %*'*6
    6%6'666        86# 86%
   %%*''**%6      %**''*'%6
  *%8'   '6%6    668'   '#%%
 %% '6' '#*'6%  *% %8' '6''6*
%68%#6#*#68*86*%6#%8%8'6%6*6%*

The code isn’t really good, as I didn’t put much thought into it and just hacked it up. Still, I’m putting it up, and I might improve it someday.

Fractals in 10 minutes No. 4: Mandelbrot and Julia in Ascii Art

lorg — Wed, 10 Dec 2008 10:06:36 +0000

I felt like it's about time I tackled the Mandelbrot and Julia sets, in Ascii-Art. Heck, the Mandelbrot fractal is on the logo of this Blog! However, being the most well-known fractal, this issue was tackled already, with satisfactory results.

Still, I took the ten minutes required to draw them in Python, using numpy:

def get_mandelbrot(x, num_iter = 10):
c = x
for i in range(num_iter):
x = x**2 + c
return abs(x)>2

def get_julia(x, c, num_iter = 10):
for i in range(num_iter):
x = x**2 + c
return abs(x)>2

"Hey!" you might say, "There's no loop in here!". Indeed, with numpy loops can sometimes be avoided, when using arrays. When the expression x**2 + c is applied to an array x, it is applied element-wise, allowing for implicit loops. The actual magic happens in the following function:

def get_board(bottom_left, top_right, num_x, num_y):
x0, y0 = bottom_left
x1, y1 = top_right
x_values = numpy.arange(x0, x1, (x1-x0)/float(num_x))
y_values = numpy.arange(y0, y1, (y1-y0)/float(num_y))
return numpy.array([[x+1j*y for x in x_values] for y in y_values])

The result of get_board will be used as the "x input" later on. It should be noted though that while that's a cute trick this time, it might grow unhandy for more complicated computations. For example, making each element to reflect the iteration number on which it "escaped".
So, here are the results:

############################   ##############
###########################   ###############
##########################     ##############
#####################                ########
####################                #########
############ #######                 ########
############                         ########
#########                           #########
#########                           #########
############                         ########
############ #######                 ########
####################                #########
#####################                ########
##########################     ##############
###########################   ###############

############################################################
############################################################
############################################################
############################ ###############################
######################### ##   #############################
############## #######           ###########################
######## ##      ###              ##########  ##############
#########  ###        ###         ######       #############
##############       ######         ###        ###  ########
###############  ##########              ###      ## #######
############################           ####### #############
##############################   ## ########################
################################ ###########################
############################################################
############################################################

Here's the code. (With the usual bsd-license slapped on top of it :)

Fractals in 10 minutes no. 3 – The Dragon

lorg — Wed, 16 Jan 2008 20:12:33 +0000

When first I looked through the pages of the book "Hacker's Delight", I found myself looking at the chapter about bases. There I learned a very curious fact - with the digits of 0,1 and the base of -2, you can represent any integer. Right afterwards I learned something even more interesting - with the digits of 0,1 and the base of 1-i, you can represent and number of the form a+bi where a and b are integers. Having nothing to do with this curious fact, I let the subject go.
Some time later, I was reading through Knuth's "Art of Computer Programming", and found that with the base of (1-i)^-1, and digits of 0,1 you can generate the dragon fractal!

Generating the fractal is quite simple actually:

def create_dragon_set(n):
"""calculate the dragon set, according to Knuth"""
s = set([0.0+0.0j])
for i in range(n):
new_power = (1.0-1.0j)**(-i)
s |= set(x+new_power for x in s)
return s

(By the way, can you do it better?)

The annoying part is converting the complex numbers to drawable integer points. After doing so, I used PIL to draw the jpeg.
Here's a link to the code.