Darwin istiga viaggi sudamericani

Charles Darwin Viaggio di un naturalista intorno al mondo

Charles Darwin Viaggio di un naturalista intorno al mondo

Libro molto interessante per chi ama le scienze naturali. Raccontato in maniera fluida e incalzante, Darwin descrive il viaggio intorno al mondo del Beagle, appuntando tutto quello che la sua mente acuta riesce ad osservare. Affascinante notare che in realtà il periodo di viaggio effettivo in mare è stato complessivamente di un anno, a fronte di quattro anni passati in terra ferma dedicati all’esplorazione e all’analisi del territorio nel suo complesso. Utile per comprendere le condizioni di vita delle americhe e del pacifico nella metà dell’800. Rilevante l’incontro con gli indigeni della terra del fuoco. Gli indiani d’america e i gauchos.

Annunci

Come implementare il Gioco della Vita di Conway in C#

Dopo il primo post sugli automi di Wolfram, passiamo allo studio ben più interessante e vario degli automi a due dimensioni. Un mondo artificiale, chiamato comunemente “Game of Life” gioco della vita perchè è un misto variegato di pattern e conglomerati di bytes che si raccolgono e si evolvono in fantasiose creature, o variegati accrescimenti sincronizzati, o in una morte certa ed atroce, fa sempre un po’ tristezza quando ti muore un automa cellulare, sono momenti che non vorresti mai accadessero nella tua vita. Non è giusto che un automa vive solo perchè ha delle regole favorevoli o delle condizioni iniziali tarate ad hoc da una entità superiore. Personalmente non trovo giusto ed eticamente corretto che si creino degli automi cellulari per poi farli morire, o ancora peggio per godere mentre questi muoiono nell’indifferenza più totale della società moderna. Un po’ come Pernolino il tenero buchino nero, tanto amato ma tanto temuto del mondo intero. Per questo mi impegnerò nella salvaguardia degli automi cellulari, voglio fondare una associazione, in modo tale da organizzare una forza lavoro per raccogliere risorse, dibattiti, divulgazione, volantini informativi. Tutti devono sapere che gli automi cellulari esistono e molti incontrano la morte solo dopo neanche un paio di cicli di evoluzione!

Accrescimento cellulare sincronizzato

Accrescimento cellulare sincronizzato generato dal Gioco della Vita regola S23/B246.

Accrescimento cellulare incontrollato game of life conway

Accrescimento cellulare incontrollato generato dalla regola S23/B2356

Replicatore cellulare Game of Life Conway

Replicatore cellulare generato dalla regola S1357/B1357

Espanditore cellulare Game of Life Conway

Espanditore cellulare generato dalla regola S012345678/B3

Espanditore cellulare labirintico Game of Life Conway

Espanditore cellulare labirintico generato dalla regola S1234/B3

Questi sono degli automi cellulari possenti! Sembrano non morire mai, ed infatti così è! Ma ne esistono anche di altamente insicuri e precari, i quali dipendono fortemente dalle condizioni iniziali. Ma sono anche i più interessanti, come il classico gioco della vita di Conway basato sulla regola S23/B3 (qui potete leggervi la descrizione delle regole Game of Life di Conway).

Game of Life S23B356 Conway

Regola S23B356

Vediamo il codice, dove la classe astratta Automata e la classe Environment2D sono descritte nel precedente post sugli automi unidimensionali di Wolfram.

public class Automata2DGameLife : Automata {
  protected readonly List<byte> RuleSurvival = null;
  protected readonly List<byte> RuleBirth = null;

  public Automata2DGameLife(byte[] ruleSurvival, byte[] ruleBirth, Environment2D env0 = null) {
    this.RuleSurvival = ruleSurvival.ToList();
    this.RuleBirth = ruleBirth.ToList();
    this.Env0 = env0;
  }

  public override void StandardInit() {
    if (this.Env0 != null)
      this.Env.Merge(this.Env0);
    else {
      Env.SetValue(Env.Width / 2, Env.Height / 2, 1);
      Env.SetValue(Env.Width / 2 + 1, Env.Height / 2, 1);
      Env.SetValue(Env.Width / 2 - 1, Env.Height / 2 - 1, 1);
      Env.SetValue(Env.Width / 2 - 2, Env.Height / 2 - 1, 1);
      Env.SetValue(Env.Width / 2 - 2, Env.Height / 2 - 2, 1);
      Env.SetValue(Env.Width / 2 - 3, Env.Height / 2 - 2, 1);
      Env.SetValue(Env.Width / 2 - 3, Env.Height / 2 - 3, 1);
      Env.SetValue(Env.Width / 2 - 4, Env.Height / 2 - 2, 1);
    }
  }
  
  public override bool IsFinite() { return false; }
  public override void RandomInit() {
    Env0 = new Environment2D(20, 20);
    Random rand = new Random(Environment.TickCount);
    for (int i = 0; i < (Env.Width * Env.Height); i++) {
      int x = rand.Next(0, Env.Width);
      int y = rand.Next(0, Env.Height);
      Env.SetValue(x, y, (byte)rand.Next(0, 2));
    }
  }
  public override bool Next() {
    Environment2D etmp = new Environment2D(Env.Width, Env.Height);
    for (int x = 0; x < Env.Width; x++)
      for (int y = 0; y < Env.Height; y++)
        etmp.SetValue(x, y, ComputeRule(x, y));

    Env = etmp;
    return true;
  }		
  protected override byte ComputeRule(int x, int y) {
    byte neighbours = GetNeighbours(x, y);
    byte c = Env.GetValue(x, y);
    if (c > 0) {
      return (byte)(RuleSurvival.Contains(neighbours) ? 1 : 0);
    } else {
      return (byte)(RuleBirth.Contains(neighbours) ? 1 : 0);
    }
  }
  private byte GetNeighbours(int x, int y) {
    byte neighbours = 0;
    if (x > 0) { if (Env.GetValue(x - 1, y) > 0) neighbours++; }
    if (x > 0 && y > 0) { if (Env.GetValue(x - 1, y - 1) > 0) neighbours++; }
    if (x > 0 && y < Env.Height - 1) { if (Env.GetValue(x - 1, y + 1) > 0) neighbours++; }
    if (y > 0) { if (Env.GetValue(x, y - 1) > 0) neighbours++; }
    if (y < Env.Height - 1) { if (Env.GetValue(x, y + 1) > 0) neighbours++; }
    if (x < Env.Width - 1 && y > 0) { if (Env.GetValue(x + 1, y - 1) > 0) neighbours++; }
    if (x < Env.Width - 1) { if (Env.GetValue(x + 1, y) > 0) neighbours++; }
    if (x < Env.Width - 1 && y < Env.Height - 1) { if (Env.GetValue(x + 1, y + 1) > 0) neighbours++; }
    return neighbours;
  }  
  public override string ToString() {
    return string.Format("Game of Life S{0}/B{1}",
      string.Concat(RuleSurvival.Select(b => b.ToString()).ToArray()),
      string.Concat(RuleBirth.Select(b => b.ToString()).ToArray()));
  }
}

Come implementare automi cellulari unidimensionali in C#

Dopo il primo post sugli automi cellulari vediamo come implementare il tipo più semplice di automa: l’unidimensionale di Wolfram.

Iniziamo col definire la nostra struttura dati per descrivere l’ambiente dell’automa. Nel caso di automi di Wolfram avremmo bisogno di una matrice a due dimensioni (benchè l’automa venga definito come unidimesnionale abbiamo bisogno della seconda dimensione per descriverne l’evoluzione nel tempo).

