Diary

Bernini, maestro della passione avvolgente e calda, sapeva catturare il desiderio lacerante e violento, riassumendolo in gesti eleganti e definitivi. La sua abilità trascendeva il bene e il male, oltre la morale pubblica o privata, e oltre la legge. La sua arte, come la statua del ratto di Proserpina, dimostra una profonda comprensione del delirio dei sensi, con dita di marmo gelido che penetrano in una carne marmorea che non mostra alcun segno del suo materiale.

Le opere di Bernini non si rivolgono alla ragione, ma piuttosto stordiscono l’osservatore con volute e spirali che avvolgono e fanno perdere i sensi. L’artista, capace di colpire brutalmente suo fratello per un’amante destinata a essere abbandonata, si immergeva completamente nel delirio dei sensi.

La sua arte racconta storie di stupri e sante in estasi come le peggiori peccatrici, sintetizzando la lotta eterna tra l’istinto e la legge, tra carnefice e vittima, tra la passione che non ascolta ragioni e la civiltà. Il suo lavoro riflette la filosofia di Agostino: “ama e fa’ ciò che vuoi”. Bernini esemplifica questa filosofia con l’innocenza sensuale e travolgente che solo i santi e i grandi peccatori possiedono.

Che si tratti di scolpire una statua o di disegnare un portico per San Pietro, l’arte di Bernini evoca un’ebbrezza che trascina l’osservatore in un vortice di emozioni. In ogni sua opera, Bernini ha saputo incapsulare il conflitto tra la pulsione e la legge, tra il carnefice e la vittima, e tra la passione e la civiltà, in modo ineguagliabile.

Silenzio e pace, rumore e burrasca. Così il mare, così i pensieri.

Il codice (qui puoi scaricare il codice sorgente) implementa il gioco del tris (tic-tac-toe) con un’interfaccia testuale, permettendo a un giocatore umano di sfidare un’intelligenza artificiale (IA) semplificata che sceglie mosse casuali. Ecco il funzionamento del codice, funzione per funzione:

1. stampa_tabellone(tabellone): Questa funzione prende in input il tabellone di gioco e lo stampa sulla console in un formato leggibile. Il tabellone è una lista di liste che contiene le informazioni sulle caselle occupate dai simboli dei giocatori.
2. verifica_vittoria(tabellone, simbolo): Questa funzione prende in input il tabellone e un simbolo del giocatore (“X” o “O”) e verifica se il giocatore con quel simbolo ha vinto la partita. Controlla tutte le righe, colonne e le due diagonali per vedere se contengono tre simboli uguali. Se trova una combinazione vincente, restituisce True, altrimenti False.
3. mossa_ia(tabellone): Questa funzione rappresenta la logica dell’IA semplificata. Prende in input il tabellone e sceglie casualmente una mossa tra le caselle disponibili. Restituisce le coordinate (riga, colonna) della mossa scelta. Nota che questa IA è molto semplice e non segue alcuna strategia per vincere la partita.
4. gioco(): Questa è la funzione principale che implementa la logica del gioco. Inizialmente, crea un tabellone vuoto e assegna il turno al giocatore umano con il simbolo “X”. Fino a quando ci sono caselle libere, esegue i seguenti passaggi: a. Stampa il tabellone attuale. b. Se è il turno del giocatore umano, chiede in input un numero tra 1 e 9 che corrisponde alla casella da occupare. Converte il numero in coordinate (riga, colonna) del tabellone. c. Se è il turno dell’IA, chiama la funzione mossa_ia() per ottenere le coordinate della mossa scelta dall’IA. d. Controlla se la casella scelta è già occupata. Se lo è, chiede al giocatore di scegliere un’altra casella. e. Altrimenti, occupa la casella con il simbolo del giocatore corrente e decrementa il numero di caselle libere. f. Verifica se il giocatore corrente ha vinto la partita chiamando la funzione verifica_vittoria(). Se ha vinto, stampa il messaggio di vittoria e interrompe il ciclo. g. Se nessuno ha vinto, passa il turno all’altro giocatore.
5. Se il ciclo termina senza che nessun giocatore abbia vinto, stampa il messaggio di pareggio.

La strategia adottata in questo codice è semplice e non ottimizzata per far vincere l’IA. L’IA sceglie mosse casuali tra le caselle disponibili, senza alcuna strategia per bloccare il giocatore avversario o cercare di vincere la partita. L’obiettivo principale del codice è di fornire un’implementazione di base del gioco del tris, piuttosto che un’intelligenza artificiale avanzata.

