Robitex's Blog

Ideas in the web

Roma: GuITmeeting 2013


Il luogo del convegno

Ciao a tutti,
tra pochi giorni si terrà a Roma il decimo convegno nazionale del GuIT.

Partecipate numerosi correndo ad iscrivervi perchè l’evento è un’ottima occasione per saperne di più sul sistema TeX ed è libero e gratuito.

Si parlerà dunque di un software libero sviluppato da oltre trent’anni in grado di produrre ottima documentazione sia per qualità tipografica che per una modalità di lavoro e gestione dei dati.

Il convegno è un momento importante nell’attività del GuIT, il TeX User Group italiano ufficiale che ha come missione quella di diffondere l’uso di TeX nel nostro paese, per conoscere, apprezzare e parlare nel clima di amicizia e condivisione 🙂 .

Arrivederci a Roma!
R.

Annunci

Differenza di orari in TeX


Ciao,
in questo assolato e caldo meriggio d’estate, vi presento problema e soluzione di un caso particolare che forse a questo punto vi incuriosirà.

Differenza di orari

Dovendo compilare un report, non potevo certo non farlo con LaTeX ed allora mi son trovato il problema di calcolare diverse differenze orarie. Per esempio tra le 10:25 e le 11:40 sono trascorse un’ora e quindici minuti, alias 1:15.

Torna comodo scrivere una macro con argomenti delimitati — visto come sono TeXnico? — che calcoli i minuti trascorsi dalla mezzanotte per ciascun orario, esegua la differenza e riconverta il risultato nel formato ore:minuti.

Ecco il codice da compilare con pdflatex ovviamente:

\documentclass{article}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}

% contatori di minuti
\newcount\mi
\newcount\mii

% determina la differenza oraria
\def\timediff(#1:#2-#3:#4){%
% mii contiene i minuti dell'orario di uscita
\mii=#3
\multiply\mii by 60
\advance\mii by #4
% mi contiene i minuti dell'orario di entrata
\mi=#1
\multiply\mi by 60
\advance\mi by #2
% mii contiene il numero dei minuti effettuati
\advance\mii by -\mi
\mi=\mii
\divide\mii by 60
\the\mii:%
\multiply\mii by 60
\advance\mi by -\mii
\ifnum\mi<10
    0%
\fi
\the\mi
}

\begin{document}
Tra le 14:35 e le 18:38 abbiamo: \timediff(14:35-18:38).
\end{document}

Se poi devo arrotondare alla mezz’ora per difetto?

Tranquilli, niente panico (cit.), è sufficiente

\documentclass{article}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}

% contatori di minuti
\newcount\mi
\newcount\mii

% determina la differenza oraria
% con l'arrotandamento alla mezz'ora
% per difetto
\def\timediff(#1:#2-#3:#4){%
% mii contiene i minuti dell'orario di uscita
\mii=#3
\multiply\mii by 60
\advance\mii by #4
% mi contiene i minuti dell'orario di entrata
\mi=#1
\multiply\mi by 60
\advance\mi by #2
%% mii contiene il numero dei minuti effettuati
\advance\mii by -\mi 
%% mii contiene il numero delle mezz'ore
\divide\mii by 30 
%
\ifodd\mii
    \mi=3
\else
    \mi=0
\fi
%% mii contiene il numero delle ore
\divide\mii by 2
\the\mii:\the\mi 0%
}

\begin{document}
Tra le 14:35 e le 18:38 abbiamo: \timediff(14:35-18:38).
\end{document}

Una volta tanto finisco prima — non vi farò l’esempio della soluzione equivalente in LaTeX3 od in LuaTeX, questo passa il convento e dovrete accontentarvi.
Ok, allora a voi la parola con un classico…
Alla prossima.
R.

Se SQLite vi sembra lento…


Sommario

Indagine sul perché SQLite fosse così lento ad inserire i dati…
In un progetto di elaborazione dati ho utilizzato un database SQLite per gestire un set di dati abbastanza complesso. Fino ad ora ammettevo che il codice per l’inserimento dei dati fosse molto lento contrariamente all’esecuzione delle query…

