lunedì, agosto 18, 2008

Diamo forma ai libri..!

Alla fine le poesie sono fatte per essere scritte.. e lette! Quindi eccovi la mia prima pubblicazione poetica ufficiale:

Deliranti sentieri...
...in versi sparsi.


Giusto per dare forma ai pensieri.. tipo forma di "parallelepipedo sfogliabile"! ;)

giovedì, agosto 07, 2008

Mutevole erotismo

Mutevole erotismo


Fantasia fervida,
ricerca di novità,
il docle piacere
d'un sogno proibito;
di tabù superati
è plasmata l'unione.

Fine delle idee,
nullo desiderio
d'arti spericolate;
sensibile profondo,
gustato a pieno,
l'amore passionale.

La sottomissione
all'amante deciso,
la prevaricazione
d'uno schiavo dolce,
scontro d'intensi sguardi:
si miscelan' i sensi.

Riscoprendoci dentro,
sbizzarrendoci fuori,
usando corpi nudi,
assaporando ogni
sfumatura d'anime,
siamo sempre più "NOI"!


Gabriele Lombardi

mercoledì, luglio 02, 2008

Sgretolandoti

Sgretolandoti


Mente d'instabile,
veloce deriva
d'una dolce pensatrice:
s'aggrovellano idee,
paure, proiezioni
d'un mondo che mai
fu meno reale.


Gabriele Lombardi

Fresche e lucenti... nell'oscurità

Fresche e lucenti... nell'oscurità


Perle trasparenti brillano:
da tiepidi raggi trafitte,
rotolano inermi lungo stami,
abbandonano i giovani germogli
per lanciarsi nell'abisso
ove non faranno ritorno.


Gabriele Lombardi

giovedì, maggio 15, 2008

Stagioni diverse

Stagioni diverse


Rotean ingranaggi
d'esseri mutevoli,
splendore rugginoso;
alternarsi frivoli
osservo personaggi.

Essendo incapaci
d'introspetta puntura,
dolore fastidioso
alimenta paura,
vegetano felici.

Rarament'intendendo,
ponendomi quesiti
vi osservo dubbioso:
contorto è l'animo,
lo sto somatizzando.

Gli umani son siti
d'intricati terrori:
chi diviene furioso,
chi rovina d'amori,
chi lavor'appassiti.

Io m'osservo: perdente
comprendo di non poter,
nell'animo fumoso,
duro nocciolo scorger:
sconfitta è sovente.


Gabriele Lombardi

mercoledì, maggio 14, 2008

Sambuco in fiore

Ragazzi, in questo periodo la natura si è svegliata e sembra impazzita. La camomilla romana ed i papaveri invadono i campi e le piante di sambuco riempiono l'aria di un profumo dolciastro. Maaa.. lo sapevate che:
  1. Il sambuco è una pianta commestibile, non tossica, i cui fiori hanno mille usi.
  2. In questo periodo i fiori aperti (e belli profumati) possono essere fritti in pastella (come i fiori di zucca) e comodamente mangiati utilizzando il picciolo del fiore come "manico".
  3. Per produrre un buon liquore al sambuco (non identico alla classica sambuca) è sufficiente raccogliere i fiori, separare i singoli fiorellini dal picciolo "sgrullando" il fiore su un giornale e tenerli in "infusione" per 40 giorni in alcool puro (in maniera tale che i fiori riempiano completamente il barattolo in cui sono posti); dopo questo periodo è sufficiente per ogni litro di alcool aromatizzato versare in una pentola un litro di acqua e 700g di zuccero e portare ad ebollizione (facendo sciogliere completamente lo zucchero con un cucchiaio), infine miscelare bene i due liquidi e lasciar raffreddare. La raccolta e separazione dei fiori dai piccioli è un'operazione velocissima (le piante di sambuco si trovano ovunque ed i fiori maturi si staccano subito), purtroppo bisogna aspettare 40 giorni (agitando di tanti in tanto il barattolo), però la preparazione finale del liquore con acqua e zucchero è un lavoro da 10 minuti!!!
  4. Sambuco è anche un comune di 84 abitanti in provincia di Cuneo ;)
  5. Il suo nome deriva dal greco, "sambuchè", una specie di flauto costruito rimuovendo il modollo morbido dai rami più grossi.
  6. E' una pianta emolliente e sudorifera, i fiori sono diaforetici, i frutti sono lassativi e la corteccia è diuretica. (ne ha una per ogni esigenza ;) Inoltre i fiori possono essere usati contro l'influenza tramite infusi e come astringenti per la pelle se se ne utilizza il decotto.