Per migliorare l’IA e renderla più competitiva, potresti implementare un algoritmo di ricerca come il Minimax, che analizza tutte le possibili mosse future e sceglie la mossa ottimale per massimizzare il punteggio dell’IA e minimizzare il punteggio del giocatore avversario. Tuttavia, questo richiederebbe una modifica sostanziale della funzione mossa_ia() e l’aggiunta di funzioni aggiuntive per calcolare il punteggio delle mosse e simulare le mosse future.

Oh, gioveni! Quando vi dico «sequitemi miei pugnaci», dovete sequire et pugnare! Poche conte! Se no qui stemo a prenderci per le natiche…

dal film L’armata Brancaleone

Il nucleo centrale del problema nel governo di Giorgia Meloni risiede nell’olfatto. La politica di FDI si è focalizzata sull’aroma delle parole piuttosto che sul loro significato e sulle ripercussioni che queste avrebbero. “Non siamo fascisti”, sussurrano con cautela nei momenti di imbarazzo, ma allo stesso tempo sembrano apprezzare l’aura di fascismo che le circonda. Il richiamo ai bei tempi passati, ai treni puntuali e al razzismo coloniale è il loro aroma distintivo.

Chi riesce a captare i sottintesi, i riferimenti nascosti e le sfumature del linguaggio, comprenderà il messaggio. I media non mancano di evidenziare i “boia chi molla” dei nostri leader, mentre per coloro che non si addentrano in queste sottigliezze, le frasi risuonano come pura razionalità.

Il dibattito sulla “sostituzione etnica” appare privo di senso: Fratelli d’Italia si limita a ripetere le stesse poche idee da tempo, ponendo maggiore enfasi sul suono piuttosto che sul contenuto. Temi come razza, patria, purezza della lingua e famiglia tradizionale evocano il periodo fascista senza citarlo direttamente, accarezzandolo appena.

Le parole di Meloni e soci emettono un odore di fascismo: talvolta solo un accenno, altre volte con forza e un’impressione di soffocamento per chi ne riconosce l’essenza. E così, assistiamo a una parodia olfattiva della politica, un gioco di equilibrismi tra ciò che viene detto e ciò che viene taciuto, tra l’aroma seducente e il senso di nausea.

Malgrado le accese discussioni riguardo all’uso della Venere di Botticelli come influencer nella campagna promozionale del turismo, qualcosa di ancor più cruciale emerge, come l’onda lunga di un mare profondo.

Si pone la domanda se l’Italia necessiti davvero di un’iniziativa turistica generica, che abbracci l’intero marchio “Italia”, riproponendo gli stessi luoghi simbolo, gli eterni cliché. Se il Bel Paese fosse alle prese con una crisi generale del turismo, allora tale strategia sarebbe giustificabile. Ma la realtà è ben altra.

Venezia, come una madre che protegge il suo fragile bambino, sta considerando di porre limiti al numero di visitatori, o di introdurre altre misure per arginare l’incessante flusso di turisti. E Venezia non è sola in questo, basta guardare alle Cinque Terre e ad altre mete celebri. Gli Uffizi, dove la Venere di Botticelli giace, sono quasi inaccessibili senza prenotazione online e pagamento anticipato, e persino così, durante l’alta stagione, la fatica si fa sentire. La Costiera Amalfitana è continuamente assediata dalla folla.

L’Italia, invece, dovrebbe prendersi cura dei tesori più nascosti e meno celebrati della Penisola, come si coltiva con amore un giardino segreto. Ci sono borghi medievali arroccati su colline e affacciati su spiagge e laghi, piccoli musei nascosti, bellezze naturali semisconosciute e feste tradizionali dal fascino folcloristico.

Sono questi i luoghi che languono nell’ombra del turismo internazionale, e che meriterebbero di essere riscoperti, specialmente nelle aree del paese dove la disoccupazione e lo spopolamento mordono come un freddo vento d’inverno.

Se la Venere della campagna pubblicitaria avesse deciso di immortalarsi con il suo sorriso davanti a queste meraviglie sconosciute, forse l’iniziativa avrebbe trovato un’accoglienza più calorosa. Forse.

In questo tutorial, ti guiderò attraverso la creazione di un programma Python per visualizzare un toro 3D rappresentato con linee e farlo ruotare intorno al suo asse utilizzando PyOpenGL e Pygame. Infine, mostrerò come generare e salvare una GIF animata del toro ruotante.

Prerequisiti:
Prima di iniziare, assicurati di aver installato le seguenti dipendenze:

pip install PyOpenGL PyOpenGL_accelerate numpy pygame imageio imageio[ffmpeg]

Passo 1: Importare le librerie necessarie
Innanzitutto, importiamo le librerie che useremo nel nostro codice:

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import numpy as np
import imageio

Passo 2: Creare la funzione per generare il toro

