In [1]:
# Math libraries
import numpy as np
import math
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 = .001
        self.set = np.array([])
    
    def juliamap(self, z):
        return z ** 2 + self.c
    
    def iterate(self, z):
        for m in np.arange(1, self.n+1):
            z = self.juliamap(z)
            if abs(z) > 2:
                return m
        return 0
    
    
    def setcomplexplane(self, _d, r=-2, r1=2):
        plane = np.arange(r,r1,self._d)
        plane = np.append(plane, 2)
        x, y = np.meshgrid(plane, plane)
        z = x + y*1j
        self._complexplane = z
        
        
    def set_spacing(self, d, r=-2, r1=2):
        self._d = d
        self.setcomplexplane(d, r=-2, r1=2)
        
    
    def generate(self):
        i = np.vectorize(self.iterate)
        self.set = i(self._complexplane)
        return self.set

To improve the speed of JuliaSet I used meshgrid to evaluate the complexplane without any loops so the complexplane would be generated faster. I also changed the generate function to vectorize the iterate function and apply it to the complexplane instead of using loops


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(math.sqrt(self.img.size))
    
    def render(self):
        if not self.set: self.generate()
        # Convert inefficient list to efficient numpy array
        
        dim = int(math.sqrt(self.set.size))
        # Reshape array into a 2d complex plane
        self.img = np.reshape(self.set, (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)
%time j.show()


CPU times: user 0 ns, sys: 12 ms, total: 12 ms
Wall time: 13.8 ms
CPU times: user 6.71 s, sys: 244 ms, total: 6.96 s
Wall time: 11.8 s

In [ ]: