Newsgroup: it.cultura.filosofia
Titolo: Darwin e l`informatica

In tutti i programmi "darwinisti" che ho visto, il concetto e` a grandi linee questo:
 
1) si individuano i caratteri da sottoporre a selezione
2) si presume che questi caratteri siano codificati in variabili: ovvero in spazi isolati e contigui, distinti dal programma principale
3) si mutano casualmente le variabili, lasciando il programma principale intatto
 
A me sembra concettualmente piu` simile al lamarckismo, soprattutto per questi aspetti:
 
1) la presenza di una volonta` che decide il carattere da modificare (giraffa o programmatore)
2) il fatto che questo carattere sia nettamente separato, e non intrecciato ad altri (lunghezza del collo, codificato come se fosse una cifra in una variabile di programma)
 
Senza queste due astrazioni -per me totalmente arbitrarie- il programma si bloccherebbe oppure darebbe risultati inattesi.
 
Mi chiedo allora: cosa c`e` di darwinista in tutto cio`?

 
<pauperino@

Se vuoi te lo dico in lingua d'oil!!?
Hai gi' toppato al punto 1)
!si individuano i caratteri da sottoporre a selezione!
 
che frase e'? premetto che non voglio saperlo, ma immagino che
il carattere possa essere tipo la lunghezza del pene no!?
quello da sottoporre a selezione, nevvero!!
 
 
 
 
 
 
 


 
Dunque e' casuale che uno arriva con una minchia tanta!?
Ma poi la selezione non e' piu' naturale se voi ci mettete le vostre
luride manacce!?
Ma gli effetti collaterali varii ed eventauli di queste vosatre bizzarre 
manipolazioni
genetiche li conoscete, o pensate esclusivamente alla minchia tanta e 
succeda
quel che succeda!? 
 
 


 
  dimenticavo il servizio!!
 
https://www.youtube.com/watch?v=d--nSm-wshk
 
 
Frank Zappa - Tengo na Minchia Tanta
232.906 visualizzazioni 
 
 


___________________________
Purtroppo non capisco di che cosa tu stia parlando. 
(Mi succede spesso :-) )
 
Pero' ho scritto la mia prima Darwin Machine nel 1972 su un Wang 720
in linguaggio macchina. Se vuoi proviamo a risolvere un'equazione, 
magari di quelle che non hanno una soluzione algebrica, come ad es.:
 
sin(x)=1/x
 
Per x=1, sin(x)=0.84
Per x=Pi/2, sin(x)=1
Partiamo da x=1.2, applichiamo mutazioni casuali, se 
Errore=Abs(sin(x)-1/x) migliora accettiamo la mutazione, se no
la scartiamo. Non c'e' niente di lamarckiano in tutto cio'.
 
 


 
Ma veramente io questo genere di algoritmi li ho sempre sentiti chiamare 
algoritmi genetici, programmazione evolutiva, o con altri nomi di questo 
genere. Senza un esplicito riferimento a Darwin, che effettivamente mi 
sembra abbastanza forzato.
 

 Non c'e' niente di lamarckiano in tutto cio'.
 
Analizzando il codice, quello che trovo concettualmente piu` vicino al lam. che al dar.:
 
1) le modifiche vengono applicate direttamente sul codice "vivente", e non su quello dei discendenti (gameti)
2) le modifiche sono mirate, come se l`organismo sapesse cosa modificare e cosa lasciare immutato, concentrando le mutazioni solo su certi caratteri e non altri.
 
Il punto 1 potrebbe essere accettabile come semplificazione, ma il 2 non vedo come farlo entrare nel darwinismo.
 

 Il punto 1 potrebbe essere accettabile come semplificazione, ma il 2 non vedo come farlo entrare nel darwinismo.
 
3) finalismo implicito, codificato nello stesso programma (condizione se ... allora)

 sembra abbastanza forzato.
 
http://www.iread.it/lz/darwin.html
 ;-)


___________________________
Wow! Il mio programma si e' riprodotto. Ci ha messo trent'anni, ma alla
fine ce l'ha fatta. Chissa' se l'ha fatto per una volonta' sua 
intrinseca o se si e' riprodotto per caso e Pauperino e' "l'altro
nome del Caso"? :-)
 
Veniamo al punto 1). L'obiezione mi sembra superabile con una semplice
interpretazione: i vari risultati parziali sono le generazioni, la
mutazione avviene tra una generazione e l'altra. Complicando un po'
il programma, si potrebbero generare, ad ogni generazione, una 
popolazione di risultati e farli competere tra loro.
 
Punto 2). Le cose avvengono "come se" fossero mirate, e' l'eterno
equivoco dei lamarckiani. In realta' abbiamo usato il caso. Mi vengono
in mente le parole di Dawkins:  "È ormai invalsa, tra i biologi, questa
abitudine di parlare di un animale o di una pianta, o di un gene, come 
se cercasse consapevolmente il modo migliore di aumentare il proprio successo [...]. È un linguaggio di comodo che non è dannoso, a meno 
che non capiti fra le mani di persone che non sono in grado di capirlo".
 
Punto 3) Finalismo Implicito. Se qualcuno sostiene, ad es., che un 
sistema non-finalistico e' stato progettato da un dio che aveva il 
finalismo in testa e che quindi usa il sistema non-finalistico per
un suo fine, questa sarebbe una classica posizione infalsificabile.
Nel bene e nel male. Per una mentalita' scientifica, cio' che non e'
falsificabile non viene neanche preso in considerazione. Per uno
spiritualista, giusto il contrario, lo troverebbe *compatibile* con
la realta'. :-)
 
 

 la realta'. :-)
 
Non ho capito bene cosa hai voluto dire; se invece sono stato io a non essere chiaro, lo ribadisco: nel tuo programma la finalita` e` implicita perche` (oltre a non essere dichiarata come tale) e` codificata nel programma stesso. E non e` un "come-se": e` proprio voluta.


_______________________________
Anche nel darwinismo c'e' una finalita' irrinunciabile: la sopravvivenza.
 


In attesa di novità, direi piuttosto non "finalità" ma meccanismo :-)
 


 
Si tratta del meccanismo della minima resistenza.
come acqua che scorre.
Ma gli scienziati devono trovare il genio della salita!!
E sempre "di pene" si stratta!! dai retta!! 
 
 

 E sempre "di pene" si stratta!! dai retta!!
 
 ...."Il gene della salita",
inocularlo nell'acqua e finalmente saranno i creatori!
Dico che si tratta "di pene" perche' ormai questi casi
sono patologici e vanno visti in chiave psicologica.
Abbiamo tanti cazzi da risolvere qui, che piu' non se ne puo'!
E guarda 'sti coglioni a cosa pensano!
 
 
 


______________________________
Diciamo meglio allora: la *volonta' di sopravvivere*.
Tutto il *meccanismo* darwiniano regge se ammettiamo che la volonta'
di sopravvivere sia una qualita' finalistica gia' accquisita: 
qualunque organismo finalizza quel che fa *per* sopravvivere.
 
Non credo che sia impossibile dedurre che anche questa qualita'
sia stata mutuata da un meccanismo piu' elementare: se hai la volonta'
di sopravvivere forse sopravviverai, diversamente verrai travolto
da quelli che ce l'hanno. E questo ci dice anche che alcuni atteggiamenti
finalistici possono nascere da un'evoluzione non finalista.
 

 
"Chenickname"
 
 
di sopravvivere forse sopravviverai, diversamente verrai travolto
da quelli che ce l'hanno. E questo ci dice anche che alcuni atteggiamenti
finalistici possono nascere da un'evoluzione non finalista.
 
...
cioe' hanno una volonta' di sopravvivere cosa: il "gene della salita"?
o sono tutti, cioe' tutto e' provvisto del gene egoista?
Ogni cosa in natura dice io-io-io..ma a me sembra che lo dicano
solo gli umani oppure gli asini. Abbiamo questo i-o in comune.
Ma l'asino non credo che sia tanto scemo, sinceramente..
Non individuo essere peggiori di questi filantropi dell'umanita',
si vede in fatti in fondo, a che pozzo e' finito...
E siete tutti indifferenti... questa e' la summa del vs pennsiero assente,
Altro che egoista, voi non siete presenti a voi stessi. 
 
 


____________________________
A parte il gene egoista di Dawkins, che e' un'ipotesi audace, in
natura tutto cio' che vive appare egoista, persino i vegetali
tendono a soffocare il vicino vegetale che gli contende le risorse
del territorio. L'egoismo e' alla base della vita.
 
 

 
"Chenickname"
 
____________________________
A parte il gene egoista di Dawkins, che e' un'ipotesi audace, in
natura tutto cio' che vive appare egoista, persino i vegetali
tendono a soffocare il vicino vegetale che gli contende le risorse
del territorio. L'egoismo e' alla base della vita.
.....
 
 
Vedi, le persone intelligentio non si urtano!
Io temo solo gli idioti!!:))
Com'e' se l'egoismo ' alla base della vita, che trovo cosa
buona er giusta, com'e' cje non siete sopravvissuti?!
Com'e' che siete assenti!?
Com'e' che io parlo esclusivamente a demoni!?
Perche' essi erano piu' egoisti di voi!!
;)
 
 


 
Io paarlo esclusivamente a demoni, e voi pensate alla mia
solita bizzarria.. va bene cosi', ma posso insultarvi come
mi pare e voi non vi urtate perche' siete demoni e ci
conosciamo bene. Risulta n tutto cio' solo la vostra assenza...
Quindi il gene egoista di chi!?
Voi siete usciti in pratica dall'uovo di Pasqua...
sarete sempre dei pulcini a questo mondo. 
 
 

 Io temo solo gli idioti!!
 
e me stesso! 
 
 


I Demoni vorrebbero *urtarsi* ma e' impossibile!
possono fingere di urtarsi, possono inscenare le piu
lamentose telenovelas(quelle che voi inscenate)--
(voi tutti poveri esseri umani, siete il trastullo degli dei)..
Ora pero' pure quelli si sono rotti le balle e hanno lasciato il campo
alle larve.... una specie di verminaio...e' cio' che resta.
E pure questo e' un dono del signore...
e' un'idea pure quella e io sono senza limiti..
questo e' quanto.
Ho offeso pesantemente l'altro giorno il padrone della giostra qua,
e gli ho detto: fammi vedere se sei il padrone qua e sbattimi fuori!?
(il testo esatto e' Sei tu il Padrone?
e allora bannami 'ste palle,
coglione.)
Dunque il demone la' dietro sapeva che svariavo e non ha risposto,
mentre hanno bannato il deboni ad es...
il mario della julia ecc... Mai successo sui ng!
 
 
 
 
 


In pratica "un essere", non meglio connotato, in quanto tale
e' come un oggetto nello spazio, se e' in moto continua a muoversi
se sata fermo, senza spinta non si muove, e nn si ferma se non
lo blocchi!!:)) 
 
 


 
Volevo dire qlcs di molto piu' complesso, evidentemente che sarebbe
dovuto discendere logicamente.. ovvero parlavo dell'intelligenza perfetta
che alla fine si rispecchia, non nella vostra realta'. nella natura si 
evidenzia
tale carattere che e' connotato come dicevo dalla mancanza di volonta', 
invece...
Avete scambiato per volonta' il verso dell'energia e della spinta..
va di la', semplicemente perche' di la' l'avevano spinta.
Perche' dovrebbe avere una volonta' l'intelligenza!? E' qualcosa per chi non 
ha raggiunto..
l'intelligenza si mette a servizio del difetto, seguendo il suo verso.
Ma non esiste alcuna direzione.. tranne il capriccio 
 
 


 
Leggendo il sito, sembrerebbe che il riferimento a Darwin sia 
un'iniziativa dell'autore che ha ideato il programma autonomamente, 
senza conoscere l'ampia letteratura che c'è in materia.
 
Devo dire che il programma è forse un pochino troppo semplificato, tanto 
più se si vuole chiamare in causa Darwin: infatti il concetto di lotta 
per la sopravvivenza, che è uno dei punti di forza degli algoritmi 
genetici, è stato totalmente eliminato. Questo vuol dire che ben 
difficilmente il programma sarà in grado di superare i minimi locali. 
Inoltre, la variabile che cambia è solo una, ed è di tipo numerico e non 
vero/falso, questo la rende lontana dal concetto di gene e di cromosoma.
 
Il funzionamento di un algorimto genetico invece dovrebbe essere questo: 
si parte non da uno ma da una popolazione di individui, ognuno con un 
genoma diverso. Si fanno "combattere" in qualche modo tra loro i vari 
individui (tuttavia serve stabilire a priori la cosiddetta "funzione di 
fitness", cioè i criteri con cui si stabilisce il vincitore). I migliori 
sopravvivono, i peggiori muoiono. Solo a questo punto c'è la fase della 
riproduzione, dove ognuno dei vincitori fa un certo numero di figli, 
copiando i propri geni. I figli tuttavia non sono una copia esatta dei 
genitori, ma avvengono alcune mutazioni casuali. Queste mutazioni 
avvengono nei figli, non nei genitori! E non sono il prodotto della 
volontà di qualcuno, ma solamente la simulazione di errori di 
trascrizione. Quindi non c'è traccia di lamarkismo.
 
Esistono anche altri tipi di algoritmi, dove invece i cambiamenti non 
sono casuali ma diretti verso la direzione apparentemente migliore. 
Questo potrebbe far pensare al lamarkismo, ma comunque è tutt'altro tipo 
di approccio.

 
 
______________________________
Nel 1972, quando l'autore compilava questi primi programmi, non solo
non c'era un' "ampia letteratura" al riguardo, ma l'algoritmo era
assolutamente ignorato da qualunque corso universitario di Calcolo
Numerico.
 


Non si potrebbe piuttosto inserirlo nel metodo Monte Carlo?

Queste mutazioni avvengono nei figli, non nei genitori! E non sono il prodotto >della volontà di qualcuno, ma solamente la simulazione di errori di >trascrizione. Quindi non c'è traccia di lamarkismo.
 
Ma sono sempre mutazioni mirate, e modificazioni di parametri (doppia astrazione indebita); quindi non assolutamente casuali (altrimenti si bloccherebbe tutto, anche con una sola mutazione; chi ha programmato in linguaggio macchina lo sa benissimo).
 
Quindi sono questi i punti lamarchiani:
 
1) precisa identificazione del carattere da modificare
2) volonta` di modificazione
 
Il finalismo e` evidente anche perche` in questi algoritmi come se ci fosse scritto: "diventa un elefante e poi smetti di modificarti" (infatti il risultato e` noto fin dall`inizio).
 


________________________
Direi di no, anche se hanno in comune l'uso del caso.
Il Metodo Monte carlo e' ad anello aperto, la Darwin Machine ha un
feedback.


 
Certo che è evidente il finalismo.
 
Anche nelle razze animali c'è un evidente finalismo, che è operato 
dall'uomo.
 
Non capisco perché tu faccia fatica a conciliare il finalismo con il 
darwinismo.

Il 05/05/17 08:27, Chenickname ha scritto:

Neanche oggi trovi questi argomenti nei corsi di Calcolo Numerico. Il 
calcolo numerico non è altro che la discretizzazione dell'analisi 
matematica.
 
Qui invece parliamo di un tipo di algoritmi cosiddetti "euristici", che 
hanno un approccio totalmente diverso alla soluzione del problema.

 alto.
 
Ma alla fine qualsiasi linguaggio di programmazione produce linguaggio macchina.
E la mutazione agisce sempre nel livello piu` basso (fisico) non in quello astratto: anche un solo bit modificato puo` cambiare totalmente un`istruzione.


 
No, la mutazione agisce nel livello più astratto, quello di descrizione, 
cosa ti fa supporre il contrario?

 
 
 
 
oppure la predisposizione, o tendenza, ad allungare il dito anulare richiama più testosterone. 
 
 
 
 
 
 
 


______________________
Ho dato un'occhiata a queste (per me recenti) simulazioni e le ho trovate
davvero interessanti. Il neodarwinismo si e' arricchito di molti
concetti, soprattutto con la genetica, pero' devo dire che il concetto
base di mutazione_casuale/selezione_naturale e' rimasto immutato.
 
E' chiaro pero' che, se l'obbiettivo di questi algoritmi e' di ottenere
un risultato ingegneristico, al progettista non importa un gran che di
essere perfettamente aderente al darwinismo. Vado quindi a immaginare
che se un intervento lamarckiano o comunque arbitrario mi migliora
il risultato, questo verra' adottato.
 
Per questo ritengo piu' adatto titolare questi lavori semplicemente
come "genetic algoritm" o "evolution", senza un preciso riferimento
a Darwin.
 
 

 cosa ti fa supporre il contrario?
 
Certamente nella programmazione accade cosi`, ed e` proprio la differenza che volevo mettere in luce.


 
Ok, prova ad immaginare questo esperimento, o, e se vuoi, a farlo.
 
Scrivi una decina di numeri casuali in un file, in formato binario. 
Assegna a quel file l'estenzione ".com" e prova a lanciarlo come fosse 
un programma. Ovviamente, con grande probabilità, il programma non farà 
niente e si bloccherà. Ma di questi programmi ne generi qualche 
centinaio di migliaia. Ce ne sarà uno che invece di bloccarsi scrive 
sullo schermo qualche carattere senza senso e poi termina? Direi proprio 
di sì: se conosci il set di istruzioni del tuo processore puoi calcolare 
facilmente la probabilità che ciò avvenga.
Prendi quel programma, ne fai centomila copie, mentre gli altri li 
cancelli. Ad ogni copia inserisci, togli, o modifichi un byte in una 
posizione casuale. Esegui di nuovo tutti i programmi.
Questa volta, probabilmente, la maggioranza dei tuoi programmi scriverà 
qualcosa sullo schermo e terminerà senza bloccarsi. E siamo solo alla 
seconda generazione.
Ora osserva le stringhe che vengono scritte, e confrontala con la 
stringa "Hello, world". Assegna ad ogni programma due punti per ogni 
lettera giusta nella posizione giusta, e uno per ogni lettera giusta in 
posizione sbagliata. Seleziona e duplica i dieci programmi che hanno 
ottenuto il punteggio più alto, cancella i programmi rimanenti, applica 
le mutazioni, ed esegui di nuovo i programmi. Ripeti tutta la procedura 
un numero indeterminato di volte. Nel giro di poche generazioni avrai 
ottenuto almeno un programma che scrive correttamente "Hello world" e 
termina regolarmente.
 
Poi possimao discutere si sia corretto dire che quel programma è uscito 
fuori in maniera puramente casuale, o se invece è più corretto dire che 
l'hai creato tu, o magari che l'ho creato io che ti ho dato queste 
istruzioni.


 
Anche io eviterei un preciso riferimento a Darwin, ma per un altro 
motivo: Darwin viene spesso, a torto o a ragione, tirato in ballo per 
questioni di natura filosofico-religiosa che poco hanno a che vedere con 
la scienza e meno ancora con l'informatica. Per esempio, riguardo il 
creazionismo o il finalismo.
 
Negli algoritmi genetici c'è un intento evidentemente finalistico dato 
non tanto delle mutazioni casuali, ma dalla funzione di fitness. Quindi 
chiamare in causa Darwin potrebbe generare dei malintesi.
 
 
 

Il 06/05/17 02:04, 
ideap...@googlemail.com
 ha scritto:

Sarebbe abbastanza inverosimile, in situazioni come queste, tentare di 
invertire la causa con l'effetto.
Il testosterone può avere vari effetti sull'organismo, ma di certo non 
possono essere gli effetti a generare il testosterone. Così come un gene 
può generare una proteina, ma una proteina non può generare un gene.
 
 


 
E invece e' proprio cosi0 in moltissimi casi! non e' che tentate di 
invertire
ma partite proprio invertiti perche' non esiste il gene del lungo collo 
della
giraffa o della minchia, esiste o e' esistita questa tendenza della giraffa 
a
beccare la foglia piu' in alto.
E' la tendenza a modificare la materia non l'inverso.
Pecoroni!!
E la vostra tendenza a ragionare come criceti che vi trasformera' in essi, 
un giorno!! 
 
 


ma se li fai mettere d'accordo c'è chi poi non può più giocare allo scienziato. 
 
 
 
 
 
 


e sei tu a stabilire ciò che è effetto oppure causa... o effetto causante, o causa effettuante? 
 
 
 
 
 
 
 
 

 un giorno!!
 
 
 
 
 
ma se li fai mettere d'accordo c'è chi poi non può più giocare allo 
scienziato.
 
....
 
 
 
NOno, ora ti dico come ragionano: (e mica sono fessi..)
non interessano proprio le cause o gli effetti.
cercano un gene che esiste, perche la giraffa l'ha prodotto,
quello della lunghezza,
e vogliono applicarlo alla minchia!
Basta che funziona!
 
 
 
 
 
 
 


c'è chi cerca di dimostrare che tutto succede a caso
 
 
 
 

 seconda generazione.
 
Questo posso farlo; la seconda parte mi sembra meno interessante, oppure cambiamo frase ;-) (le leggi le altre mie discussioni?).
 
Per far correre i nostri programmi casuali ho pensato di scrivere un emulatore in python del processore 6502 (8bit). Ho gia` buttato giu` del codice per trattare i diversi modi di indirizzamento:
 
MEM=np.zeros(65536,dtype='uint8') #memoria 64 kb
LN=0x4000 #linea corrente
 
modo={
  'immed':      (LN+1,LN+1),
  'zerop':      (MEM[LN+1],LN+1),
  'zerop_x':    (MEM[LN+1]+X,LN+1),
  'zerop_y':    (MEM[LN+1]+Y,LN+1),
  'abs':        (MEM[LN+1]+MEM[LN+2]<<8,LN+2),
  'abs_x':      ((MEM[LN+1]+MEM[LN+2]<<8)+X,LN+2),
  'abs_y':      ((MEM[LN+1]+MEM[LN+2]<<8)+Y,LN+2),
  'indirect_x': (MEM[MEM[LN+1]+X]+(MEM[MEM[LN+1]+X+1]<<8),LN+1),
  'indirect_y': (MEM[MEM[LN+1]]+(MEM[MEM[LN+1]+1]<<8)+Y,LN+1)
  }
 
Questa parte di codice e` immutabile.

Il 07/05/17 07:58, 
ideap...@googlemail.com
 ha scritto:

Non è che io usi la sfera di cristallo per discernere gli effetti dalle 
cause. Di solito faccio degli esperimenti.
 
Se esco a fare una passeggiata quando piove, mi inzuppo i vestiti. Se 
invece esco con i vestiti inzuppati, questo non basta a far piovere. 
Quindi deduco che è la pioggia a bagnare i vestiti e non i vestiti 
bagnati a causare la pioggia.
 


 
Bene, fammi sapere come va.
 
 

 bagnati a causare la pioggia.
 
 
 
 
che caspita c'entra??? 
 
la pioggia e i tuoi vestiti mica fanno parte di uno stesso sistema. 
 
 
 
 
 
 
 
 
 
 
 


 
Non fanno parte entrambi del pianeta terra?
Comunque, se preferisci un esempio più inerente, tu hai mai visto una 
proteina generare un gene? Non ti risulta che sia il contrario?
 


eccerto che fanno parte del pianeta terra, ma allora chiudiamola qui con ogni genere di studi su sistemi e sottosistemi e molecole particelle geni e tutto quanto ... se permetti.
O si esaminano le cose in modo globale o ci si addentra nei vari sistemi,e mondi e micromondi, circoscrivendoli ognuno per quanto possibile, .... tipo in sto caso il ciclo dell'acqua/pioggia relativamente all'uomo, non ai vestiti che indossa in quel dato momento.
Se fai rientrare in uno stesso sistema pure gli abiti che indossi, perchè allora escludere altre cose a te aggiunte, tipo occhiali, o cinte, o l'agendina o il telefonino... ecc? ... e di questo passo di cosa in cosa ad essa asssociata si arriva al Tutto, come vedi. Quindi? 
O l'uno o l'altro approccio alle cose, se permetti. 
Per conto mio tutto è correlato ... ma a fare distinzioni, qui, mica sono io. 
 
 
Continuiamo. 
Io la proteina non la ho mai vista, ne so qualcosa per sentito dire, ma mica sto a "vedere" queste cose, il mio approccio alle cose tutte è diverso, ... ma suppongo che, facendo parte di uno stesso sistema, pure le proteine contribuiscano alla genetica.  Tanto per dire ... il cibo influenza le emozioni (e viceversa) e queste influenzano i geni.... ecc 
 
Ma .. ok il gene, ma l'imprinting genetico non è meno importante, nell'ereditarietà. E quindi, non ci si dovrebbe limitare alla sola genetica, ma guardar pure all'epigenetica, ad esempio... e chissà a cos'altro ancora, di cui la scienza (ufficiale) deve e sempre più dovrà prendere atto. 
E' anche per questo che il mio interesse va ad altri campi del sapere e di modi  di relazionarsi col tutto. Campi cui la scienza ufficiale è costretta col tempo a prestare attenzione riconoscendone via via la validità e la visione certamente più completa e ad ampio respiro. 
 
Per cui ... pur ammirando l'intelligenza applicata in calcoli matematici e logaritmi, ed essendone pure per un verso affascinata, essi sono del tutto senza senso se applicati su presupposti errati o che non tengano in considerazione pure ciò che non garba o non si ritiene possibile.   
 
 
 
 
 
 
 

 ritiene possibile.
 
Non è che siano senza senso.
 
Il programma di cui si sta parlando non serve a dimostrare il 
darwinismo, ma solo a risolvere una semplice equazione.
 

 darwinismo, ma solo a risolvere una semplice equazione.
 
 
 
 
ideaprima
 
essì... lo dovevi proprio chiarire, sai? 
 
Però, l'equazione, vedo che a risolverla non sei comunque tu.
Tu ti sei affrettato a lasciarla tutta quanta a paup.
 
STOP va'! ..... finiamola qui. 
 
Un altro post chilometrico... non avessi altro da fare! 
 
 
 
 
 
 
 

 sei affrettato a lasciarla tutta quanta a paup.
 
Ma scommetto che se l'avessi risolta io sarebbe stata un'occasione in 
più da parte tua per accusarmi di voler sfoggiare erudizione.

 più da parte tua per accusarmi di voler sfoggiare erudizione.
 
 
 
ideaprima 
 
ma questa cosa non esiste, posi. 
Esiste solo e sempre il tuo ridicolo e indisponente voler far credere di saper tutto in tutti i campi... e di insistere con questo atteggiamento anche quando risulta evidente che non è così.
 
 
 
 
 

 Tu ti sei affrettato a lasciarla tutta quanta a paup.
 
Non mi sono dimenticato, sto solo riscrivendo il codice in C perche` credo sia tutto sommato piu` semplice. Questo e` il codice per i vari modi di indirizzamento:
 
inizio codice
 
#define mAXYl (unsigned char *mem, unsigned char *A, unsigned char *X, unsigned char *Y, unsigned char *l)
#define P16(X) (unsigned short *)(X)
 
unsigned char * _accum mAXYl { return A; }
unsigned char * _immed mAXYl { return l; }
unsigned char * _zerop mAXYl { return mem+*l; }
unsigned char * _zerop_x mAXYl { return mem+*l+*X; }
unsigned char * _zerop_y mAXYl { return mem+*l+*Y; }
unsigned char * _abs mAXYl { return mem+ *P16(l); }
unsigned char * _abs_x mAXYl { return mem+ *P16(l)+*X; }
unsigned char * _abs_y mAXYl { return mem+ *P16(l)+*Y; }
unsigned char * _ind mAXYl { return mem+ *P16(mem+ *P16(l)); }
unsigned char * _ind_x mAXYl { return mem+ *P16(mem+*l+*X); }
unsigned char * _ind_y mAXYl { return *Y+mem+ *P16(mem+*l); }
 
typedef unsigned char *(*funz_ind)(unsigned char *,unsigned char *,unsigned char *,unsigned char *,unsigned char *);
 
funz_ind fp[11]={&_accum,&_immed,&_zerop,&_zerop_x,&_zerop_y,&_abs,&_abs_x,&_abs_y,&_ind,&_ind_x,&_ind_y};
 
unsigned char *i=fp[0](mem,&A,&X,&Y,l);
 
fine codice
 
Qui ricavo la tabella con le operazioni del processore:
 
http://www.thealmightyguru.com/Games/Hacking/Wiki/index.php/6502_Opcodes
 
 
Pensa che da bambino, stando sulle ginocchia di mio padre, copiavo i programmi dei videogiochi da pubblicazioni direttamente in linguaggio macchina: cioe` inserendo una serie di centinaia di numeri da tastiera, senza possibilita` minima di errore! (non ho vissuto l`epoca delle schede perforate).

 che non è così.
 
Ma infatti non è per niente così, e oltretutto l'idea di avere una 
cultura enciclopedica non mi interessa affatto, non è una mia 
aspirazione. Preferisco approfondire quelli che sono i miei interessi e 
le mie competenze.
 
Sulla sintesi proteica non so e non millanto di sapere niente di più di 
quello che tutti noi abbiamo imparato alla scuola.

 fare solo supposizioni?
 
 
 
tu manco sapevi di che si trattava, pensavi fossero supposizioni mie,.... per cui ritenevi di poter sminuire tutto quanto, snobbandomi da idiota.  
Capisci, quindi, perchè io non ti reggo? 
Perchè le persone come te non le reggo ..... semplice. 
E rimgraziami che non ti dico come ti considero.
Ma comportati ancora così e sta' certo che te lo spiattello in faccia davanti a tutti. Me, da scema, non mi ci fai passare.  
 
 
 
 
 
 

 da idiota.
 
Ma quando mai ti ho snobbato?
 
Sei intervenuta su una discussione di genetica con una giusta 
osservazione riguardo il principio di causa-effetto. Ti ho considerato e 
ti ho risposto.
 
Fai spesso considerazioni interessanti che varrebbe la pena 
approfondire, ma mi trovo sempre a dover troncare le discussioni con te 
perché dopo pochi messaggi degenerano in un cumulo di insulti.
 
Se inizierò a snobbarti è solo per questo.

 Se inizierò a snobbarti è solo per questo.
 
 
 
ideaprima
 
libero di fare come ti pare ..... ed io pure, anche di non farmi far scema da te. 
 
 
 
 
 
 
 
 


-------------------------- 
 
 
 
 
nel mio post precedente ho erroneamente e non intenzionalmente fatto risultare un mio intervento diretto a posi come se l'autore dello stesso fosse uniposta invece che ideaprima, ossia la sottoscritta.
Me ne scuso e correggo l'errore.. dovuto al fatto che avevo in memoria quel nickname non mio, per inviargli un messaggio.
 
l'intervento, in quanto mio e non di uniposta, va quindi corretto così: 



 
uniposta o ideaprima, chiunque tu sia, la discussione è conservata per 
l'eternità negli archivi di google, e nel giusto ordine. Quindi chiunque 
sia interessato può andarsi a rileggerla da solo, senza bisogno che tu 
ci mostri di saper usare i comandi ctrl-c e ctrl-v.
 
C'è un solo motivo per cui io mi ritengo "superiore" a te, ma solo a te, 
e a nessun altro in questo gruppo. Perché ritengo che chi ricorre a 
termini come "stronzetto perfido" nei confronti di uno sconosciuto che 
non ha neanche mai visto in faccia e che non gli ha fatto niente di 
male, solo perché non ha altre argomentazioni a cui aggrapparsi, si pone 
automaticamente in una condizione di inferiorità.
 
E' solo una mia opinione, sia chiaro. Però la penso così. E non è una 
questione di erudizione, è una queastione di civilità. Mi trovo spesso a 
discutere con persone di livello culturale superiore al mio, o 
inferiore, senza che nessuno debba trascendere in linguaggi come il tuo.

 inferiore, senza che nessuno debba trascendere in linguaggi come il tuo.
 
 
 
ideaprima
 