Cosa ho vantaggiosamente scoperto

L’inserimento dei dati avviene in SQLite all’interno di transazioni che hanno lo scopo di salvare i dati in modo sicuro. Se eseguo un inserimento tramite la normalissima funzione SQL INSERT, SQLite attende che ogni record inserito sia completamente e con successo salvato fisicamente sul disco.
Questo comportamento è dovuto al fatto che l’istruzione viene inserita automaticamente in una transazione.

Il numero di transazioni che SQLite è in grado di completare è dell’ordine di 10 al secondo, ed ecco spiegato il motivo di quelle strane attese. All’interno di una transazione invece il numero di inserimenti è dell’ordine di 50.000 al secondo.

Soluzioni

Compreso che ogni inserimento crea implicitamente una transazione, le alternative sono due:

  1. non fare niente e lasciare che i dati vengano inseriti con una transazione alla volta per usufruire della massima affidabilità;
  2. rendere le operazioni molto più veloci operando all’interno di un’unica transazione, ma anche meno sicure in caso di guai con il processo client.

…naturalmente ho preferito la seconda…

Giusto per fissare le idee

Giusto per fissare le idee, il codice che ho utilizzato, scritto in Lua e che utilizza la libreria LJSQLite3 scritta per luajit, è il seguente:

-- carico la libreria LJSQLite3
local sql = require "ljsqlite3"

-- creo la connessione
-- (in dbfilename è salvato il nome effettivo del file)
    local conn = sql.open( dbfilename, "rw")

-- abilito il vincolo di chiave esterna
-- per il momento non ON di default per mantenere
-- compatibilità con versione precedenti di SQLite3 versione 3.6
    conn:exec("PRAGMA foreign_keys = ON;")

-- creo una transazione
    conn:exec "BEGIN" -- begin transaction

-- codice per inserire i dati nel database
-- per esempio con un prepared statement
-- (codice esemplificativo con nomi tabella e campi per riferimento)
   local stmt = conn:prepare("INSERT INTO mytable " ..
     .. "(field_1, field_2, ..., field_n)" ..
     .. " VALUES (?, ?, ..., ?);" )
...
...
... eccetera eccetera

-- chiudo la transazione
    conn:exec "END"

-- chiudo la connessione
    conn:close()

Saluti e buona estate.

Opuscoli e booklet


Sommario

Utilizzeremo il sistema TeX per comporre documenti in formato A4 su libretti in formato A3.

Capita…

Capita di dover stampare fronte retro dei documenti ripiegando i fogli in un libretto. Chiameremo questa modalità booklet oppure opuscolo.
L’esempio è il seguente: abbiamo a disposizione un documento di quattro pagine nel formato A4 e vorremo comporlo nel formato A3 fronte retro in modo che il foglio A3 ripiegato formi l’opuscolo, come in questa raprresentazione:

Fronte:
+-----++-----+
|  4  ||  1  |
|     ||     |
+-----++-----+

retro:
+-----++-----+
|  2  ||  3  |
|     ||     |
+-----++-----+

La soluzione con LaTeX

Quella che vi propongo è una soluzione che ha il pregio di rappresentare un esempio che può essere applicato a casi anche molto più complicati di quello in esame, e consiste nel salvare un file di testo puro nella stessa cartella contenente il file che chiameremo docA4.pdf con le quattro pagine, con il seguente contenuto:

\documentclass{minimal}
\usepackage[a3paper,landscape]{geometry}
\usepackage{pdfpages}

\begin{document}
\includepdf[pages={4,1,2,3},nup=2x1]{docA4}
\end{document}

Compilando questo file (dategli l’estensione .tex) quello che succede è questo:

  1. viene impostato il formato di pagina A3 orizzontale;
  2. viene caricato il pacchetto pdfpages che definisce il comando \includepdf;
  3. e poi si inseriscono nel documento una alla volta e nella sequenza corretta, le pagine del documento in A4.

Il comando \includepdf offre molte altre opzioni: consultate la documentazione del pacchetto per scoprirle.

Un documento di esempio

