≡ Menu

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.

{ 0 comments }

L’Italia è nota per la sua burocrazia complessa, con innumerevoli norme e regolamenti spesso in contraddizione tra loro. Questi vengono interpretati da diverse autorità decisionali, ciascuna con il proprio potere di veto. Il risultato è un sistema frammentato e autoreferenziale, in cui le valutazioni di costi e benefici per la collettività sono spesso trascurate.

Burocrati e potere dominano la scena, parlando del popolo ma agendo in termini astratti e ideologici. Questo approccio genera ammirazione nei contesti internazionali, ma non si traduce in miglioramenti concreti per i cittadini.

La fitta rete di norme e interpretazioni ostacola l’innovazione, a meno che questa non provenga dal potere stesso. Se un’innovazione è vicina al potere, come nel caso del telemarketing, il sistema la favorirà a scapito dei cittadini.

{ 0 comments }

Velocità…

Il calcolo della velocità vera (TAS) e della ground speed (GS) di un aereo è un problema importante nella navigazione aerea. La velocità vera (True Air Speed, TAS) è la velocità effettiva del vento che incontra l’aereo, mentre la ground speed (GS) è la velocità dell’aereo rispetto al terreno, tenendo conto del vento. In questo articolo, introdurremo i concetti generali e analizzeremo in dettaglio un codice scritto in Python che permette di calcolare queste velocità.

Il codice è composto da diverse funzioni che svolgono compiti specifici. La funzione true_air_speed calcola la velocità vera a partire dalla velocità indicata (Indicated Air Speed, IAS) e dalla quota. Questo viene fatto utilizzando la relazione tra densità dell’aria e quota, che a sua volta dipende dalle proprietà dell’atmosfera standard. La funzione ground_speed calcola la ground speed a partire dalla velocità vera, dal modulo e dalla direzione del vento e dall’angolo di rotta dell’aereo. Questi ultimi due valori sono inseriti come input dall’utente. La funzione mach_number calcola il Mach number, che è il rapporto tra la velocità vera e la velocità del suono alla quota data.

Infine, il codice rappresenta i risultati sotto forma di diagrammi che mostrano come variano la velocità vera e la ground speed con la quota, da 0 a 11000 metri. Inoltre, su ogni diagramma viene visualizzato un riquadro che mostra i valori calcolati di velocità vera, Mach number e ground speed.

Per quanto riguarda la parte di codice che riguarda la rappresentazione dei diagrammi, utilizza la libreria matplotlib per creare due diagrammi, uno per la velocità vera e l’altro per la ground speed. La funzione plot viene utilizzata per tracciare le curve, mentre la funzione scatter viene utilizzata per visualizzare un punto sul diagramma corrispondente alla quota data. La funzione annotate viene utilizzata per stampare i valori all’interno dei diagrammi.

{ 0 comments }

Nell’articolo di oggi, esploreremo come creare un’applicazione semplice ma utile utilizzando PyQt5 per visualizzare lo spazio libero sui dischi del sistema. PyQt5 è una libreria Python che consente di creare interfacce utente grafiche (GUI) per le applicazioni desktop. Il nostro obiettivo è creare una finestra che mostri le informazioni sullo spazio libero sui dischi e includa un pulsante “Exit” per chiudere l’applicazione.
Prima di iniziare, assicurati di avere installato Python sul tuo sistema e di aver installato i pacchetti PyQt5 e psutil. Per installarli, esegui il seguente comando:

pip install PyQt5 psutil

Importazione dei moduli: All’inizio del codice, importiamo i moduli necessari, tra cui os, sys, psutil e alcuni widget specifici da PyQt5.QtWidgets.

Funzione get_disk_space_info: Questa funzione raccoglie informazioni sullo spazio libero sui dischi utilizzando la libreria psutil. La funzione itera su tutte le partizioni e raccoglie informazioni su dispositivo, punto di montaggio, spazio totale, spazio libero e spazio utilizzato. Restituisce una lista di stringhe con queste informazioni.

Classe DiskSpaceApp: Questa classe estende QWidget e contiene la logica per creare l’interfaccia utente dell’applicazione.

  • Metodo __init__: Il costruttore chiama il costruttore della classe base e inizializza l’interfaccia utente.
  • Metodo init_ui: Questo metodo crea l’interfaccia utente dell’applicazione. Imposta il titolo della finestra e crea un layout verticale (QVBoxLayout). Aggiunge le informazioni sullo spazio libero sui dischi (ottenute dalla funzione get_disk_space_info) come etichette (QLabel) al layout. Infine, crea un pulsante “Exit” (QPushButton) e lo collega al metodo close per chiudere l’applicazione. Il pulsante viene aggiunto al layout e il layout viene impostato come layout della finestra.

Alla fine del codice, creiamo un’istanza dell’applicazione QApplication e un’istanza della nostra classe DiskSpaceApp. Quindi, avviamo l’applicazione con il metodo exec_().

{ 0 comments }

The Game of Life…

The game of life

Il Game of Life, concepito dal matematico britannico John Horton Conway nel 1970, è un automa cellulare a due dimensioni che ha catturato l’immaginazione di matematici, informatici e appassionati di giochi per oltre cinquant’anni. Con le sue semplici regole che governano la nascita, la morte e la sopravvivenza delle cellule su una griglia, il Game of Life genera una sorprendente varietà di pattern e comportamenti complessi. In questo articolo, esploreremo le regole del gioco, alcuni dei suoi pattern più noti e come implementarlo in Python.

Le regole del Game of Life

Il Game of Life si svolge su una griglia bidimensionale di celle quadrate, ognuna delle quali può essere “viva” (1) o “morta” (0). Le celle interagiscono con i loro otto vicini, che sono le celle direttamente adiacenti orizzontalmente, verticalmente e diagonalmente. A ogni passo temporale, o generazione, le seguenti quattro regole vengono applicate simultaneamente a tutte le celle:

  1. Una cella viva con meno di due vicini vivi muore per isolamento.
  2. Una cella viva con due o tre vicini vivi sopravvive alla generazione successiva.
  3. Una cella viva con più di tre vicini vivi muore per sovraffollamento.
  4. Una cella morta con esattamente tre vicini vivi diventa viva per riproduzione.

Pattern interessanti nel Game of Life

Le semplici regole del Game of Life danno origine a una vasta gamma di pattern e comportamenti. Alcuni dei più noti sono:

  1. Configurazioni oscillanti: pattern che si ripetono periodicamente dopo un certo numero di generazioni, come il Blinker, il Toad, il Beacon e il Pulsar.
  2. Navi spaziali: pattern che si spostano attraverso la griglia mentre oscillano, come il Glider e il Lightweight Spaceship (LWSS).
  3. Pattern stabili: configurazioni che non cambiano nel tempo, come il Block e la Beehive.
  4. Cannoni: pattern che producono navi spaziali o altri pattern in modo periodico, come il Glider Gun di Gosper.

Implementazione del Game of Life in Python

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

def inizializza_griglia(n):
    griglia = np.random.choice([0, 1], n*n, p=[0.5, 0.5]).reshape(n, n)
    return griglia

def conta_vicini_vivi(griglia):
    vicini_vivi = np.zeros(griglia.shape, dtype=int)

    for x in range(-1, 2):
        for y in range(-1, 2):
            if x == 0 and y == 0:
                continue
            vicini_vivi += np.roll(np.roll(griglia, y, axis=0), x, axis=1)

    return vicini_vivi

def aggiorna_griglia(griglia):
    nuova_griglia = griglia.copy()
    vicini_vivi = conta_vicini_vivi(griglia)

    nuova_griglia[(griglia == 1) & (vicini_vivi < 2)] = 0
    nuova_griglia[(griglia == 1) & (vicini_vivi > 3)] = 0
    nuova_griglia[(griglia == 0) & (vicini_vivi == 3)] = 1

    return nuova_griglia

def aggiorna_frame(*args):
    global griglia
    griglia = aggiorna_griglia(griglia)
    img.set_array(griglia)
    return [img]

def main():
    global griglia, img
    n = 50  # Dimensione della griglia
    generazioni = 100  # Numero di generazioni

    griglia = inizializza_griglia(n)

    fig, ax = plt.subplots()
    img = ax.imshow(griglia, cmap='binary')
    ax.set_xticks([])
    ax.set_yticks([])

    anim = FuncAnimation(fig, aggiorna_frame, frames=generazioni, interval=200, blit=True)
    plt.show()

if __name__ == '__main__':
    main()

Per implementare il Game of Life in Python, è possibile utilizzare la libreria numpy per rappresentare e manipolare la griglia e la libreria matplotlib per visualizzare l’evoluzione del gioco nel tempo. Il codice può essere organizzato nelle seguenti funzioni:

  1. inizializza_griglia: crea una griglia iniziale con celle viventi e morte casuali.
  2. conta_vicini_vivi: calcola il numero di vicini vivi per ogni cella della griglia.
  3. aggiorna_griglia: applica le regole del Game of Life alla griglia corrente per ottenere la griglia della generazione successiva.
  4. visualizza: mostra la griglia corrente con matplotlib
{ 0 comments }

Che facce di Cutro!

Recitando un rosario
di ambizioni meschine
di millenarie paure
di inesauribili astuzie
Coltivando tranquilla
l’orribile varietà
delle proprie superbie
la maggioranza sta

  • Fabrizio De André, da Smisurata Preghiera

Per incontrare i familiari delle vittime o i superstiti del naufragio non c’era tempo, ché avevano da canta’ a un compleanno la storia di una ragazza morta annegata in un fiume…

{ 0 comments }

[…]

Stat rosa pristina nomine, nomina nuda tenemus…
{ 0 comments }

Purtroppo, sì!

  • Scusi, lei è davvero un ministro di questo Governo?
  • Purtroppo, sì.
{ 0 comments }

David Crosby

«(Do we) Find the cost of freedom buried in the ground.
Mother Earth will swallow you; lay your body down.»

  • from Find the Cost of Freedom
{ 0 comments }

In real time…

This prototype of a wing that has undergone a change in form enhances the dynamics of flight in real-time…

{ 0 comments }