ehi, bello! ... a comportarti da stronzo sei stato tu, mica io... tienilo sempre presente... e se non cambi atteggiamento continuerò a fartelo presente io. 
 
 
 
 
 
 
 

 Non mi sono dimenticato, sto solo riscrivendo il codice in C perche` credo sia tutto sommato piu` semplice.
 
Per il momento ho implementato queste funzioni:
 
inizio codice
 
unsigned char * _BCC () { if(C!=0) return l; else return l+*(signed char *)i; }
unsigned char * _BNE () { if(Z!=0) return l; else return l+*(signed char *)i;}
unsigned char * _DEC () { *i=*i-1; SZ(X); return l; }
unsigned char * _DEX () { X=X-1; SZ(X); return l; }
unsigned char * _DEY () { Y=Y-1; SZ(Y); return l; }
unsigned char * _EOR () { A=A^*i; SZ(A); return l; }
unsigned char * _INC () { *i=*i+1; SZ(*i); return l; }
unsigned char * _JMP () { return i; }
unsigned char * _JSR () { p=p-2; *P16(mem+0x100+p)=l-mem; return i; }
unsigned char * _LDA () { A=*i; return l; }
unsigned char * _LDX () { X=*i; return l; }
unsigned char * _LDY () { Y=*i; return l; }
unsigned char * _LSR () { C=*i&0x01; *i=*i>>1; SZ(*i); return l; }
unsigned char * _RTS () { p=p+2; return mem+*P16(mem+0x100+p-2); }
unsigned char * _ROR () { int t=C<<7; C=*i&0x01; *i=(*i>>1)|t; SZ(*i); return l; }
unsigned char * _STA () { *i=A; return l; }
unsigned char * _TAX () { X=A; return l; }
unsigned char * _TYA () { A=Y; return l; }
unsigned char * _NOP () { return l; }
 
fine codice
 
Ho provato a generare casualmente 100000 frammenti codice, ciascuno di 11 operazioni (corrispondente ad un valore nell`intervallo 0-255) e con una vita massima di 256 cicli (per non incorrere in blocchi). Se ad un valore non e` associata nessuna funzione, la cella in questione e` ignorata.
 
E` ritenuto valido il programma che modifica in qualche modo la zona di memoria relativa al terminale a caratteri ($400-$800).
 
Risultati positivi: 396 su 100000.
 
Questo e` il primo (lo faccio partire dalla cella $4000):
 
4000   96 9C      STX $9C,Y
4002   AF         ???
4003   93         ???
4004   CE 23 04   DEC $0423
4007   2C 81 7F   BIT $7F81
400A   FD 00 00   SBC $0000,X
400D              .END
 
fine codice
 
La linea che ha prodotto la validita` e` la $4004, dove si decrementa la cella di memoria $0423.
 
Devo dire che e` emozionante scoprire il codice autogenerato.


ahahahaha !!!!! .... sì, paup... è certamente emozionante.... sei stato bravissimo:) ..... peccato che io ci capisca niente però .... sono dispiaciuta. 
(spero che tuo padre ci sia ancora, per essere ancora orgoglioso di te..:)..) 
 
 
Ma ... potresti farla notare pure a posi questa cosa? 
 
 
 
 
 
 

 fartelo presente io.
 
Quindi io sarei stronzo ma erudito e pure bello. ;)
 
Ogni tanto ti scappa anche qualche complimento.
 


 
Devo ammettere anche io che gli algoritmi genetici hanno un loro fascino.


un commento del cavolo. 
Potresti almeno mostrare un certo apprezzamento... tutto sommato ha fatto ciò che non avevi saputo fare tu. 
 
 
 
 
 


A dire il vero ho detto che "fai" l'erudito... che è anche peggio.
Ed ho un diverso concetto di bellezza. 
 
No... non sono complimenti. 
 
 
 
 
 

 
Ho aggiunto le funzioni mancanti e le ho testate (l`emulatore passa tutte le prove tranne una, sul salto indiretto).
 
Allego il codice per far capire a grandi linee la differenza tra il codice immutabile e quello sottoposto a modifica:
 
inizio codice:
 
unsigned char mem[65536];
unsigned char A=0,X=0,Y=0,S=0,Z=0,C=0,V=0,B=0,I=0,D=0,esci=0;
unsigned char *l;
unsigned char *i;
unsigned char p=0xFF;
 
typedef unsigned char *(*funz_ind)();
typedef unsigned char *(*funz_op)();
 
// indirizzamento
 
unsigned char * _accum () { return &A; }
unsigned char * _immed () { return l; }
unsigned char * _zerop () { return mem+(*l&0xFF); }
unsigned char * _zerop_x () { return mem+((*l+X)&0xFF); }
unsigned char * _zerop_y () { return mem+((*l+Y)&0xFF); }
unsigned char * _abs () { return mem+ *P16(l); }
unsigned char * _abs_x () { return mem+ ((*P16(l)+X)&0xFFFF); }
unsigned char * _abs_y () { return mem+ ((*P16(l)+Y)&0XFFFF); }
unsigned char * _ind_x () { return mem+((*(mem+((*l+X+1)&0XFF)))<<8)+*(mem+((*l+X)&0xFF)); }
unsigned char * _ind_y () { return mem+((*(mem+*l)+(*(mem+((*l+1)&0xFF))<<8)+Y)&0xFFFF) ; }
unsigned char * _ind () { return mem+ *P16(mem+ *P16(l)); } //da verificare
 
// funzioni
 
unsigned char * _ADC () { unsigned short int r=A+*i+C; CVSZ(A,*i+C,r); A=r; return l; }
unsigned char * _AND () { A=A&*i; SZ(A); return l; }
unsigned char * _ASL () { C=(*i&0x80)!=0; *i=*i<<1; SZ(*i); return l; }
unsigned char * _BCC () { if(C==0) return l+*(signed char *)i; else return l;}
unsigned char * _BCS () { if(C==1) return l+*(signed char *)i; else return l;}
unsigned char * _BEQ () { if(Z==1) return l+*(signed char *)i; else return l; }
unsigned char * _BIT () { unsigned char r=A&*i; Z=(r==0); S=(*i&0x80)!=0; V=(*i&0x40)!=0; return l; }
unsigned char * _BMI () { if(S==1) return l+*(signed char *)i; else return l; }
unsigned char * _BNE () { if(Z==0) return l+*(signed char *)i; else return l; }
unsigned char * _BPL () { if(S==0) return l+*(signed char *)i; else return l; }
unsigned char * _BRK () { esci=1; return l; }
unsigned char * _BVC () { if(V==0) return l+*(signed char *)i; else return l; }
unsigned char * _BVS () { if(V==1) return l+*(signed char *)i; else return l; }
unsigned char * _CLC () { C=0; return l;}
unsigned char * _CLD () { D=0; return l;}
unsigned char * _CLV () { V=0; return l;}
unsigned char * _CMP () { char r=A-*i; SZ(r); C=(A>=*i); return l;}
unsigned char * _CPX () { char r=X-*i; SZ(r); C=(X>=*i); return l;}
unsigned char * _CPY () { char r=Y-*i; SZ(r); C=(Y>=*i); return l;}
unsigned char * _DEC () { *i=*i-1; SZ(*i); return l; }
unsigned char * _DEX () { X=X-1; SZ(X); return l; }
unsigned char * _DEY () { Y=Y-1; SZ(Y); return l; }
unsigned char * _EOR () { A=A^*i; SZ(A); return l; }
unsigned char * _INC () { *i=*i+1; SZ(*i); return l; }
unsigned char * _INX () { X=X+1; SZ(X); return l; }
unsigned char * _INY () { Y=Y+1; SZ(Y); return l; }
unsigned char * _JMP () { return i; }
unsigned char * _JSR () { p=p-2; *P16(mem+CIMA)=l-mem-1; return i; }
unsigned char * _LDA () { A=*i; SZ(A); return l; }
unsigned char * _LDX () { X=*i; SZ(X); return l; }
unsigned char * _LDY () { Y=*i; SZ(Y); return l; }
unsigned char * _LSR () { C=*i&0x01; *i=*i>>1; SZ(*i); return l; }
unsigned char * _ORA () { A=A|*i; SZ(A); return l; }
unsigned char * _PHA () { p=p-1; *(mem+CIMA)=A; return l; }
unsigned char * _PHP () { p=p-1; *(mem+CIMA)=S<<7|V<<6|1<<5|1<<4|D<<3|I<<2|Z<<1|C; return l; }
unsigned char * _PLA () { A=*(mem+CIMA); p=p+1; SZ(A); return l; }
unsigned char * _PLP () { unsigned char r=*(mem+CIMA); S=(r&0X80)!=0; V=(r&0x40)!=0; D=(r&0x8)!=0; I=(r&0x4)!=0; Z=(r&0x2)!=0; C=(r&0x1)!=0; p=p+1; return l; }
unsigned char * _RTI () { unsigned char r=*(mem+CIMA); S=(r&0X80)!=0; V=(r&0X40)!=0; D=(r&0x8)!=0; I=(r&0x4)!=0; Z=(r&0x2)!=0; C=(r&0x1)!=0; p=p+1; p=p+2; return mem+*P16(mem+CIMA-2); }
unsigned char * _RTS () { p=p+2; return mem+1+*P16(mem+CIMA-2); }
unsigned char * _ROL () { int t=C; C=(*i&0x80)!=0; *i=(*i<<1)|t; SZ(*i); return l; }
unsigned char * _ROR () { int t=C<<7; C=*i&0x01; *i=(*i>>1)|t; SZ(*i); return l; }
unsigned char * _SBC () { unsigned short int r=A+(255-*i)+C; CVSZ(A+C,(255-*i),r); C=C; A=r; return l; }
unsigned char * _SEC () { C=1; return l; }
unsigned char * _SEI () { return l; } // da definire INTERRZ
unsigned char * _SED () { D=1; return l; }
unsigned char * _STA () { *i=A; return l; }
unsigned char * _STX () { *i=X; return l; }
unsigned char * _STY () { *i=Y; return l; }
unsigned char * _TAX () { X=A; SZ(A); return l; }
unsigned char * _TSX () { X=p; SZ(X); return l; }
unsigned char * _TXA () { A=X; SZ(A); return l; }
unsigned char * _TXS () { p=X; return l; }
unsigned char * _TAY () { Y=A; SZ(A); return l; }
unsigned char * _TYA () { A=Y; SZ(A); return l; }
unsigned char * _NOP () { return l; }
unsigned char * _UNK () { esci=1; return l; }
 
fine codice
 
Questo sopra e` immutabile, quello modificato e` di 10 caratteri.
 
Su 100000 frammenti di codice, quelli validi secondo il criterio stabilito sono circa 50 (sono diminuiti dall`esperimento precedente perche` prima avevo dimenticato di cancellare la memoria ogni volta che facevo partire i codici casuali e perche` sono aumentate le funzioni che bloccano l`esecuzione).


---------------------------------------------- 
 
 
 
 
        :)
 
 
bravissimo, paup!
 
 
 
 
 

 Questo sopra e` immutabile...
 
Per non parlare del processore, che qui vediamo simulato:
 
http://www.visual6502.org/JSSim/index.html
 
 
 
(premere n per avanzare di una istruzione ed evidenziare le zone che si attivano).
 
Tutta questi circuiti sono logica cablata immutabilmente.

 Devo dire che e` emozionante scoprire il codice autogenerato.
 
Ho provato a scrivere un programma minimale (usando solo poche funzioni logiche di base) che faccia qualcosa di /interessante/.
 
Il meglio che sono riuscito a fare e ` questo (allego solo il ciclo principale):
 
l1:
	xor al,al
	mov si,di
	sub si,0x141
	mov bx,0x3
l2:
	add al,[es:si]
	add al,[es:si+0x1]
	add al,[es:si+0x2]
	add si,0x140
	dec bx
	jnz l2
	cmp al,0x5
	mov al,0x0
	cmc
	rcl al,1
	mov [ds:di],al
	shl cx,1
	jnc @f
	xor cx,0x1d1d
@@:
	mov al,cl
	and al,0x1
	jz @f
	xor al,[ds:di]
	mov [ds:di],al
@@:
	inc di
	jnz l1
	push ds
	push es
	pop ds
	pop es
 
	jnz l1
 
fine codice
 
La lunghezza e` circa di 100 caratteri (considerando che quello sopra e` codice espanso per una piu` facile lettura)
 
Qui potete trovare programmi piu` corti (massimo 32 ottetti):
 
http://www.pouet.net/prodlist.php?type%5B0%5D=32b&platform%5B0%5D=MS-Dos&page=1&order=thumbup
 
 
Il mio codice produce l`effetto visivo di due fluidi immiscibili che si contendono uno spazio, tenuti separati da una tensione superficiale ben evidenziata.
 
(dopo invio l`animazione risultante: spero sia all`altezza della descrizione)
 
Questo per dire che molto difficilmente un codice ristretto, se modificato casualmente, puo` produrre un risultato paragonabile all`originale, o comunque un qualche effetto /interessante/.

Questo per dire che molto difficilmente un codice ristretto, se modificato casualmente, puo` produrre un risultato paragonabile all`originale, o comunque un qualche effetto /interessante/.
 
Ad esempio nel mio programmino i parametri modificabili senza problemi potrebbero essere tre: il valore iniziale di cx, il valore "1d1dh" nel generatore di numeri p.c., ed eventualmente lo spiazzamento durante la ricopiatura tra le due pagine di memoria (giocando con quest`ultimo valore, si possono avere effetti totalmente differenti).
 
Per correttezza aggiungo che il codice l`ho simulato in c, perche` in DOS non mi funziona correttamente.

 	mov [ds:di],al
 
 
l1:
	mov si,di
	sub si,0x141
	mov bx,0x3
	mov bx,ax
l2:
...
...
	jnz l2
 
	shl al,3
	mov [ds:di],al
 
 
Con questa modifica si ottiene lo stesso risultato con meno istruzioni, pero` ci ho dovuto pensare ;-)

 Con questa modifica si ottiene lo stesso risultato con meno istruzioni, pero` ci ho dovuto pensare ;-)
 
correggi:
 
mov bx,ax -> mov ax,bx
...
shl al,3 -> shr al,3
 
QUesto e` il programma completo e funzionante, sono riuscito a farlo stare in meno di 100 ottetti:
 
inizio codice macchina x86 DOS 16 bit:
 
b0 13 cd 10 fd 68 00 50 07 68 00 60 1f 68 00 a0
5d 89 fe bb 03 00 88 d8 81 ee 41 01 26 02 04 26
02 44 01 26 02 44 02 81 c6 40 01 4b 75 ee c0 e8
04 0f 92 05 d1 e1 73 04 81 f1 1d 1d 88 c8 24 01
74 05 26 32 05 88 05 47 75 c7 1e 06 55 07 ad ab
85 ff 75 fa 1f 07 e4 60 3c 01 75 b5 b8 03 00 cd
10 c3
 
fine codice macchina
 
codice "umano":
 
00000100  B013              mov al,0x13
00000102  CD10              int 0x10
00000104  FD                std
00000105  680050            push word 0x5000
00000108  07                pop es
00000109  680060            push word 0x6000
0000010C  1F                pop ds
0000010D  6800A0            push word 0xa000
00000110  5D                pop bp
00000111  89FE              mov si,di
00000113  BB0300            mov bx,0x3
00000116  88D8              mov al,bl
00000118  81EE4101          sub si,0x141
0000011C  260204            add al,[es:si]
0000011F  26024401          add al,[es:si+0x1]
00000123  26024402          add al,[es:si+0x2]
00000127  81C64001          add si,0x140
0000012B  4B                dec bx
0000012C  75EE              jnz 0x11c
0000012E  C0E804            shr al,byte 0x4
00000131  0F9205            setc [di]
00000134  D1E1              shl cx,1
00000136  7304              jnc 0x13c
00000138  81F11D1D          xor cx,0x1d1d
0000013C  88C8              mov al,cl
0000013E  2401              and al,0x1
00000140  7405              jz 0x147
00000142  263205            xor al,[es:di]
00000145  8805              mov [di],al
00000147  47                inc di
00000148  75C7              jnz 0x111
0000014A  1E                push ds
0000014B  06                push es
0000014C  55                push bp
0000014D  07                pop es
0000014E  AD                lodsw
0000014F  AB                stosw
00000150  85FF              test di,di
00000152  75FA              jnz 0x14e
00000154  1F                pop ds
00000155  07                pop es
00000156  E460              in al,0x60
00000158  3C01              cmp al,0x1
0000015A  75B5              jnz 0x111
0000015C  B80300            mov ax,0x3
0000015F  CD10              int 0x10
00000161  C3                ret
 
 
Mi piacerebbe capire se e` possibile trasformare il mio algoritmo procedurale e ricorsivo in una formula.


 
... ma così non vale ;)
 
Lascia che sia la tua popolazione di programmi a tirar fuori da sola, 
evolvendosi, qualcosa di interessante.
 
Però devi prima definire meglio il concetto di "interessante" in modo da 
poterli valutare in maniera automatica.
 


Appunto per questo ho indicato "interessante" in corsivo: cos`e` una procedura-algoritmo /interessante/?
 
Non saprei definirlo a priori, ma solo vedendone il risultato: in questo senso credo che l`'interessanza' sia un concetto simile all`idea platonica.
 
Un algoritmo che riconoscesse genericamente cos`e` interessante da cosa non lo e` (anche a posteriori), sarebbe l`ideale per il nostro progetto informatico di evoluzione guidata di frammenti di codice.
 
allego il codice in C del ciclo principale dell`animazione precedente, magari si capisce meglio cosa fa:
 
  do
  {
  si=di;
 
  bx=3;
  al=bx;
  si-=321;  
 
	while (bx)
	{
		al+=*(es+si);
		al+=*(es+si+1);
		al+=*(es+si+2);
		si+=320;
		bx--;
	}
 
	al=al>>3;
	*(ds+di)=al;
 
	c=(cx&0x8000)!=0;
	cx=cx<<1;
 
	if (c)
		cx=cx^0x1d1d;
 
	c=(cx&0x01);
 
	if (c)
	{
		al=1-*(es+di);
		*(ds+di)=al;
		}
 
	}  while(++di);
 
fine codice
Spiegazione: abbiamo due matrici toroidali puntate da ds e es, con indice (lineare) di e si.
 
Alternativamente per ogni matrice (A e B), si sommano i valori di tutte le celle raggruppandole in quadrati di 9 celle (q_i), valori che possono essere 1 (acceso) o 0 (spento): se la somma e` maggiore di 4, nell`altra matrice si pone la cella centrale del quadrato corrispondente a 1 (chiamiamola B_qi_c5; per capire l`indice 5, immaginate un tastierino telefonico).
 
A questo punto si estrae un valore pseudocasuale (cx): se e` dispari non succede niente, se e` pari si sostituisce al valore precedentemente calcolato B_qi_c5, il negativo di A_qi_c5.
 
 
Il risultato dipende valore iniziale di cx (seme); un altro esempio interessante e` con cx = 6: 
 
https://s14.postimg.org/m7pp84nzl/fluidi6.gif
 (due nuclei di aggregazione)
 
Mi piacerebbe scoprire se e` possibile guidare la formazione delle figure (credo che dipenda da una specie di risonanza, visto che i numeri estratti sono pseudocasuali).