Tutto qui? No no: gli usi del sambuco sono 1000 e 1000.. ma non vi voglio togliere il piacere della scoperta, Google is your friend ;)

martedì, aprile 15, 2008

Notte perpetua

Belli guaglioni, eccovi un bel racconto da leggere d'un fiato e da commentare. Se fa schifo.. ditemelo pure, sono qui apposta per ricevere commenti di qualunque genere. Sicuramente non è un racconto "nella media". Ditemi che ne pensate, a presto.
Notte perpetua

mercoledì, marzo 26, 2008

OOP in VimScript

Vim è uno dei (due) editor di testo più potenti che esistano, e come il suo concorrente (Emacs) può essere programmato in (almeno) un linguaggio di scripting apposito: il VimScript (in Emacs si usa l'elisp). Il VimScript è un linguaggio molto potente, articolato, con strutture dati flessibili (simili alle strututre dati di Python), tra le quali i dizioniari. I dizioniari, utilizzati in maniera particolare, consentono la costruzione di funzioni in cui sia possibile accedere al loro contentuo, una sorta di self pointer. Buttiamo lì un'identità di cui discuterò con voi volentieri:
strutture+function_handler+self=object orientation
Vediamo come questa cosa possa essere vera in VimScript: per prima cosa vi esorto a scaricare questo archivio con all'interno del codice VimScript, fra cui quello che ho scritto per l'OOP. In secundis aprite ed osservate il file "OO.vim" presente nella cartella "VimPresentation\Automation\Scripting". In esso:
  • BaseClass: salva in una variabile globale la classe corrente, costruita come dizionario con l'entry speciale "__name" contenente i nomi delle classi da cui l'oggetto eredita (per ora solo la corrente) e l'array (ora vuoto) delle interfacce implementate. Successivamente lo restituisce.
  • Interface: nefinisce una struttura simile a quella di una classe ma senza array delle interfacce.
  • Hinerit: l'ereditatrietà è gestita all'interno del costruttore chiamando questa funzione, qui viene creata l'istanza della superclasse, viene poi aggiunto ai nomi delle classi da cui si eredita il nome della sottoclasse, sarà poi compito del costruttore terminare la propria opera aggingendo nuovi attributi e svolgendo altri compiti di inizializzazione.
  • Virtual: i metodi virtuali non sono altro che metodi che vengono (nella sottoclasse, non nella superclasse come in C++) salvati all'interno della strututra d'istanza sotto nuovo nome tipo "superclasse_metodo" e che quindi vengono sostituiti nella sottoclasse.
  • PureVirtual: un metodo virtuale puro invece è un metodo che non è ancora stato implementato, se ne genera quindi una versione dummy ( che genera solo un'eccezione) e si utilizza la stessa tecnica dei metodi virtuali.
  • Implements: l'implementazione delle interfacce significa due cose:
    1. l'interfaccia (il suo nome) deve figurare tra le interfacce implementate,
    2. tutti i metodi virtuali puri presenti nell'interfaccia devono essere in quelche modo "importati" all'interno della classe corrente (starà poi al programmatore implementarli).
  • Isa: usando i nomi da dizionario si può sapere se una istanza è (da qualche parte nell'albero d'ereditarietà) istanza di una determinata classe.
  • IsImplemented: in modo analogo si può controllare se un istanza implementa una determinata interfaccia.
  • Import: un po' di comodità non guasta! ;)
Detto questo, sperando che abbiate contemporaneamente visionato il (semplicissimo) codice in VimScript che definisce queste funzioni, vediamo come utilizzarle per definire una classe, il classico contatore. Riporto e commento il file "Counter.vim":
let s:_default = 42
All'interno di uno script le variabili nello scope s: sono locali allo script stesso, per una classe questo significa avere a disposizione uno strumento per gli attributi statici.
function! Counter(...)
...
endfunction
Al solito definiamo una classe come funzione con funzioni innestate, la funzione di suo farà da costruttore. In fondo si può trovare il codice:
function! Counter_compare(a,b)
" Contronto actual:
return a:a._actual>a:b._actual
endfunction
che definisce una funzione friend. Il costruttore svolge le seguenti azioni:
if a:0<1
let initial = s:_default
else
let initial = a:1
end
let counter = BaseClass('Counter') | Implements ICounter
call extend(counter,{'_actual': initial})
che rappresentano:
  1. inizializzazione dell'attributo "initial" come variabile (per ora) locale,
  2. creazione dell'istanza con implementazione dell'interfaccia ICounter,
  3. agginta dell'attributo privato "initial".
Vedremo dopo come è stata definita l'interfaccia, ovviamente la sintassi deriva dal fatto che è stato creato un comando apposito per la definizione delle interfacce implementate, che richiama la funzione omonima.
A questo punto vengono aggiunti i metodi (eventualmente dichiarati virtuali se devono sovrascrivere i metodi di una superclasse o di un'interfaccia):
Virtual actual
function! counter.actual() dict
return self._actual
endfunction
E la classe è pronta! ;) Si osservi che i metodi vengono dichiarati con la speciale sintassi:
funciton! struttura.nome(...) dict
...
endfunction
dove la parola chiave "dict" assicura che all'interno del metodo si possa fare riferimento al dizionario "counter" con la parola chiave self. Si noti anche che il nome della funzione inizia con il nome dell'istanza che si sta costruento e che verrà restituita al termine del costruttore, infatti si sta semplicemente dichiarando un funciotn_handler di nome (in questo esempio) "actual" all'interno del dizionario "counter" richiedendo di generare il riferimento locale "self" con la parola chiave "dict".
Nel file "StepCounter.vim" si può osservare che l'ereditarietà è ottenuta semplicemente sostituendo la chiamata a "BaseClass" con la chiamata a "Hinerit" passando anche il nome della superclasse e la lista degli argomenti.
Con la definizione dei comandi si è resa semplicissima la dichiarazione delle interfacce:
fun! ICounter()
let counter = Interface('ICounter')
Abstract actual next prev set
return counter
endfun

Infatti:
  1. Si crea l'interfaccia in una fuzione "costruttore",
  2. si crea "l'istanza" con "Interface",
  3. si creano i metodi virtuali puri col comando "Abstract",
  4. si restituisce l'interfaccia.

OO in Matlab: Single inheritance

Belli guaglioni, ricordate questo post rtelativo alla programmazione OO in Matlab? Bè ogni tanto per sfizio mi diletto a giocherellare con la metaprogrammazione e ho da proporvi un paio di chicche, una (banale) in matlab e una più interessante in VimScript (prossimo post).
Iniziamo pensare alla tecnica proposta per programmare OO in Matlab, abbiamo compreso come ottenere molte features, non abbiamo ottenuto però l'ereditarietà. Per aggiungere l'ereditarietà vogliamo tenere d'occhio i seguenti aspetti:
  • Overriding: vogliamo poter "sovrascrivere" i metodi della superclasse con le nostre nuove versioni senza perdere però la possibilità di accedere esplicitamente alle versioni della superclasse.
  • Accessors: non abbiamo descritto in maniera molto dettagliata come poter realizzare dei metodi accessori al meglio della comodità d'utilizzo, l'idea è quella di ottenere una sorta di property come in C#, per intenderci.
  • Protected access: nell'antico post sulla OOP in Matlab abbiamo descritto in maniera precisa come ottenere accesso pubblico e privato ai metodi, come costruire funzioni private accessorie non legate agli oggetti, come memorizzare gli attributi come privati ma non come pubblici (cosa che non faremo, usando invece i metodi accessori). Resta però da efinire come ottenere un livello protetto di accesso ai metodi o attributi. Si cominci a considerare il fatto che se si ottiene l'accesso protetto ai metodi si può sfruttare quello per avere accesso protetto verso gli attributi semplicemente con degli accessori protetti. Per ora però purtroppo non siamo in grado di creare metodi ad accesso protetto, quindi ci limitiamo ad utilizzare la tecnica delle property.
Dopo tutta sta pizza passiamo al codice: vogliamo creare la classe stepCouter sottoclasse di counter, in essa dovremo sfruttare il valore attuale del contatore per poterlo leggere, modificare e reimpostare; per questo motivo creiamo il seguente metodo accessorio nel contatore:
% The actual value accessor:
function ao = Actual(ai)
% Getting the actual value:
if nargin>0; start=ai; end

% Setting the output:
if nargout>0; ao=start; end
end
Collegheremo questo metodo all'oggetto salvando il function_handler con il nome "actual" all'interno dell'istanza restituita:
% Returning the counter: this is the public methods' set exported.
c = struct('next',@Next,'prev',@Prev, ...
'reset',@Reset,'actual',@Actual);
Fatto questo abbiamo la possibilità, nella sottoclasse, di istanziare il contatore e aggiungervi dei metodi che, sfruttando la property 'actual', possano modificare anche l'istanza della superclasse.
Si noti che la superclasse e la sottoclasse avranno collegati a sé due workspace differenti con all'interno i loro rispettivi attributi privati; questo significa che con questa tecnica comunque ogni classe genera istanza che hanno il proprio workspace separato da tutti gli altri, senza possibilità di interferenze. Ecco il codice:

function c = stepCounter(start,step)
% STEPCOUNTER Generates a new counter that uses a step.
%
% Here the single hineritance is obtained by generating an object of the
% superclass and then joining the method calls, notice that the mantained
% workspaces are distinguished so there are difficulties in the private
% attributes access (there is no protected access, only public or private);
% so an accessor in the class "counter" must be added (in this case
% "actual"), this allows to have the actual attribute to be public.

% =========================================================================
% Creating the object:
% =========================================================================

% Using the superclass' constructor:
c = counter(start);
clear start;

% Adding local methods:
c.step = @Step;
% Saving the old method so that can be explicitly called if required:
c.counter.next = c.next;
c.next = @Next;
% Same for the prev:
c.counter.prev = c.prev;
c.prev = @Prev;

% =========================================================================
% The public methods body.
% =========================================================================
% The next integer function:
function n = Next
% Increment:
n = c.actual(c.actual() + step);
end
% The prev integer function:
function n = Prev
% Decrement:
n = c.actual(c.actual() - step);
end
% Setting and getting the step value:
function so = Step(si)
% Getting the actual value:
if nargin>0; step=si; end

% Setting the output:
if nargout>0; so=step; end
end
% =========================================================================
% Private methods are simple functions and can be defined here.
% =========================================================================
end

% =========================================================================
% Support functions that are not methods (no access to attributes) are
% defined here.
% =========================================================================
Quindi in questa sottoclasse "step" è un attributo locale privato, ed è l'unico presente nel workspace della sottoclase "stepCounter", il parametro "start" del costruttore viene rimosso una volta utilizzato perché dopo la chiamata al costruttore della superclasse non serve più (è stato memorizzato nel workspace della superclasse) e se non eliminato rimarrebbe nel workspace privato della sottoclasse "stepCounter" occupando spazio inutile e potenzialmente dando la possibilità di scrivere codice errato e confuso. Per "step" si è creata una property, i metodi "next" e "prev" sono stati sostituiti e le vecchie versioni sono state salvate nella struttura stessa in una sottostruttura con il nome della superclasse. Ora è possibile scrivere codice come il seguente:
c1 = counter(10);
c2 = stepCounter(10,10);
c1.next()
c2.next() % Uso la versione "overridata":
s=c2.step %ottengo lo step:
c2.step(20); % Imposto lo step:
c2.counter.next(); % Uso la versione originale:

mercoledì, febbraio 13, 2008

Commenti in C++

I linguaggi C/C++/Java/ecc (anche se non nello standard C99) prevedono l'utilizzo di due diversi tipi commenti:

// Commento su una riga (one-line comment)
/*
Commento di un intervallo di testo (range comment)
*/

Inoltre non prevedono comment nesting (annidamento dei commenti), quindi suddividono l'input in token "//", "/*" e "*/" dipendentemente dal contesto (di commento). Questo unito all'utilizzo del carattere "/" condiviso tra i due tipi di commento permette di "giocare" per ottenere risultati interessanti e utili.. quando si dice giocare con poco per ottenere molto! ;)

Date un occhio a questi esempi e se vi va lasciatemi un commento (al blog, non in C++ ;)

martedì, gennaio 29, 2008

Buio illuminante

Buio illuminante


Luce diffusa, radente, coglie
ogne anfratto dell’anima pia,
occultando le ombre minacciose.
In agguato pazientano tenebre,
liberatrici di spettri antichi,
nulla può impedirne il ritorno.

Miope dell’antica identità,
non comprendo il profondo dolore;
erroneamente intendo segni
mostratimi con gesti inattesi.
Nel buio profondo ora brancolo
fiutando intesa per dar appoggio.

Giornate luminose rendon ciechi,
sovente di più svela oscurità,
chiarore perpetuo, s’apprezza poco.
Nell’ombra, un sol raggio di speranza
pare illuminar l’intera vita,
vien ben percepito con ogne senso.

Dovrebbe serenità
pervadere le menti
d’accecati dispersi:
vedranno più di prima.

Non capendo,
percepisco.


Gabriele Lombardi

venerdì, novembre 23, 2007

Goccia

Goccia


Goccia mi s'è posata
d'improvviso sul volto:
pioggia lieve, trasporta;
saran d'uno stolto,
ma l'antichi riporta
mente d'era passata.

Frenetico appare
seguirsi d'adulteri
giorni non penetranti:
son gl'intensi valori,
e non i fuorvianti,
cui voglio l'sapore!

Aspirandot'appieno
gusto l'vero valore
ch'amalgama serena
coscienza d'amore;
sublima l'anatema,
errar pare ameno.

Son gli alti e bassi
che compongono succo
di esistenza, piatto
appare il rintocco
d'esistere coatto:
sovente siam percossi!

Usma essenza densa
di quanto già possiedi;
aspira la fragranza
di antichi rimedi
qual vera sostanza:
palpito non pensa.


Gabriele Lombardi

sabato, novembre 03, 2007

Bella

Bella


Come un sorriso solare
che sorge al mattino
e non tramonta mai,
come un angelo sognatore
che dispiega le ali
in un leggero volo libero,
come un delicato fiore
apre i petali vellutati
sfiorato dalla rugiada,
come una dolce amante
trasmette inconsapevole
un amore profondo e intenso;

così tu sai rendermi felice,
così tu sai carezzarmi,
così tu sai essere la mia donna,
così tu sai appagarmi,
così tu sai sorridermi,
così tu sai capirmi,
così tu mi vuoi e ti dai,
così tu mi intrighi,
così tu diventi il mio centro,
così tu.. e nessun'altra..
nel mio profondo t'inerpichi
drogandomi d'amore vero.

Mia bella,
ora ti sento mia
e non posso più pensare
a una vita vissuta senza di te.


Gabriele Lombardi

mercoledì, ottobre 31, 2007

Diamo un occhio ai saponi fatti in casa

Eccovi un piccolo album fotografico dei saponi auto-prodotti:

Saponi

lunedì, ottobre 15, 2007

Saponi saponi e ancora saponi!


Ragazzi.. come mi capita ogni tanto (anzi ogni spesso!) mi salta per la testa qualcosa e parto per la tangente! A sto giro sono partito per la tangente dei saponi e mi son messo a fabbricarne in casa! Se date un occhio al sito ilmiosapone troverete una marea di consigli, strumenti e ricette pronte per essere sperimentate.. considerate fra l'altro che se utilizzate il metodo a freddo potete utilizzare degli strumenti dedicati per il sapone per una spesa complessiva di circa 20€, senza devastare per forza una pentola di casa (che poi familiari vari tipo mogli, mariti o genitori vengono a bussare alla mia porta incazzati neri!!!).

Siccome sul sito del link c'è già scritto tutto.. non vorrei ripetere le stesse informazioni.. a parte il fatto che la soda caustica in drogheria si trova con estrema facilità e costa pure poco (tipo 5€ un kg con cui potete fare circa 8 kg di sapone.. che mi sembrano abbastanza ;).. e che dovete assolutament elavorare con finestre spalancate.. meglio se direttamente in balcone o comunque all'aperto e con tutte le protezioni e precauzioni del caso perché la soda caustica non scherza!!!

A parte tutto questo.. voglio darvi una ricettucola che mi sono inventato io e che mi sembra essere venuta una figata esagerata! Non l'ho trovata da nessuna parte.. quindi è pubblicata qui in esclusiva per voi (oooh ;). ECCOLA!


Sapone orientale rinfrescante

Questa ricetta sembra molto complicata ma in realtà ha l'enorme vantaggio di non contenere ingredienti comlicati da cercare.. molti si possono trovare in qualunque erboristeria (olii essenziali, foglie di eucalipto, olio di mandorle dolci), altri al supermercato (tutti gli altri olii, il miele e la farina di cocco). Considerate che potete tranquillamente sostituire degli ingredienti.. se avete già in casa il miele e non è all'eucalipto va bene comunque (ovviamente meglio usare quello di eucalipto), se non avete la farina di cocco ma quella normale.. ok comunque!

Pesate i grassi nelle seguenti quantità:
100g olio di mandorle dolci
100g olio di soia
50g olio di ricino
400g olio di riso
350g olio di oliva (meglio extravergine)

Procuratevi anche:
5ml olio essenziale alle mandorle (circa 50 gocce)
5ml olio essenziale all'eucalipto (circa 50 gocce)
q.b. farina di cocco (un cucchiaio va bene)
q.b. miele all'eucalipto (un cucchiaio va bene)
20g foglie secche di eucalipto (frullatele per farne una polverina fine ma non troppo)

Per la soluzione caustica servono:
125g soda caustica
300cl acqua con amido di riso procurato come segue:


Facendovi un bel riso (meglio se in bianco).. che potrete mangiarvi aggiungendo zafferano o funghi trifolati.. come vi pare.. ma durante la cottura.. tenete l'acqua non troppo abbondante ma nemmeno troppo scarsa e di tanto in tanto con un mestolo recuperate l'amido.. che non sia troppo pastoso.. deve rimanere abbastanza liquido.. dovete raccoglierne 300cl in una brocca graduata. Fatelo raffreddare.

Indossate vestiti vecchi e mettetevi le protezioni (guanti di gomma, maschera anti gas (anche semplice), occhiali da saldatore).. pesate la soda caustica con precisione (al grammo.. non all'atomo!) e unitela lentamente con l'amido all'interno di uno stampo alto per torte abbastanza capiente da contenere almeno 2l d'acqua.. e che userete solo per il sapone. Non versate MAI l'acqua nella soda.. sempre il contrario e sempre lentamente mescolando con un cucchiaio che userete SOLO per fare il sapone. Mescolate bene fino a far sciogliere la soda.. state attenti ad essere in un posto all'aperto senza cose, persone o animali in giro perché la soluzione caustica è pericolosa (raggiungerà circa gli 80 gradi solo per la reazione chimica)!

Mentre la soda rafredda e raggruma l'amido (ogni tanto andate a dargli una girata altrimenti viene fuori la ricotta sopra e tutto liquido sotto), cominciate a scaldare su un fornello i grassi, a fuoco molto lento, ogni tanto ficcateci dentro un dito per controllare la temperatura.. devono essere 45 gradi, se avete un termometro meglio, altrimenti controllate che sia appena tiepido, 45 gradi sono poco più della temperatura corporea (37).. la temperatura è molto importante.. quindi se riuscite a procurarvi 2 termometri è molto meglio!

Quando la soda si è raffreddata fino a 45 gradi e l'olio è arrivato a 45 gradi.. uniteli (meglio la soda nell'olio.. però io di solito faccio il contrario per non rovinare una pentola da cucina!), mescolate bene con un cucchiaio, poi passate al frullatore a immersione (dovreste dedicare un frullatore intero al solo sapone.. se non volete farlo dato il costo della cosa potete prendere un frustino da dolci al costo di 3 euri e frullare a mano come facevano gli antichi con i rametti per fare il fuoco.. io faccio così.. è faticoso ma funziona e non devo spendere 70€ per un frullatore ad immersione). Smettete di frullare solamente quando raggiungete il nastro, ovvero quando il tutto è abbastanza cremoso da lasciare una piccola scia per un istante quando togliete il frullatore.

A questo punto il sapone è pronto.. non resta che profumarlo e arricchirlo: tirate via metà del composto versandolo attentamente in un altro stampo, lo userete dopo. Aggiungete al rimanente il miele, la farina di cocco e l'olio essenziale alle mandorle. Continuate a mescolare a mano un po' (tipo un paio di minuti) e date anche una leggera frullatina, dovrebbe diventare ancora più cremoso. Fatto questo mettete da parte lo stampo principale e prendete il secondario con il composto avanzato: mettete l'olio essenziale all'eucalipto e le foglie di eucalipto; mescolate e frullate.
Tococ d'arte: adesso versate il composto all'eucalipto dentro al composto al miele facendo una bella striscia centrale profonda. Versatelo tutto, poi procuratevi una bella assicella di legno.. o comunque qualcosa per isolare termicamente e mettete in un posto riparato il vostro stampo con tutto il sapone dentro, coperto in maniera che il calore duri di più aiutando la saponificazione. Lasciate maturare e indurire per 48 ore, poi sformate il sapone e lasciatelo stagionare almeno per un mese, meglio se due (diventa più delicato con la pelle).

HAPPY SOAPING ;)