Volendo, possiamo produrre sempre con LaTeX un documento da utilizzare per verificare che il codice precedente funziona. Basta compilare questo codice più complicato del precedente perché fa uso di un po’ di programmazione della nuova libreria LaTeX3, in modo da poter generare documenti demo di qualsiasi lunghezza (basta cambiare l’argomento del comando \demodoc):

\documentclass{minimal}
\usepackage[a4paper]{geometry}
\usepackage{graphicx}
\usepackage{xparse}

%%% codice LaTeX3
\ExplSyntaxOn
\NewDocumentCommand{ \demodoc }{ m }
   {
   \demodoc_repeat:n { #1 }
   }

\cs_new_protected:Nn \demodoc_repeat:n
   {
   \int_step_inline:nnnn { 1 }{ 1 }{ #1 }
      { \centering
        \scalebox{12}{##1}
        \newpage
      }
   }
\ExplSyntaxOff

\begin{document}
\demodoc{4}
\end{document}

Ecco pronto da scaricare il file risultato docA4.pdf.

Note tecniche

Per avvalersi delle magie compositive di pdfpages per la costruzione di opuscoli, occorre installare sul vostro computer una distribuzione TeX – che fa sempre comodo e non costa nulla – ed io vi consiglio spassionatamente TeX Live disponibile per praticamente tutti i sistemi operativi.

Ciao a tutti!

Il passaggio della stazione spaziale


L’attesa

Da un po’ di tempo scrutavo il cielo al momento giusto ma era sempre nuvoloso. Avevo il dubbio che l’orario non fosse riferito all’ora locale oppure che la traiettoria prevista fosse in realtà un’altra oppure ancora che fosse difficile da vedere ad occhio nudo.
Ma finché il cielo fosse rimasto nuvoloso di certo non potevo verificare se effettivamente alla quota di circa 350 km ben al di sopra della coltre di nubi, fosse transitata la ISS, la stazione spaziale internazionale, alla velocità di 28000 km/h.

Finalmente, la moderna stella cometa

Invece, con incredibile precisione, stasera all’imbrunire il cielo terso mi ha permesso finalmente di osservare il passaggio della stazione spaziale internazionale per alcuni minuti, dalla direzione Nord Nord Ovest a quella di Nord Est. Fantastico.
Un punto luminoso, più luminoso di una stella, che viaggia tranquillo su una traiettoria apparentemente rettilinea…

L’equipaggio della stazione che nell’esatto momento in cui io li guardavo da terra, affacciandosi al finestrino avrebbero visto il panorama della foto seguente, è composto da tre persone: il comandante Kevin Ford ed i due ingegneri di volo Oleg Novitskiy e Evgeny Tarelkin.

iss web cam

The ISS web cam

Come ho fatto?

Semplice, mi sono collegato al portale della Nasa ed alla pagina spot the station ho inserito località di residenza ed indirizzo di posta elettronica al quale ricevere i messaggi con l’ora del passaggio e le coordinate di avvistamento della ISS.

Buon 2013 a tutti

Non rimane che scaricare il calendario in tema (ancora del 2012) e godersi lo spettacolo augurandovi di trascorrere uno splendido nuovo anno.
Buon anno a tutti.
R.

Fine del mondo!


Oggi finisce il mondo.

Per quelli che ci credono, per quelli che invece non ci credono e per quelli che poi quando capiterà effettivamente non ci crederanno perché il 21/12/2012 non successe nulla…

Buona fine del mondo,

e buon inizio…

Iterare su SQLite con Lua


Sommario

Riferendoci alla libreria LJSqlite3 verrà spiegato come iterare facilmente la collezione di dati di un database relazionale attraverso una query. Verranno inoltre messe in evidenza le proprietà dell’iteratore ai fini della pulizia e dell’intuitività del codice Lua.

Effective code

È sempre molto utile scrivere codice che sia espressivo e compatto, qualità che potremo riassumere in un unico termine idiomatico: effective.
Gli iteratori di Lua, che abbiamo già visto in questo post, sono costrutti sintattici che semplificano il nostro codice facendo corrispondere un concetto/entità con un elemento del linguaggio.
Lo sviluppatore costruisce così strutture concettualmente vicine a ciò che asserisce al problema da risolvere.

L’ambiente di lavoro

Utilizzeremo il database SQLite3 per creare, inserire ed interrogare i dati, e la libreria LJSqlite3 per LuaJIT un compilatore Lua, per creare il codice applicativo.
Sul vostro sistema dovranno essere installati sia SQLite3, che LuaJIT, e le librerie Xsys e LJSQLite3 scaricabili dai rispettivi siti e disponibili per quasi tutti i sistemi operativi.

Inoltre lavoreremo con un (semplice) database in modalità in-memory cioé interamente mantenuto nella memoria centrale, così che tutto il codice di esempio possa trovare posto in un unico file.

L’iteratore Lua

Il nostro obiettivo è scrivere un iteratore ‘stateless‘ in Lua che ad ogni ciclo ci metta a disposizione record per record, il risultato di una query.
Chiamando l’iteratore ‘iselect()‘ potremo prevedere per esso due argomenti: la connessione al database e la query da eseguire. Per concretizzare l’idea, lasciando i dettagli ad un secondo momento, il codice per stampare l’intero contenuto della tabella di esempio ‘val‘ con i suoi attributi ‘id‘ e ‘num‘ potrebbe essere il seguente:

for i, tr in iselect(conn, "SELECT * FROM val;") do
    print( 'Row '..i..': ', tr.id, tr.num)
end

L’iteratore ad ogni ciclo del ‘generic for’ ritorna il progressivo del record e la ‘tupla’ (una tabella Lua ovviamente) con i valori dei campi indicizzati con chiavi corrispondenti ai nomi degli attributi della tabella del database.

Passiamo ora al codice completo dell’esempio con l’implementazione dell’iteratore definito precedentemente. Non spiegherò il listato nei dettagli tecnici rimandando il lettore alle documentazioni dei singoli componenti peraltro scritte piuttosto bene. Eseguire il codice con il comando $ luajit nomefile.lua.

-- iterator function
local function nextrec(t, i)
    i = i + 1
    if i <= t.__number_of_records then
        local tr = {}
        local nc = #t[0]
        for col=1, nc do
            local field = t[0][col]
            tr[field] = t[col][i]
        end
        return i, tr
    end
end

-- stateless iterator
local function iselect(connection, query)
    local t, nr = connection:exec(query, 'hi')
    t.__number_of_records = nr
    return nextrec, t, 0
end

-- SQL code

local sql = require "ljsqlite3"
-- Open a temporary in-memory database.
local conn = sql.open("")

-- Execute SQL commands separated by the ';'
conn:exec[[
CREATE TABLE val (id TEXT, num REAL);

INSERT INTO val VALUES('myid1', 260);
INSERT INTO val VALUES('myid2', 200);
INSERT INTO val VALUES('myid3', 200);
INSERT INTO val (id) VALUES('myid4');
INSERT INTO val (num) VALUES(200);
INSERT INTO val VALUES('myid6', 260);
INSERT INTO val VALUES('myid7', 201);
INSERT INTO val VALUES('myid8', 300);
INSERT INTO val VALUES('myid9', 240);
]]

-- user code
for i, tr in iselect(conn, "SELECT * FROM val;") do
    print( 'Row '..i..': ', tr.id, tr.num)
end
conn:close()

Conclusioni

Oltre a confermare l’intuitività e la semplicità degli iteratori in Lua, abbiamo dimostrato come SQLite3 e le librerie LuaJIT per accedervi, siano in grado di fornire una soluzione performante e potente per la creazione di applicativi non di rete.

Un saluto.

Napoli: tutto pronto per il GuITmeeting


GuITmeeting2012

Tra pochissimi giorni, Sabato 27 ottobre 2012 si terrà a Napoli il GuITmeeting 2012, uno dei più importanti tra i meeting organizzati dal GuIT, Gruppo utilizzatori italiani di TeX, che per la prima volta non si svolgerà nell’aula magna della scuola Sant’Anna di Pisa, ma nell’altrettanto prestigiosa sala del Centro congressi Partenope dell’Università degli Studi di Napoli Federico II.

Anch’io parteciperò molto volentieri essendo perfino riuscito a presentare un lavoro di cui vi posso dire solo il titolo: “La grafica ad oggetti con LuaTeX”.

Non mancate sarà una bellissima occasione

Qualsiasi cosa stiate facendo, collegatevi subito con il sito del GuIT alla pagina del modulo d’iscrizione 🙂 !
Grazie, ci vediamo a Napoli!

Iteratori in Lua


Costruzione di un iteratore in Lua

La costruzione di un iteratore in Lua si basa sulla creazione di una funzione che restituisce uno alla volta gli elementi dell’insieme nella sequenza desiderata. Una volta costruito l’iteratore, questo potrà essere impiegato in un ciclo foreach — che in Lua viene chiamato generic for — in modo molto efficiente.
Se per esempio si volesse iterare la collezione dei numeri pari compresi nell’intervallo da 1 a 10, avendo a disposizione l’apposito iteratore evenNum(first, last) che definiremo in seguito, potrei scrivere semplicemente:

for n in evenNum(1,10) do
   print(n)
end

ottenendo in console:

2
4
6
8
10

Numeri pari

Per definire questo iteratore dobbiamo creare una funzione che restituisce a sua volta una funzione in grado di generare la sequenza dei numeri pari. L’iterazione termina quando giunti all’ultimo elemento, la funzione restituirà il valore nullo ‘nil’, cosa che succede in automatico senza dover esplicitare un’istruzione di return.
Per prima cosa si calcola il numero pari successivo al numero di partenza dell’intervallo. Lo faremo usando la funzione math.ceil() che fornisce il numero arrotondato al primo intero superiore dell’argomento. Poi viene restituita la funzione in sintassi anonima che prima incrementa di 2 il numero pari precedente — ed ecco perché inizialmente viene sottratta la stessa quantità all’indice — e, se questo è inferiore all’estremo superiore dell’intervallo, verrà restituito l’indice corrente, il numero pari della sequenza:

-- iteratore dei numeri pari compresi
-- nell'intervallo [i, e]
function evenNum(i, e)
   -- primo numero pari della sequenza
   i = 2*math.ceil(i/2) - 2
   return function ()
             i = i + 2
             if i<=e then
                return i
             end
          end
end

Tecnicamente il sistema funziona perché ogni volta che viene chiamata una funzione, Lua crea le necessarie variabili in una nuova area di memoria, così che la funzione anonima possa lavorare correttamente. Ulteriori particolari possono essere reperiti nel libro ‘Programming in Lua‘, cosa consigliabile se si devono costruire iteratori in ambienti di produzione.

Naturalmente, l’implementazione data di evenNum() è solo una delle possibili soluzioni, e non è detto che non debbano essere considerate situazioni particolari come quella in cui si passa all’iteratore un solo numero o addirittura nessun argomento.

Stateless iterator

Una seconda versione del generatore di numeri pari può essere un buon esempio di un iteratore in Lua che non necessita di un area di memoria — chiamata closure — per un risultato ancora più efficiente.
Per capire come ciò sia possibile dobbiamo conoscere come funziona il ‘generic for’ in Lua; dopo la parola chiave ‘in’ esso si aspetta tre parametri: la funzione dell’iteratore da chiamare ad ogni ciclo, una variabile che rappresenta lo stato invariante, e la variabile di controllo.
Nel seguente codice la funzione evenNum() provvede a restituire i tre parametri necessari: la funzione nextEven() come iteratore, lo stato invariante che per noi è il numero a cui la sequenza dovrà fermarsi, e la variabile di controllo che è proprio il numero della sequenza dei numeri pari, e con ciò abbiamo realizzato un stateless iterator in Lua.
La funzione iteratrice nextEven() verrà chiamata ad ogni ciclo con nell’ordine lo stato invariante e la variabile di controllo, pertanto fate attenzione, dovete mettere in questo stesso ordine gli argomenti nella definizione.

-- even numbers stateless iterator
local function nextEven(last, i)
   i = i + 2
   if i<=last then
      return i
   end
end

local function evenNum(a, b)
   a = 2*math.ceil(a/2)
   return nextEven, b, a-2
end

-- example of generic for
for n in evenNum(10,20) do
print(n)
end

Lua non finisce mai di stupire…
Alla prossima!

Numeri in lettere in Go


Scarica l’articolo in formato pdf

Sommario

Un nuovo linguaggio di sviluppo si è affacciato sulle scene: è il Go. In questo post non spiegherò come installare Go sul sistema, né come compilare il sorgente od il perché compaiono certe espressioni. Vorrei piuttosto proporre di assaporare questo nuovo piatto del grande libro di ricette, informatiche s’intende.

Di nuovo numeri in lettere…

Avevamo già preso in considerazione il problema di tradurre numeri in lettere, per sperimentare un nuovo linguaggio o per confrontarne le caratteristiche. Prima in Java in questo post, poi in Python e Lua in quest’altro post.

Ricorsione, operazioni con le stringhe, test a scelta multipla, sono tutti temi impiegati nel codice informatico che dato un numero, ne restituisce il testo letterale.

Il codice

Vi presento subito il codice:

package main

import "fmt"

func main() {
    var n uint64
    for {
        fmt.Scanf("%d", &n)
        fmt.Println(num2text(n))
    }
}

// array per definizione nomi da 1 a 19
var alpha19 = [...]string{"uno", "due", "tre", "quattro",
     "cinque", "sei", "sette", "otto", "nove", "dieci",
     "undici", "dodici", "tredici", "quattordici", "quindici",
     "sedici", "diciassette", "diciotto", "diciannove",}
     
var  decine = [...]string{"venti", "trenta", "quaranta",
                  "cinquanta", "sessanta", 
                  "settanta", "ottanta", "novanta",}

// funzione ricorsiva di trasformazione
// di un intero nella definizione letterale
func num2text(n uint64) string {
    switch {
        case n==0 :
           return ""
        case n<=19 :
           return alpha19[n-1]
        case n<=99 : {
           letter := decine[n/10-2]
           if t := n%10; t == 1 || t == 8 {
              letter = letter[0:len(letter)-1]
           }
           return letter + num2text(n%10)
        }
        case n<=199 :
            return "cento" + num2text(n%100)
        case n<=999 : {
            letter := "cent"
            if m := (n%100)/10; m != 8 {
                letter += "o"
            }
            return alpha19[n/100-1] +
                   letter +
                   num2text(n%100)
        }
        case n<=1999 :
            return "mille" + num2text(n%1000)
        case n<= 999999 : {
            return num2text(n/1000) +
                   "mila" +
                   num2text(n%1000)
        }
        case n <= 1999999 :
            return "unmilione" + num2text(n%1000000)
        case n <= 999999999 :
            return num2text(n/1000000)+
                "milioni" +
                num2text(n%1000000)
        case n <= 1999999999 :
            return "unmiliardo" + num2text(n%1000000000)
        default:
            return num2text(n/1000000000) +
                "miliardi" +
                num2text(n%1000000000)
    }
    return ""
}

Il codice si apre con la funzione main() che chiama a sua volta una funzione num2text() non ancora definita nel sorgente, e prosegue definendo un paio di array con le espressioni letterali dei numeri, per finire con la definizione della funzione ricorsiva, tutta costruita con un costrutto switch.

Se è la prima volta che vi capita del codice in Go, leggete il listato con calma e scoprirete un po’ di stranezze. Proprio questo è quello che intendo per imparare un nuovo linguaggio…

Prime impressioni sul Go

Non male, davvero non male. Non nascondo che questo linguaggio mi piace, prima di tutto perché non si lascia compilare facilmente, ed è per così dire “colto”, ricco di dettagli da tenere a mente, insomma ben progettato. Sembra una di quelle espressioni dell’architettura che li per li dice poco ma che invece abitandola rivela profondità.

Sfida

Il listato non è perfetto. Lancio dunque una sfida a chi vorrà farlo con divertimento: trovare un codice ancora migliore, più elegante e più tecnico di quello che ho trovato io per tradurre un numero in lettere.
Let’s Go…

%d blogger hanno fatto clic su Mi Piace per questo: