Julia Fractal in Python

Fractals are intriguing mathematical entities that display complex and repetitive patterns. The Julia fractal, named after French mathematician Gaston Julia, is created by iterating a simple mathematical function over complex numbers. In this article, we will explore Julia fractals and learn how to create them using Python.

What is a Julia Fractal?

A Julia fractal is generated using an iterative function applied to each point in the complex plane. The equation is ?

Z_{n+1} = Z_n^2 + C

Here, Z_n is the complex number at iteration n, Z_n+1 is the complex number at iteration (n+1), and C is a fixed complex constant that determines the fractal's shape. Each point is color-coded based on how many iterations it takes to reach a magnitude threshold.

Algorithm Steps

• Step 1 Define the image width and height

• Step 2 Set zoom level and x, y offsets to adjust fractal position

• Step 3 Specify maximum iterations and escape threshold

• Step 4 Apply the Julia iteration formula for each pixel

• Step 5 Display the generated fractal using matplotlib

Method 1: Basic Julia Fractal Implementation

Let's create a Julia fractal with a fixed complex constant ?

import numpy as np
import matplotlib.pyplot as plt

def julia_fractal(width, height, max_iter, c):
    # Create coordinate arrays
    x = np.linspace(-2, 2, width)
    y = np.linspace(-2, 2, height)
    X, Y = np.meshgrid(x, y)
    Z = X + 1j * Y
    
    # Initialize the result array
    fractal = np.zeros((height, width))
    
    for i in range(height):
        for j in range(width):
            z = Z[i, j]
            count = 0
            
            while abs(z) <= 2 and count < max_iter:
                z = z**2 + c
                count += 1
            
            fractal[i, j] = count
    
    return fractal

# Generate Julia fractal
width, height = 400, 400
max_iterations = 100
c = -0.7 + 0.27015j  # Julia set constant

fractal_image = julia_fractal(width, height, max_iterations, c)

# Display the fractal
plt.figure(figsize=(8, 8))
plt.imshow(fractal_image, extent=[-2, 2, -2, 2], cmap='hot', origin='lower')
plt.colorbar(label='Iterations to escape')
plt.title('Julia Fractal')
plt.show()

This code creates a classic Julia fractal by iterating the function z = z² + c for each point in the complex plane.

Method 2: Julia Fractal with Custom Coloring

We can enhance the visual appeal by applying custom coloring using trigonometric functions ?

import numpy as np
import matplotlib.pyplot as plt
import math

def julia_fractal_colored(width, height, max_iter, c):
    x = np.linspace(-2, 2, width)
    y = np.linspace(-2, 2, height)
    X, Y = np.meshgrid(x, y)
    Z = X + 1j * Y
    
    fractal = np.zeros((height, width))
    
    for i in range(height):
        for j in range(width):
            z = Z[i, j]
            count = 0
            
            while abs(z) <= 2 and count < max_iter:
                z = z**2 + c
                count += 1
            
            if count == max_iter:
                fractal[i, j] = 0  # Inside the set
            else:
                # Apply sine function for smooth coloring
                fractal[i, j] = int(math.sin(count * 0.1) * 127 + 128)
    
    return fractal

# Generate colored Julia fractal
width, height = 400, 400
max_iterations = 80
c = -0.8 + 0.156j

colored_fractal = julia_fractal_colored(width, height, max_iterations, c)

# Display with custom colormap
plt.figure(figsize=(8, 8))
plt.imshow(colored_fractal, extent=[-2, 2, -2, 2], cmap='plasma', origin='lower')
plt.colorbar(label='Color Value')
plt.title('Julia Fractal with Custom Coloring')
plt.show()

This version uses a sine function to create smooth color transitions, resulting in a more visually appealing fractal with gradient effects.

Comparison of Methods

Key Parameters

• Complex constant (c) Determines the fractal shape and characteristics

• Maximum iterations Controls detail level and computation time

• Escape threshold Usually set to 2 for Julia sets

• Image resolution Higher values provide more detail but slower computation

Conclusion

Julia fractals offer a fascinating glimpse into mathematical beauty and complexity. By experimenting with different complex constants and coloring techniques, you can create diverse and captivating fractal patterns. Python's NumPy and Matplotlib libraries provide an excellent environment for exploring these mathematical wonders.