Creiamo una funzione chiamata torus che genera i vertici e gli indici del toro. La funzione accetta quattro argomenti: il raggio del cerchio interno, il raggio del tubo, il numero di segmenti e il numero di segmenti del tubo.

def torus(radius, tube_radius, num_segments, num_tube_segments):
    vertices = []
    indices = []

    # Calcolare i vertici del toro
    for i in range(num_segments):
        theta = i * 2 * np.pi / num_segments
        for j in range(num_tube_segments):
            phi = j * 2 * np.pi / num_tube_segments

            x = (radius + tube_radius * np.cos(phi)) * np.cos(theta)
            y = (radius + tube_radius * np.cos(phi)) * np.sin(theta)
            z = tube_radius * np.sin(phi)

            vertices.append([x, y, z])

    # Creare gli indici per collegare i vertici
    for i in range(num_segments):
        for j in range(num_tube_segments):
            index1 = (i * num_tube_segments + j) % (num_segments * num_tube_segments)
            index2 = ((i + 1) * num_tube_segments + j) % (num_segments * num_tube_segments)
            index3 = ((i + 1) * num_tube_segments + (j + 1)) % (num_segments * num_tube_segments)
            index4 = (i * num_tube_segments + (j + 1)) % (num_segments * num_tube_segments)

            indices.extend([index1, index2, index3, index4])

    return vertices, indices

Passo 3: Creare la funzione per disegnare il toro

La funzione draw_torus accetta i vertici e gli indici generati dalla funzione torus e utilizza le funzioni OpenGL per disegnare il toro come una serie di linee.

def draw_torus(vertices, indices):
    for i in range(0, len(indices), 4):
        glBegin(GL_LINES)
        glVertex3fv(vertices[indices[i]])
        glVertex3fv(vertices[indices[i + 1]])
        glEnd()

        glBegin(GL_LINES)
        glVertex3fv(vertices[indices[i + 1]])
            glVertex3fv(vertices[indices[i + 2]])
    glEnd()

    glBegin(GL_LINES)
    glVertex3fv(vertices[indices[i + 2]])
    glVertex3fv(vertices[indices[i + 3]])
    glEnd()

    glBegin(GL_LINES)
    glVertex3fv(vertices[indices[i + 3]])
    glVertex3fv(vertices[indices[i]])
    glEnd()

Passo 4: Creare la funzione per catturare i frame OpenGL
Creiamo una funzione chiamata capture_frame che utilizza glReadPixels per catturare i frame direttamente dall’OpenGL e restituisce un array NumPy.

def capture_frame(width, height):
    buffer = (GLubyte * (3 * width * height))()
    glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer)
    return np.frombuffer(buffer, dtype=np.uint8).reshape(height, width, 3)[::-1, :, :]

Passo 5: Creare la funzione principale

Ora creiamo la funzione principale main che inizializza Pygame, configura la finestra e la visualizzazione OpenGL, e crea un ciclo principale che gestisce gli eventi, aggiorna la rotazione del toro, disegna il toro sullo schermo e cattura i frame per generare la GIF animata.

def main():
    pygame.init()
    display = (800, 600)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)

    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)
    glTranslatef(0.0, 0.0, -5)

    glEnable(GL_DEPTH_TEST)

    torus_vertices, torus_indices = torus(0.5, 0.5, 32, 32)

    frames = []
    num_frames = 360
    frame_interval = 10

    # Ruota il toro di 90 gradi
    glRotatef(90, 0, 1, 0)

    for _ in range(num_frames):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(1, 0, 1, 0)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        glColor3f(1, 1, 1)
        draw_torus(torus_vertices, torus_indices)

        pygame.display.flip()

        # Cattura il frame corrente e aggiungilo all'array di frame
        frame_data = capture_frame(*display)
        frames.append(frame_data)

        pygame.time.wait(frame_interval)

    # Salva l'array di frame come una GIF animata
    imageio.mimsave('torus_animation.gif', frames, fps=30)

    pygame.quit()

if __name__ == "__main__":
    main()

Il significato della fotografia è cambiato nel corso del tempo. Se un tempo il suo obiettivo principale era eternizzare momenti importanti della vita, oggi la sua funzione è quella di preservare ogni attimo dell’esistenza, anche quelli che possono sembrare banali e insignificanti, in una dimensione eterna. La fotografia diventa così un modo per fossilizzare la vita, catturandola nel momento stesso in cui si sta svolgendo, o addirittura prima che si compia. In questo modo, la foto non è più soltanto un ricordo di momenti significativi, ma diventa un mezzo per condividere la propria vita con gli altri. La condivisione diventa quindi il significato principale della fotografia, e non tanto l’immagine in sé.

