Esplorazione e Visualizzazione degli Insiemi di Julia…

Gli insiemi di Julia sono un famoso esempio di frattali, che formano una classe di oggetti matematici complessi e intricati. Sono definiti come l’insieme dei punti nel piano complesso che rimangono limitati sotto l’iterazione di una funzione quadratica complessa del tipo ( \(f(z) = z^2 + c\) ), dove ( c ) è un parametro complesso. Variazioni nel valore di \(c\) producono frattali con strutture estremamente diverse e spesso sorprendenti.

import numpy as np
import matplotlib.pyplot as plt
# Impostazioni
width, height = 800, 800
max_iter = 256
xmin, xmax = -1.5, 1.5
ymin, ymax = -1.5, 1.5
# Lista di numeri complessi c
c_values = [
    complex(-0.7, 0.27015), complex(0.355, 0.355), complex(-0.4, 0.6),
    complex(0.37, 0.1), complex(-0.70176, -0.3842), complex(-0.835, -0.2321),
    complex(-0.8, 0.156), complex(-0.7269, 0.1889), complex(0.3, 0.5)
]
# Creare una griglia di valori complessi
x, y = np.linspace(xmin, xmax, width), np.linspace(ymin, ymax, height)
z_values = np.array(np.meshgrid(x, y)).reshape(2, -1).T
z_values = z_values[:, 0] + 1j * z_values[:, 1]
# Inizio del grafico 3x3
fig, axes = plt.subplots(3, 3, figsize=(12, 12))
for i, c in enumerate(c_values):
    row = i // 3
    col = i % 3
    ax = axes[row, col]
    # Calcolo del frattale Julia
    z = z_values.copy()
    image = np.zeros(z.shape, dtype=float)
    mask = np.ones(z.shape, dtype=bool)
    for k in range(max_iter):
        z[mask] = z[mask] * z[mask] + c
        mask = np.logical_and(mask, np.abs(z) < 8)
        image += mask.astype(float)
    image = image.reshape((width, height))
    # Visualizzazione del frattale Julia
    ax.imshow(image, extent=(xmin, xmax, ymin, ymax), cmap="hot")
    ax.set_title(f"c = {c}")
plt.show()

Il codice fornito rappresenta una visualizzazione grafica di nove diversi insiemi di Julia utilizzando la libreria Matplotlib in Python. Ecco una spiegazione dettagliata delle componenti principali:

1. Impostazione della Griglia: La griglia di valori complessi è creata utilizzando np.linspace per generare vettori di valori reali e immaginari, e questi sono combinati in un array di numeri complessi. La griglia rappresenta i punti nel piano complesso che verranno iterati.
2. Iterazione e Calcolo del Frattale: Per ogni valore di ( c ) nell’elenco di numeri complessi c_values, l’algoritmo itera la funzione (\( f(z) = z^2 + c\) ) su ogni punto della griglia. Utilizza una maschera logica (mask) per tracciare quali punti rimangono limitati attraverso le iterazioni. L’immagine finale viene costruita sommando i valori della maschera attraverso le iterazioni, dando un’indicazione della velocità con cui i punti divergono.
3. Visualizzazione: La griglia di output è ridimensionata in una forma che corrisponde alla risoluzione dell’immagine e viene visualizzata utilizzando imshow. La mappa dei colori “hot” è scelta per rappresentare i valori, con i colori che indicano la velocità di divergenza dei punti.
4. Strutturazione del Grafico: Il codice utilizza una griglia di grafici 3×3, utilizzando plt.subplots, per mostrare i nove diversi frattali associati ai valori in c_values. Ogni grafico è etichettato con il valore corrispondente di ( c ).

Il codice, in estrema sintesi, sfrutta le capacità di calcolo vettoriale di NumPy e le funzionalità di visualizzazione di Matplotlib per esplorare e visualizzare una famiglia di frattali complessa e affascinante. Le scelte di progettazione mirano a fornire un’analisi efficiente e una rappresentazione chiara e accattivante degli insiemi di Julia, illustrando come piccole variazioni nel parametro ( c ) possano produrre strutture notevolmente diverse.