mercoledì, ottobre 10, 2007

Cose semplici.. ma di effetto!!!

A volte penso: "come è possibile che nel nostro laboratorio si lavori così tanto senza pensare all'impatto emotivo che anche prodotti semplici hanno su chi li vede?" Ovviamente mi metto in prima persona: cerco di inventare algoritmi carini (e funzionanti) per svolgere i compiti più disparati nel ramo della computer visione e dell'elaborazione delle immagini.. e poi non mi rendo conto di quanto poco ci voglia per valorizzarli!

Ad esempio: con un proiettore, una webcam, un puntatore laser (ed ovviamente un computer) si può costruire in maniera molto semplice un sistema di puntamento (cioè di controllo del cursore) che funzioni con il puntatore laser puntato contro un muro dove è proiettato lo schermo del PC.. senza troppa fatica (l'algoritmo di localizzazione dello spot luminoso rosso è veramente una cavolata), ma con un risultato decisamente d'effetto! E' tanto semplice che mi è sembrato assurdo che non ci avesse ancora pensato nessuno.. infatti ci avevano già pensato [1].

Al che dico.. il giochino del puntatore laser me gusta e me lo implemento.. però d'ora in poi voglio cercare di stupirmi e stupirvi con effetti speciali.. alla mia portata! ;)

martedì, luglio 24, 2007

Factor-Graphs.. questi sconosciuti!

L'inferenza statistica è uno strumento veramente potentissimo in molti campi, permette di sfruttare al massimo le informazioni a disposizione, eventualmente corredate da prior distributions ecc ecc, per ricavare delle distribuzioni di probabilità che descrivono un determinato fenomeno. Ad esempio si può utilizzare una tecnica di inferenza come la belief-propagation nelle Bayesian-networks per sapere se in Cina il prezzo del sale aumenterà o diminuirà partendo dal fatto che in Italia piove ecc ecc.. eccessi a parte l'idea è che eventi fra loro apparentemente scorrelati possono influenzare tramite catene di dipendenza altri eventi, le Bayesian-networks hanno sostanzialmente lo scopo di consentire la gestione di queste dipendenze per determinare la distribuzione di probabilità di un evento a posteriori (ovvero date le informazioni disponibili).

Esistono una quantità smodata di tecniche di inferenza statistica, ma -udite udite- moltissime di esse sostanzialmente si pongono come scopo quello di marginalizzare una distribuzione di probabilità coniugata in molte variabili, spesso facilmente fattorizzabile (ad esempio utilizzando le regole relative alle distribuzioni di probabilità condizionata).

I factor-graphs sono uno strumento molto potente per la marginalizzazione di funzioni in molte variabili fattorizzabili in funzioni a poche variabili, del tipo:
data g(x1,x2,...,xn) = PRODi(f(Xi)

dove le xi sono le variabili e gli Xi sono dei sottoinsiemi (di cardinalità "bassa") delle variabili xi,

è possibile sfruttare la fattorizzazione per calcolare efficientemente:
g(xj) = SUMx1(SUMx2(...SUMxj-1(SUMxj+1(...SUMxn(g(x1,x2,...,xn))...))...))

I factor-graphs permettono di effettuare questo calcolo utilizzando un solo semplice algoritmo di nome Sum-Product-Algorithm. Tantissimi algoritmi sono rappresentabili come istanze dei factor-graphs, ad esempio l'algoritmo di Viterbi, il belief-propagation per le Bayesian-networks, forward-backward, Random Markov Fields ecc ecc Turbo-codes decoding.. e ovviamente molti altri algoritmi possono essere costruiti utilizzando lo stesso framework.

Quindi? Non state ancora leggendo l'articolo del link? Ok, allora se non avete voglia di leggere tutto il paper magari date un occhio qui per un tutorial/demo. ;)

mercoledì, luglio 04, 2007

Documenti antichi

Dalla Sonipaf rispuntano importantissimi documenti di 9 anni fa!!! Date un occhio a quali effetti collaterali producono gli esami di analisi nei poveri studenti che inconsapevoli del pericolo li affrontano!

Analisi1 Analisi2
GIURO.. prima di analisi ero normale! ;)

mercoledì, giugno 27, 2007

Da sempre, vicini

Da sempre, vicini


Interminabile la nostr'attesa,
obbligata distanza duratura
ha fermentato ancor più di prima
il desiderio e la certezza
d'un intreccio a maglie strette,
un ricco ricamo variopinto
che sulla tela della nostra vita
prende forma mostrando l'armonia
di ciò ch'assieme siamo e saremo.

Ritrovo, abbraccio, le pennellate
d'un rosso vivo or ci dipingono
su uno sfondo rosa permanente;
coricati in un campo di grano
ammirando l'orizzonte aperto:
scorgiamo serena retta linera
ch'immersi c'accompagnerà entrambe
fra carezze d'oro e alto cielo.


Gabriele Lombardi

lunedì, giugno 25, 2007

Side effects in Matlab

Come tutti i "matlabbisti" sanno, in Matlab l'assegnamento ed il passaggio dei parametri è virtualmente per copia, ovvero virtualmente ogni volta che si assegna una variabile ad un'altra o che si passa una variabile a una funzione questa viene copiata per intero in maniera tale da non avere side effects. In pratica ovviamente non viene sempre fatta la copia: viene utilizzata una politica di lazy-evaluation sulle copie in maniera da utilizzare la variabile originale fin tanto che non vengono fatte modifiche e di copiarla in una nuova variabile solamente a fronte di una richiesta di modifica della stessa (questo solamente per una questione di efficienza).

Ma è possibile ottenere in Matlab i side effects?

Ovviamente è possibile ottenerli utilizzando Java o creando MEX-files in C o in FORTRAN. E' però possibile ottenere i side effects anche in Matlab puro sfruttando i workspaces temporanei creati durante le chiamate a funzione. Nel post Programmare OOP in Matlab è stato spiegato come costruire una classe in Matlab utilizzando solamente le funzioni. Ora, si ipotizzi di istanziare la classe counter, descritta in quel precedente post, e crearne una copia come segue:
c1 = counter(1); % Istanziazione:
c2 = c1; % Copia:
Ora l'oggetto c1 e l'oggetto c2 sono esattamente lo stesso oggetto. Le modifiche su uno hanno side effects sull'altro, infatti:
c1.next()
ans = 1
c2.next()
ans = 2
c1.next()
ans = 3
c2.next()
ans = 4
Inoltre realizzando una funzione come la seguente:
function incrementa(c)
c.next();
E richiamandola come segue:
c =counter(1);
incrementa(c);
incrementa(c);
c.next()
ans = 3
E' possibile appurare che l'oggetto passato alla funzione può essere modificato dall'interno della stessa generando side-effects.

SPIEGAZIONE: Le classi realizzate come spiegato nel post precedente sfruttano la creazione di un workspace locale (WL) per ogni chiamata a funzione Matlab, quando una funzione Matlab viene richiamata un workspace temporaneo viene creato ex-novo in cui "vivono" le variabili locali della funzione, alla terminazione dell'esecuzione tale WL viene lasciato in pasto al garbage collector che normalmente lo rimuove, nel caso però in cui vengano restituiti i puntatori a funzioni innestate, che possono quindi accedervi, il WL non viene rimosso perchè esistono ancora delle variabili che vi possono accedere. Il WL viene eliminato quando anche l'oggetto istanziato diviene irraggiungibile. A differenza delle normali variabili però il WL è legato all'istanza dell'oggetto in maniera indiretta, non fa parte della variabile, questo significa che copiare la variabile non copia il WL. L'oggetto rappresenta in maniera indiretta un puntatore al WL, passare quindi questo "puntatore" a una funzione o copiarlo non provoca la replica del WL che rimane lo stesso e soffre quindi dei side-effects.

Questo comportamento non deve essere visto come un "baco" ma come una "feature": infatti è un modo efficace per ottenere i side-effects quando e se servono.