Il teorema del limite centrale è uno dei concetti fondamentali nella teoria della probabilità e nelle statistiche. Stabilisce che la distribuzione della somma (o della media) di un numero sufficientemente grande di variabili casuali indipendenti e identicamente distribuite tende a una distribuzione normale, anche conosciuta come distribuzione gaussiana. Questo articolo illustra come implementare e dimostrare il teorema del limite centrale utilizzando Python, generando numeri casuali da diverse distribuzioni e sommandoli per creare un istogramma che converge verso una distribuzione gaussiana.

Il teorema del limite centrale ha importanti implicazioni nella pratica, poiché giustifica l’utilizzo della media come stima del valore vero di una misura e mostra che la nostra confidenza nella stima aumenta con l’aumentare del numero di misure. La convergenza verso una distribuzione gaussiana è il risultato dell’effetto combinato di un gran numero di variabili casuali indipendenti, che porta ad una distribuzione simmetrica attorno al valore medio.

Per illustrare il teorema del limite centrale in Python, abbiamo sviluppato un codice che genera numeri casuali da diverse distribuzioni, somma i numeri casuali generati e crea un istogramma dei valori sommati. Con l’aumentare del numero di distribuzioni, l’istogramma diventa sempre più simile a una distribuzione gaussiana.

import numpy as np
import matplotlib.pyplot as plt

def generate_random_numbers(num_distributions, num_samples):
    random_numbers = []
    
    for _ in range(num_distributions):
        distribution = np.random.choice(["uniform", "normal", "exponential"])
        
        if distribution == "uniform":
            numbers = np.random.uniform(-1, 1, num_samples)
        elif distribution == "normal":
            numbers = np.random.normal(0, 1, num_samples)
        elif distribution == "exponential":
            numbers = np.random.exponential(1, num_samples)
        
        random_numbers.append(numbers)
    
    return random_numbers

def sum_random_numbers(random_numbers):
    return np.sum(random_numbers, axis=0)

def plot_histogram(summed_numbers):
    plt.hist(summed_numbers, bins=50, density=True)
    plt.xlabel("Valori sommati")
    plt.ylabel("Densità")
    plt.title("Istogramma della somma di numeri casuali")
    plt.show()

def main():
    num_distributions = 10  # Numero di distribuzioni da sommare
    num_samples = 1000  # Numero di campioni per ciascuna distribuzione

    random_numbers = generate_random_numbers(num_distributions, num_samples)
    summed_numbers = sum_random_numbers(random_numbers)
    plot_histogram(summed_numbers)

if __name__ == "__main__":
    main()

Il codice si basa su due librerie principali: NumPy per la manipolazione dei numeri e la generazione di numeri casuali, e Matplotlib per la creazione dell’istogramma. Il codice è strutturato in quattro funzioni principali: generate_random_numbers, sum_random_numbers, plot_histogram e main.

La funzione generate_random_numbers genera numeri casuali da diverse distribuzioni, quali uniforme, normale ed esponenziale. Questa funzione prende due argomenti: il numero di distribuzioni da sommare e il numero di campioni per ciascuna distribuzione. Restituisce una lista di array NumPy contenente i numeri casuali generati.

La funzione sum_random_numbers somma i numeri casuali generati lungo l’asse 0, ovvero somma i numeri casuali delle diverse distribuzioni. Prende come argomento la lista di array NumPy contenente i numeri casuali generati e restituisce un array NumPy con i numeri sommati.

La funzione plot_histogram crea un istogramma dei numeri sommati utilizzando Matplotlib. Prende come argomento l’array NumPy con i numeri sommati e mostra l’istogramma.

La funzione main gestisce il flusso del programma. Imposta il numero di distribuzioni e il numero di campioni per ciascuna distribuzione, genera i numeri casuali, somma i numeri e crea l’istogramma.

L’esecuzione del codice mostra che, con l’aumentare del numero di distribuzioni sommate, l’istogramma dei valori sommati diventa sempre più simile a una distribuzione gaussiana. Questo risultato è in accordo con il teorema del limite centrale e conferma la sua validità nella pratica.

Questa convergenza verso una distribuzione gaussiana dimostra che la media delle misure è una stima affidabile del valore vero e che la nostra confidenza nella stima aumenta con l’aumentare del numero di misure. Inoltre, l’istogramma simmetrico attorno al valore medio suggerisce che la maggior parte delle misure si trova vicino alla media, il che implica una minore variabilità dei risultati.

L’implementazione del teorema del limite centrale in Python attraverso la generazione di numeri casuali da diverse distribuzioni e la loro somma mostra la convergenza verso una distribuzione gaussiana, confermando l’importanza e l’applicabilità del teorema nella pratica. Questo esempio dimostra l’utilità del teorema per giustificare l’uso della media come stima del valore vero e per mostrare che la nostra confidenza nella stima aumenta con l’aumentare del numero di misure.