public class Environment2D {
  public byte[] Buffer { get; private set; }
  public int Width { get; private set; }
  public int Height { get; private set; }
  public Environment2D(int w, int h) {
    Width = w;
    Height = h;
    Buffer = new byte[w * h];
  }
  public byte GetValue(int x, int y) {
    int i = x + Width * y;
    return Buffer[i];
  }
  public void SetValue(int x, int y, byte value) {
    int i = x + Width * y;
    Buffer[i] = value;
  }
}

Definiamo ora la struttura del nostro automa tramite una classe astratta. E’ una definizione generica che sarà valida anche per automi bidimensionali (come per esempio il famoso gioco della vita di Conway).

public abstract class Automata {
  public Environment2D Env { get; protected set; }
  protected Environment2D Env0 { get; set; }

  public Automata() { Env = new Environment2D(0, 0); Env0 = null; }		
  public int Width { get { return Env.Width; } }
  public int Height { get { return Env.Height; } }
  public abstract bool IsFinite();
  public abstract bool Next();
  public abstract void RandomInit();
  public abstract void StandardInit();
  public virtual void SetSize(int w, int h) { Env = new Environment2D(w, h); }

  protected abstract byte ComputeRule(int x, int y);
}

public enum AutomataInitialCondition {
  Random, Standard
}

L’automa va inizializzato di dimensioni tramite il metodo SetSize(int w, int h), vanno impostate le condizioni iniziali, che possono essere generate casualmente (RandomInit()) oppure attivando solo la cella centrale dell’automa (StandardInit()). Next() calcola e attualizza la nuova generazione, applicando la regola definita in ComputeRule(int x, int y).

Vediamo ora come implementare il caso specifico dell’automa unidimensionale di Wolfram.
Mi preme introdurre la definizione di notazione di Wolfram, che potete dolcemente leggervela su Wikipedia.

public class Automata1DWolfram : Automata {
  private int x = 0;
  private int y = 0;
  private byte rule;
  private byte[, ,] tt = new byte[2, 2, 2];
  public Automata1DWolfram(byte rule) {
    this.rule = rule;
    tt[0, 0, 0] = (byte)((rule & 1) > 0 ? 1 : 0);
    tt[0, 0, 1] = (byte)((rule & 2) > 0 ? 1 : 0);
    tt[0, 1, 0] = (byte)((rule & 4) > 0 ? 1 : 0);
    tt[0, 1, 1] = (byte)((rule & 8) > 0 ? 1 : 0);
    tt[1, 0, 0] = (byte)((rule & 16) > 0 ? 1 : 0);
    tt[1, 0, 1] = (byte)((rule & 32) > 0 ? 1 : 0);
    tt[1, 1, 0] = (byte)((rule & 64) > 0 ? 1 : 0);
    tt[1, 1, 1] = (byte)((rule & 128) > 0 ? 1 : 0);
  }
  public override bool IsFinite() {	return true; }
  public override void SetSize(int w, int h) { Env = new Environment2D(w, h);	}
  public override void RandomInit() {
    Random rand = new Random(Environment.TickCount);
    for (x = 0, y = 0; x < Env.Width; x++)
      Env.SetValue(x, y, (byte)rand.Next(0, 2));
    x = 0;
    y = 1;
  }
  public override void StandardInit() {
    Env.SetValue(Env.Width / 2, 0, 1);
    x = 0;
    y = 1;
  }
  public override bool Next() {
    for (int i = 0; i < Env.Width; i++) {
      if (y >= Env.Height)
        return false;

      Env.SetValue(x, y, (byte)(ComputeRule(x, y)));
      if (x == Env.Width - 1) {
        x = 0;
        y++;
      } else
        x++;
    }

    return true;
  }		
  protected override byte ComputeRule(int x, int y) {
    byte l = Env.GetValue(x == 0 ? 0 : x - 1, y - 1);
    byte c = Env.GetValue(x, y - 1);
    byte r = Env.GetValue(x == Env.Width - 1 ? x : x + 1, y - 1);
    return tt[l, c, r];
  }
  public override string ToString() {
    return string.Format("Wolfram Rule {0}", rule);
  }
}

