In [1]:

    

# Math libraries
import numpy as np
from math import sqrt

# Matplotlib plotting libraries
import matplotlib.pyplot as plt
%matplotlib inline

# Bokeh plotting libraries
import bokeh.plotting as blt
blt.output_notebook()


    

    





    
        
        
        
    

        
        BokehJS successfully loaded.
    

In [2]:

    

class JuliaSet(object):

    def __init__(self,c,n=100):
        self.c = c
        self.n = n
        self._d = 0.001
        self._complexplane = np.array([])
        self.set = np.array([])

    def juliamap(self,z):
        return z**2 + self.c

    def iterate(self,z):
        m=0
        while True:
            z=self.juliamap(z)
            m=m+1
            if abs(z)>2:
                return m
            if m>=self.n:
                return 0

    def set_spacing(self,d):
        self._d=d
        t=np.arange(-2,2,self._d)
        self._complexplane=[complex(x,y) for x in t for y in t]

    def generate(self):
        self.set=[self.iterate(a) for a in self._complexplane]
        return self.set


    

In [3]:

    

class JuliaSetPlot(JuliaSet):
    """Extend JuliaSet to add plotting functionality"""
    
    def __init__(self, *args, **kwargs):
        # Invoke constructor for JuliaSet first, unaltered
        super(JuliaSetPlot, self).__init__(*args, **kwargs)
        # Add one more attribute: a rendered image array
        self.img = np.array([])
    
    def get_dim(self):
        # get what should be an attribute
        return int(sqrt(self.img.size)) #int(4.0 / self._d)
    
    def render(self):
        if not self.set: self.generate()
        # Convert inefficient list to efficient numpy array
        self.img = np.array(self.set)
        dim = self.get_dim()
        # Reshape array into a 2d complex plane
        self.img = np.reshape(self.img, (dim,dim)).T
        
    def show(self):
        if not self.img.size: self.render()
        # Specify complex plane axes efficiently
        xy = np.linspace(-2,2,self.get_dim())
        # Use matplotlib to plot image as an efficient mesh
        plt.figure(1, figsize=(12,9))
        plt.pcolormesh(xy,xy,self.img, cmap=plt.cm.hot)
        plt.colorbar()
        plt.show()
        
    def interact(self):
        from matplotlib.colors import rgb2hex
        if not self.img.size: self.render()
        # Mimic matplotlib "hot" color palette
        colormap = plt.cm.get_cmap("hot")
        bokehpalette = [rgb2hex(m) for m in colormap(np.arange(colormap.N))]
        # Use bokeh to plot an interactive image
        f = blt.figure(x_range=[-2,2], y_range=[-2,2], plot_width=600, plot_height=600)
        f.image(image=[j.img], x=[-2,2], y=[-2,2], dw=[4], dh=[4], palette=bokehpalette)
        blt.show(f)


    

In [4]:

    

j = JuliaSetPlot(-1.037 + 0.17j)
%time j.set_spacing(0.006)
print len(j._complexplane)
print sqrt(len(j._complexplane))
%time j.show()


    

    




CPU times: user 376 ms, sys: 0 ns, total: 376 ms
Wall time: 519 ms
444889
667.0






    













    




CPU times: user 5.8 s, sys: 464 ms, total: 6.27 s
Wall time: 10.9 s

In [5]:

    

j = JuliaSetPlot(-0.624 + 0.435j)
%time j.set_spacing(0.006)
%time j.generate()
%time j.interact()


    

    




CPU times: user 364 ms, sys: 16 ms, total: 380 ms
Wall time: 791 ms
CPU times: user 4.58 s, sys: 8 ms, total: 4.58 s





    




ERROR:/projects/sage/sage-6.9/local/lib/python2.7/site-packages/bokeh/validation/check.pyc:E-1000 (COLUMN_LENGTHS): ColumnDataSource column lengths are not all the same: ColumnDataSource, ViewModel:ColumnDataSource, ref _id: e5ad776e-ae91-45ab-802c-8b2b9425faa9






    




Wall time: 5.25 s






    















    




CPU times: user 440 ms, sys: 80 ms, total: 520 ms
Wall time: 994 ms

In [ ]: