1 Automi Cellulari (Rev )

Transcript

1 1 Automi Cellulari (Rev ) Gli automi cellulari sono una classe di modelli introdotti originariamente da von Neumann e Ulam nel 1948 come una semplice idealizzazione dell evoluzione delle cellule a livello cellulare. Un automa cellulare può essere pensato come un insieme di cellette il cui stato può assumere un numero finito di stati discreti. Nell ipotesi più semplice la celletta può trovarsi in soli due stati: 1 celletta viva o 0 celletta morta. Lo stato delle singole cellette cambia nel tempo a seconda dello stato delle cellette vicine. Ad esempio se ci sono troppe cellette vicine vive, la celletta muore. Questi modelli sono un tipico esempio del processo di riduzione utilizzato in fisica nell analisi di sistemi complessi. Il punto di partenza è che fenomeni complicati possano essere originati da poche leggi semplici. Sotto questa ipotesi, si cercano quindi modelli semplici che basati su queste leggi riproducano il comportamento dei sistemi più complicati. Al di là della loro rilevanza fisica e/o biologica, questi modelli sono un esempio di un sistema dinamico discreto che può essere simulato esattamente su un computer. Più in dettaglio un automa cellulare è un sistema dinamico in cui: Lo spazio è discretizzato, ossia il sistema è definito su un reticolo; Le variabili di interesse sono definite solo sui siti del reticolo e possono assumere solo una sequenza discreta di valori; Il tempo è discreto per cui l evoluzione avviene ad intervalli regolari; Lo stato delle variabili su ogni sito cambia ad ogni intervallo di tempo con una regola locale che dipende solo dallo stato del sito e dei suoi vicini. L evoluzione è parallela, ossia il valore delle variabili viene cambiato simultaneamente in tutti i siti. A causa della sua origine biologica spesso i siti di un automa cellulare sono chiamati celle, noi useremo indifferentemente il nome cella o sito. Gli automi cellulari trovano una vasta applicazioni in molti campi della fisica che vanno dalla fluidodinamica alle galassie. Automi Cellulari Unidimensionali L esempio più semplice di automa cellulare sono gli automi cellulari Booleani Unidimensionali in cui i vicini di un sito sono il sito immediatamente a sinistra e quello immediatamente a destra. Le variabili definite su ogni sito possono assumere solo due valori (automa Booleano) che per comodità, e senza perdere di generalità, vengono indicati con 0 e 1. L automa di evolve nel tempo con una regola di evoluzione definita associando ad ogni configurazione di un sito e dei suoi due primi vicini il nuovo stato del sito: 1

2 i 1 i i+1 t rule t+1 La regola di evoluzione può essere facilmente espressa mediante una tavola che riporti nella prima riga le possibili configurazioni dei tre siti al tempo t e nella seconda il corrispondente lo stato del sito centrale al tempo successivo t + 1, come mostra il seguente esempio t t I tre siti possono trovarsi in 8 configurazioni differenti per cui vi sono 2 8 = 256 regole diverse. Le differenti regole sono usualmente indicate con un codice numerico ottenuto scrivendo nella prima riga della tavola della regola i possibili stati dei tre siti ordinati da sinistra a destra in modo che corrispondano alla rappresentazione binaria dei numeri 7, 6, 5, 4, 3, 2, 1, 0 e leggendo la seconda riga come rappresentazione binaria di un numero decimale. Il numero cosìottenuto rappresenta il codice numerico della regola. Ad esempio nel caso della regola espressa dalla tavola precedente si ha = 90 per cui questa regola viene indicata come la regola 90. Dalla tavola si vede facilmente che questa regola equivale a prendere la somma modulo 2 dei siti vicini per cui questa è anche nota come la regola modulo 2, o regola xor perchè lo stato dello spin al tempo t + 1 è 1 solo e lo stato di uno solo dei suoi primi vicini è 1. Il seguente programma simula un automa cellulare Booleano unidimensionale. Il programma prende come input il codice numerico della regola, il numero di passi che si vuole effettuare ed informazioni sulla configurazione iniziale. Quest ultima può essere sia random che data. Programma: cell aut-1d.c /**************************************************************** - Descrizione : Simulazione di un Automa Cellulare Booleano unidimensionale con condizioni periodiche al bordo. - Input : Numeri di siti dell automa Codice numerico regola Passi di evoluzione temporale 2

3 Configurazione iniziale random: seed e probabilita stato 1 Configurazione iniziale data posizioni siti con stato 1 - Output : Sul file OUT_F siti con stato 1 versus tempo - Parametri : OUT_F -> File output - $Id: cell_aut -1d.c v AC *****************************************************************/ #include <s t d i o. h> # include <math. h> #include <s t d l i b. h> /* Macros */ #define OUT F "cell_aut.dat" /* sito automa cellulare */ typedef unsigned short int cell_t ; /* automa cellulare */ typedef struct unsigned int size ; /* numero sito automa */ cell_t site ; /* puntatore al primo sito */ cellular_t ; /* Prototipi */ cell_t create_site ( int n ) ; void table_rule ( cell_t rule, cell_t rule_code ) ; void bit_to_str ( char str, int nchar, int n ) ; void init_state ( cellular_t aut, unsigned long seed ) ; void update_state ( cellular_t aut, cell_t rule ) ; int main ( void ) int i ; /* indice sito automa */ int n_step ; /* # intervalli temporali */ int step ; /* contatore passi temp */ cellular_t automata ; /* automa cellulare */ cell_t rule [ 8 ] ; /* tavola regola */ cell_t rule_code ; /* codice numerico regola */ unsigned long seed ; /* seme generatore n. r. */ char line [ 8 1 ] ; /* input buffer */ FILE fp ; /* puntatore file out */ /* Automa */ automata = ( cellular_t ) malloc ( sizeof ( cellular_t ) ) ; 3

4 if ( automata == NULL ) fprintf ( stderr, " Non enough space for automata\n" ) ; return 1 ; /* Parametri Automa */ printf ( "Numero siti automa : " ) ; sscanf ( line, "%ud", &automata >size ) ; printf ( " Codice numerico regola : " ) ; sscanf ( line, "%hu", &rule_code ) ; printf ( "Passi temporali : " ) ; sscanf ( line, "%d", &n_step ) ; printf ( " Seed condizione iniziale (== 0 fissa) : " ) ; sscanf ( line, "%lu", &seed ) ; /* Tavola della regola */ table_rule ( rule, rule_code ) ; /* Variabili sul reticolo */ automata >site = create_site ( automata >size ) ; /* Inizializzazione Automa */ init_state ( automata, seed ) ; /* File di output */ fp = fopen ( OUT_F, "w" ) ; if ( fp == NULL ) fprintf ( stderr, " File open failure\n" ) ; return 1 ; /* Configurazione iniziale */ for ( i = 0 ; i < automata >size ; ++i ) if ( automata >site [ i ] ) fprintf ( fp, "%d %d\n", 0, i + 1 ) ; /* Evoluzione */ for ( step = 1 ; step <= n_step ; ++step ) update_state ( automata, rule ) ; for ( i = 0 ; i < automata >size ; ++i ) if ( automata >site [ i ] ) fprintf ( fp, "%d %d\n", step, i +1); fclose ( fp ) ; 4

5 return 0 ; /* ---- * create_site() * */ cell_t create_site ( int n ) cell_t c ; c = ( cell_t ) malloc ( n sizeof ( cell_t ) ) ; if ( c == NULL ) fprintf ( stderr, " Memory allocation failure\n" ) ; exit ( 1 ) ; return c ; /* ---- * table_rule() * */ void table_rule ( cell_t rule, cell_t rule_code ) int i ; char str [ 4 ] ; /* stampa le configurazioni */ fprintf ( stdout, "tavola regola " ) ; for ( i = 7 ; i >= 0 ; i ) bit_to_str ( str, 3, i ) ; printf ( "%s ", str ) ; printf ( "\n" ) ; fprintf ( stdout, " codice %3d ", rule_code ) ; /* Tavola */ for ( i = 0 ; i <= 7 ; ++i ) rule [ i ] = rule_code & 1 ; rule_code >>= 1 ; /* stampa la tavola */ for ( i = 7 ; i >= 0 ; i ) printf ( " %1d ", rule [ i ] ) ; printf ( "\n" ) ; return ; 5

6 /* ---- * bit_to_str() * */ void bit_to_str ( char str, int nchar, int n ) int i ; unsigned int mask ; mask = 1 << ( nchar 1 ) ; for ( i = 0 ; i < nchar ; ++i ) str [ i ] = ( ( n & mask )!= 0)? 1 : 0 ; mask >>= 1 ; str [ nchar ] = \0 ; return ; /* ---- * init_state() * */ void init_state ( cellular_t aut, unsigned long int seed ) int i ; double r ; double p_one ; char line [ 8 1 ] ; if ( seed > 0) /* configurazione random */ printf ( " Configurazione random: %d siti\n", aut >size ) ; printf ( " Probabilita valore 1: " ) ; sscanf ( line, "%lf", &p_one ) ; srand ( seed ) ; for ( i = 0 ; i < aut >size ; ++i ) r = ( double ) rand ( ) / ( RAND_MAX ) ; aut >site [ i ] = ( r < p_one )? 1 : 0 ; else /* configurazione data */ for ( i = 0 ; i < aut >size ; ++i ) aut >site [ i ] = 0 ; printf ( " Configurazione data: %d siti\n", aut >size ) ; 6

7 printf ( " Specificare posizione siti 1\ n" ) ; while ( 1 ) printf ( "Posizione ( =< 0 fine): " ) ; sscanf ( line, "%d", &i ) ; if ( i < 1 i > aut >size ) break ; if (! aut >site [ i 1]) aut >site [ i 1] = 1 ; else printf ( "Sito non valido, gia scelto\n" ) ; return ; /* ---- * update_state() * */ void update_state ( cellular_t aut, cell_t rule ) int i ; /* indice sito */ int im1, ip1 ; /* indice sito a sx e dx */ int conf_index ; /* codice num conf 3 siti */ cell_t new_site ; /* nuova configurazione aut */ /* configurazione temporanea per evoluzione parallela */ new_site = create_site ( aut >size ) ; /* Usiamo condizioni periodiche al bordo */ /* Vicino a sinistra di 0 e N-1 */ /* Vicino a destra di N-1 e 0 */ for ( i = 0 ; i < aut >size ; ++i ) im1 = ( i 1 + aut >size ) % aut >size ; ip1 = ( i+1) % aut >size ; conf_index = 4 aut >site [ im1 ] + 2 aut >site [ i ] + aut >site [ ip1 ] ; new_site [ i ] = rule [ conf_index ] ; for ( i = 0 ; i < aut >size ; ++i ) aut >site [ i ] = new_site [ i ] ; free ( new_site ) ; return ; 7

8 Il programma utilizza per l automa cellulare l oggetto automata di tipo cellular t che contiene la sia il numero di celle dell automa, campo size, che il puntatore alla prima cella dell automa, campo site. Da momento che ciascuna cella può assumere solo il valore 0 o 1 le celle sono di tipo cell t definito come unsigned short int. Le celle dell automa sono create con la funzione create site() automata >site = create_site ( automata >size ) ; che alloca lo spazio di memoria per le automata->size celle dell automa e ritorna il puntatore alla prima cella. Tavola: funzione table rule() Il programma utilizza direttamente la tavola della regola che associa a ciascuna delle 8 configurazioni di tre siti consecutivi il nuovo valore del sito centrale. Questa scelta non è necessariamente la più efficiente ma sicuramente è la più flessibile. La tavola della regola è costruita dalla funzione table rule() che trasforma il codice numerico della regola nella tavola corrispondente. Interpretando lo stato di tre celle consecutive come la rappresentazione binaria di un numero intero le 8 configurazioni possibili sono identificate univocamente dal valore di un indice i = 0,..., 7 cosicchè la tavola della regola può essere facilmente codificata con l ausilio dell array di 8 elementi rule assegnando all elemento i-esimo di rule il nuovo valore del sito centrale per la configurazione dei tre siti identificata dal valore dell indice i. for ( i = 0 ; i <= 7 ; ++i ) rule [ i ] = rule_code & 1 ; rule_code >>= 1 ; Per trasformare il codice numerico della regola nella tavola si utilizza l espressione rule_code & 1 il cui valore è 0 o 1 a seconda che il primo bit a destra, quello meno significativo, di rule code sia un bit 0 o un bit 1. Gli 8 bits della rappresentazione numerica della regola vengono letti spostando successivamente a destra i bits di rule code, rule_code >>= 1 ; Dal momento che si leggono solo i primi 8 bits non ha importanza se lo shift a destra sia logico od aritmetico. Tuttavia sebbene rule code sia un tipo intero senza segno se il codice della regola viene dato in input con un segno negativo il risultato di queste operazioni dipende dalla rappresentazione utilizzata dal computer per i numeri negativi. Ad esempio nella rappresentazione in complemento a due i primi otto bits di rule code conterranno la rappresentazione in complemento a due del codice della regola mentre nella rappresentazione in true magnitude i primi otto bits conterranno la rappresentazione binaria del modulo del codice della regola. Il fatto che rule code sia letto con la direttiva di conversione %hu sscanf ( line, "%hu", &rule_code ) ; 8