L’automa è ben che implementato in tutta la sua gustosità, il parametro rule passato nel costruttore Automata1DWolfram(byte rule) definisce la regola che identifica univocamente l’automa cellulare di Wolfram. Un po’ come una legge universale che decide la vita e la morte degli esemplari di una popolazione, un po’ come un Dio che determina le sorti di un mondo immaginario ma ben regolato da leggi fisiche e strutturato da fondamenti matematici. Per ognuna delle otto possibili configurazioni dell’intorno viene deciso (la regola!) se la cella dovrà vivere o morire.

Wolfram Regola 30

L'immagine visualizza la regola 30 di Wolfram (30 = 00011110 in decimale).

In WPF, utilizzando una UniformGrid, è semplice quanto banale creare una vista d’insieme degli 256 possibili automi cellulari di Wolfram, vi allungo qualche immagine direttamente dal mio schermo.

Wolfram Rules 1 Cell Initial Condition

Le 256 regole di Wolfram, con una cella attiva come condizione iniziale.

Wolfram Rules with Random Initial Condition

Le 256 regole di Wolfram, con condizione iniziale casuale.



Ho caricato l’eseguibile e i sorgenti del progetto in questa pagina: cellular-automata-world. Se qualcuno volesse contribuire, si faccia avanti! ;=)

#salvaiciclisti è il nuovo movimento per una movimentazione urbana sostenibile

Tu non sei bloccato nel traffico. Tu sei il traffico.

Tu non sei bloccato nel traffico. Tu sei il traffico.

E’ da qualche giorno che nella rete si sente un gran parlare di #salvaiciclisti, un nuovo movimento derivato dalla volontà di rendere migliore e sicura la vita dei ciclisti e di chi si sposta in strada in bicicletta. Avverto un cambiamento, l’idea di una città a misura di bicicletta, non lo sentite anche voi? Questo blog approva e aderisce alla campagna salva i ciclisti!

Oltre all’account twitter esiste anche un gruppo su facebook, e una pagina ufficiale.

Aggiornamento: il sito ufficiale della campagna salviamo i ciclisti!

Libri e appunti sugli automi cellulari

appunti sugli automi cellulari

Alcuni esempi di automi cellulari unidimensionali

Raccolgo qui delle risorse sugli automi cellulari, come base per iniziare a conoscerli e comprenderli. Non è una cosa facile percepirne la loro potenzialità e il loro significato intrinseco. Con automa cellulare si intende un modello matematico discreto in grado di descrivere perfettamente un sistema biologico complesso, come ad esempio la crescita di una foglia di palma, le fantasiose colorazioni di una conchiglia, la proliferazione nello spazio di una certa specie biologica.
 

Come l'automa cellulare descrive pattern biologici

Come l'automa cellulare descrive pattern biologici


Immagine da Cellular Automata.
 

Ho creato una pagina su facebook sugli automi cellulari, unico luogo di ritrovo italiano dove poter scambiare informazioni e conoscenze!

Qui un elenco di articoli e pubblicazioni interessanti trovati in rete:

 

Vi consiglio A New Kind of Science, il libro bibbia sugli automi cellulari. E’ stato scritto dal fisico matematico Stephen Wolfram, che negli anni ottanta sperimentò per primo automi cellulari computazionali.

Altri libri di interesse:

 

Da piccolo sono stato rapito dagli alieni e non lo sapevo

Questo è il test che propone Corrado Malanga nel suo Abduction Protocol per identificare senza alcun dubbio se un bambino è stato rapito dagli alieni.
Mi sembra infallibile! =D

Hirt Test

Il test di Hirt è un test proiettivo che consiste nel far vedere al bambino alcune figure e chiedergli di identificarle. Immancabilmente se il soggetto ha avuto rapimenti: identifica la figura del grigio con espressioni del tipo "è quello che mi viene a prendere di notte quando i miei genitori dormono"

Primo buco nero fotografato al cern di ginevra

La terra sarà distrutta da un buco nero? Secondo calcoli quantistici, che inglobano al loro interno la nuova teoria delle superstringhe sviluppata proprio al cern di ginevra, la terra verrà inghiottita dal buco nero nei nove mesi successivi al 31/09/2012, assicurando la fine del mondo all’umanità intera.


Il 31 gennaio del 2012, durante la fase di accensione e di start up del nuovo mega acceleratore di particelle, è stata rivelata una forte emissione di raggi gamma in un particolare punto dell’acceleratore. Si tratta del primo buco nero prodotto dall’uomo. Gli scienziati che stanno continuando a studiare questo fenomeno fisico in veloce espansione, si dicono sconfitti dalla manifestazione della natura e delle sue leggi fisiche. La fine del mondo sembra vicina, eppure così illogica e utopistica. La filosofia degli ultimi secoli non ci ha fornito ancora le basi per superare questo fatidico momento, ed elevarci ad entità fisiche superiori. Nonostante tutto, la determinazione e la devozione dei ricercatori alla scienza ed alla letteratura scientifica continua a persistere anche in una situazione catastrofica come quella in cui ci troviamo. Un evento così sensazionale non si era mai potuto osservare così da vicino, e sottrarsi allo studio di un tale fenomeno risulterebbe contrario ad ogni etica morale, scientifica e giuridica che il mondo ha plasmato come propria immagine e somiglianza. Il team di scienziati che lavora al progetto si è fatto scappare una piccola chicca: al neonato buco nero è stato assegnato il nome di Pernolino.

Udine parodia tributo ai mostri del crossover

Oggi presentiamo un video bellissimo sopra le righe dove un grumo di giovini udinesi hanno reinterpretato un video dei Limp Bizkit, girato da mani esperte e gloriosamente tremanti del fascinoso Riccardo Peterlunger di Codroipo giovine cineautore e cineasta friulano, e diretto dal succulento Matteo Delli Zotti.

Le locazioni utilizzate rappresentano il top dell’interland udinese e dell’intera regione Friuli-Venezia Giulia: parcheggio principale del centro commerciale Città Fiera, giardini pubblici nei pressi dell’abitato di Torreano di Martignacco (Udine).

Scoprire la campagna pordenonese in bicicletta

Vi consiglio un bel giro rilassante tra il verde e la tranquillità dei campi pordenonesi, da fare rigorosamente in bicicletta in una giornata di bel tempo! Questo il tragitto di massima: partenza dal cimitero comunale di Pordenone, verso Rorai, Porcia, Pieve, Palse, Tamai, Brugnera.
Clicca per aprire il percorso.

Lago della Burida: prima sosta sulle rive del più famoso lago artificiale della città. Potete ammirare magnifici cigni in e anatre in libertà. Sconsigliata la balneazione! Maneggio cavalli, soffermatevi ad osservare silenziosamente i cavalli del maneggio di via Cappellari. Odore di mucche, deliziatevi con l’inebriante fragranza di sterco di vacca di via Rustighel. Campanile di Tamai, fatevi abbagliare dal maestoso campanile di Tamai. A guardarlo troppo a lungo, vi farà male il collo. I.P.S. Brugnera: fermatevi a visitare il complesso del mobile, un luogo storico e tutt’ora all’avanguardia, dove giovani menti coltivano e studiano l’interesse per il design e la ricerca raffinata di oggetti e soluzioni d’arredo.

Cudumar-xmpp, un nuovo client gratuito e leggero conforme allo standard jabber/xmpp

Oggi presentiamo un innovativo software per accedere ai network XMPP: cudumar-xmpp. Gratuito, leggero, 100% conforme allo standard XMPP. Il nome buffo deriva dalle origini geografiche degli ideatori, friulani DOC e con uno spiccato amore per le verdure. Infatti cudumar in friulano significa cetriolo, un nome decisamente buffo da assegnare ad un programma!