9 non vuol dire infatti che un valore negativo è convertito nell equivalente valore positivo ma solo che la rappresentazione binaria del valore negativo è interpretata come la rappresentazione binaria di un valore positivo. Di conseguenza se si vuole essere certi che per il codice della regola vengano utilizzati solo valori positivi bisogna aggiungere un controllo esplicito nel programma. In alternativa agli operatori bit-a-bit si può utilizzare for ( i = 0 ; i <= 7 ; ++i ) rule [ i ] = rule_code % 2 ; rule_code /= 2 ; Anche in questo caso valgono ovviamente considerazioni analoghe alle precedenti se il codice della regola viene dato in input con un segno negativo. Per controllare che la tavola generata corrisponda alla regola voluta la funzione table rule() ne stampa il contenuto utilizzando la funzione void bit_to_str ( char str, int nchar, int n ) che converte i primi nchar bits della rappresentazione binaria del numero intero n nella stringa puntata da str. Configurazione Iniziale: funzione init state() Il programma permette di scegliere tra una configurazione iniziale random o specificata nel caso il valore del seme seed sia uguale a zero. Nel caso di configurazione random alle celle viene assegnato il valore 1 con probabilità p one for ( i = 0 ; i < aut >size ; ++i ) r = ( double ) rand ( ) / ( RAND_MAX ) ; aut >site [ i ] = ( r < p_one )? 1 : 0 ; Se il valore di seed è 0 la configurazione iniziale deve essere data specificando la posizione delle celle con valore 1. while ( 1 ) printf ( "Posizione ( =< 0 fine): " ) ; sscanf ( line, "%d", &i ) ; if ( i < 1 i > aut >size ) break ; if (! aut >site [ i 1]) aut >site [ i 1] = 1 ; else printf ( "Sito non valido, gia scelto\n" ) ; Le celle vengono inserite utilizzando un ciclo infinito 9

10 while ( 1 )... interrotto dall istruzione break quando viene inserita una posizione non valida. viene anche controllato che le posizioni non vengano inserite più volte if (! aut >site [ i 1]) aut >site [ i 1] = 1 ; else printf ( "Sito non valido, gia scelto\n" ) ; Nel ciclo Evoluzione: funzione update state() Lo stato delle cellette deve essere aggiornato simultaneamente, in altre parole il nuovo valore delle cellette al tempo t + 1 deve essere determinato usando per tutte le cellette il valore al tempo t. Questo tipo di evoluzione viene chiamata sincrona o parallela. Il modo più semplice di realizzare una evoluzione sincrona è utilizzando un array temporaneo su cui viene memorizzato il nuovo valore delle cellette generato a partire dai valori vecchi. La funzione update state() usa a questo scopo l array temporaneo new site. cell_t new_site ;... new_site = create_site ( aut >size ) ; Quando lo stato di tutte le cellette è stato cambiato l array temporanea viene copiata su quella che contiene la configurazione dell automa for ( i = 0 ; i < aut >size ; ++i ) aut >site [ i ] = new_site [ i ] ; e lo spazio utilizzato dall array temporaneo restituito al sistema free ( new_site ) ; L uso di un array ausiliario non è efficiente da un punto di vista dell utilizzo della memoria, ed in effetti l evoluzione sincrona dell automa può essere realizzata utilizzando solo due variabili temporanee ausiliarie. La scrittura dell algoritmo diventa però più complessa e meno trasparente, e viene lasciato come esercizio. Il nuovo valore di ogni cella i viene determinato dalla la tavola della regola rule calcolando il valore dell indice della configurazione dei tre siti adiacenti: conf_index = 4 aut >site [ im1 ] + 2 aut >site [ i ] + aut >site [ ip1 ] ; dove im1 e ip1 individuano il vicino si sinistra e di destra del sito i, ed assegnando al sito i il valore ottenuto dalla tavola new_site [ i ] = rule [ conf_index ] ; 10

11 Condizioni al bordo L automa cellulare vive in uno spazio finito di L siti di conseguenza il primo ed l ultimo sito hanno un vicino in meno. Per ovviare a questo inconveniente si usano le Condizioni Periodiche al Bordo associando come vicino di sinistra del primo sito l ultimo sito, e come vicino di destra dell ultimo sito il primo sito. Geometricamente questo vuol dire che l automa cellulare vive su un anello: L 2 L 1 Nel programma questo è realizzato con le istruzioni im1 = ( i 1 + aut >size ) % aut >size ; ip1 = ( i+1) % aut >size ; come è facile convincersi considerando, ad esempio, i casi i=0, i=1 e i=aut->size-1. Questo non è l unico modo di realizzare le condizioni periodiche al bordo. Ad esempio si potrebbe eseguire il ciclo partendo dalla seconda cella sino fino alla penultima e scrivere esplicitamente la regola per la prima e l ultima cella. Questo metodo è chiaramente più efficiente di quello che richiede le operazioni di modulo, ma ha lo svantaggio che se la regola di evoluzione è piuttosto complicata, non come in questo caso, è più facile fare errori in quanto questa va replicata tre volte: una volta per le celle a ciascun estremo ed una volta per tutte le altre celle. Il numero di repliche inoltre aumenta con il numero di dimensioni del sistema, per cui se sono tre in una dimensione saranno nove in due e cosìvia. Un altro metodo è quello di utilizzare tavole dei vicini che per ogni sito contengano gli indici dei siti primi vicini, come fatto ad esempio per il Random Walk in due dimensioni. Questo metodo è piuttosto flessibile e per questo viene utilizzato quando il sistema è definito su geometrie particolari o se il numero di vicini può variare nel tempo come ad esempio nelle simulazioni di dimanica molecolare. c AC