cudumar-xmpp versione 0.0.2

cudumar-xmpp versione 0.0.2

Ho avuto il piacere di incontrare di persona Daniele Tenero, uno degli ideatori.

La domanda di rito: come nasce questo nome… “cudumar”?
A me piaceva “cudumar & verzutin”. Hai mai fatto una minestra di cetrioli e verze? Spettacolare… dovresti provarla. Fai bollire due cetrioli grossi a piacere in un litro d’acqua, dagli solo una lavata sotto acqua corrente ma non togliere la buccia! E’ la parte più buona, i cetrioli non vanno pelati. Aggiungi metà verza e lascia riposare per qualche minuto. Frulla il tutto con un mixer ad immersione, aggiungi sale, pepe se vuoi anche una cipolla che fa sempre bene e ti leccherai i baffi.
Volevamo un nome simpatico, che ricordasse la nostra friulanità, l’amore per le verdure, lo stile di vita semplice e casereccio. E così è anche cudumar-xmpp, semplice e anche un po’ contadino, senza tanti fronzoli un po’ come la gente friulana, che mantiene ancora un forte legame con la terra e la natura.

Parlaci di questo progetto. Perché è nato?
Inizialmente voleva solo essere un esercizio di stile, ne più ne meno. Ci interessiamo da tempo di protocolli e standard aperti sia per lavoro che per passione, è una filosofia che ci piace e intriga moltissimo. Tutto è nato dalla necessità di approfondire come lavora il server Jabber di Google Talk per valutarne possibili interazioni con client esterni. Soprattutto per quanto riguarda la trasmissione audio vocale, le chiamate VoIP, i flussi video. Un bel lavoro di reverse engineering che ci ha portati a conoscere nel dettaglio lo standard xmpp, le sue estensioni ma anche molte variazioni “fuori standard”. E’ nato per passione, perchè a noi piace impastarci il cervello, tenerci sempre in movimento, e questi risultati ci ripagano con grande soddisfazione.

Dopo un approccio filosofico buttiamoci sul tecnico. Quali tecnologie adotta cudumar-xmpp?
Le ultime e più innovative sul mercato: WPF .Net Framework 4. Con WPF si semplifica enormemente tutta l’analisi e lo sviluppo dell’interfaccia utente. L’utilizzo della versione 4 del .Net Framework permette di sfruttare tutti i vantaggi di un linguaggio di alto livello e di particolari funzionalità. Esempio: LINQ to XML ci ha permesso di semplificare notevolmente l’implementazione del protocollo XMPP, che per chi non lo sapesse è basato su XML.

Un progetto nato da poco ma già sulla bocca di tutti, se ne parla molto nelle comunità online. Quali sono i piani di sviluppo futuri?
Abbiamo puntato molto sul supporto alla chat di Facebook, con l’implementazione di un nuovo meccanismo SASL (DIGEST-MD5) per l’autenticazione ai servizi facebook. Attualmente, con questa nuova release, cudumar-xmpp è in grado di collegarsi a qualsiasi server jabber che supporti SASL PLAIN / TLS / SASL DIGEST-MD5. Abbiamo in programma di supportare altri meccanismi di autenticazione per estendere il supporto alla totalità dei servizi jabber in rete. Oltre questo aspetto tecnico ci preme il restiling grafico del logo, stiamo valutando diverse proposte grafiche da persone altamente fantasiose.

Un cetriolo parlante quindi?
Potrebbe essere.

Ultima domanda, ma non la meno importante: dove ti troviamo in rete?
Esiste un blog del progetto dove è possible restare sempre aggiornati sulle ultime novità e ultime releases, una pagina su facebook che rende il tutto molto social, la pagina di progetto per gli sviluppatori ospitata su google code dove è possibile contribuire e scaricare l’ultima versione del programma.
Cudumar Blog
Cudumar su Facebook
Cudumar su Google Code
Cudumar su Google Plus