php daemon

In quest’ultimo articolo descrivo come si lancia in background lo script PHP su un server con sistema operativo Linux Ubuntu o Debian. Come vi sarete accorti lo script descritto nella seconda parte contiene nella prima riga il seguente codice:

#!/usr/bin/env php

in gergo questa sintassi si chiama Shebang e viene utilizzata per lanciare dalla shell l’interprete dello script che sta per essere eseguito. In questo caso il PHP. Sarà dunque necessario verificare che PHP5-CLI (command line interpreter) sia installato.

Se proviamo a lanciare, semplicemente digitando gpsspck.php da un terminale, questo è l’output prodotto non appena viene “agganciato” il tracker:

output di gpssock.php

Per lanciarlo in background, questo è lo script bash che ho preparato per gestire l’avvio e la chiusura del socket PHP:

#!/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
NAME=gpssock
PIDFILE="/var/run/${NAME}.pid"
WORKINGDIR="/path/to/gpssock/"
DAEMON="${WORKINGDIR}${NAME}.php"
DAEMONLOG="${WORKINGDIR}${NAME}.out"

case "$1" in
  start)
	start-stop-daemon --start  --make-pidfile --pidfile=$PIDFILE --exec $DAEMON>>$DAEMONLOG &
	;;
  restart|reload|force-reload)
	echo "Error: argument '$1' not supported" >&2
	exit 3
	;;
  stop)
	start-stop-daemon --stop --pidfile=$PIDFILE
	;;
  *)
	echo "Usage: $0 start|stop" >&2
	exit 3
	;;
esac

Lo script esegue start-stop-daemon che è un programma frequentemente utilizzato su Ubuntu per avviare e terminare i processi che funzionano come demoni. Se ne possono trovare diversi esempi nella directory /etc/init.d/ ed infatti è proprio lì che andremo a collocare il nostro script. Gli unici due settaggi da fare sono quelli di modificare, se necessario, la variabile NAME con il nome del file PHP da lanciare (nel nostro caso gpssock) e di impostare la directory di lavoro WORKINGDIR con il percorso corretto di gpssock.php
Notate che l’ultimo parametro di start-stop-daemon è & questo indica che il processo deve essere eseguito in background. Infine tutti gli output vengono rediretti in un file di log che ha lo stesso nome dello script PHP ed estensione .out

Per lanciare lo script da riga di comando:

/etc/init.d/gpssock start

Per terminare lo script da riga di comando:

/etc/init.d/gpssock stop

Se vogliamo che lo script parta all’avvio in esecuzione automatica, è necessario registrarlo con questa istruzione:

update-rc.d gpssock defaults

Riferimenti:

• OpenGTS
• Open GPS Tracking Server
• Socket Programming With PHP
• PHP: Sockets – Manual

Socket PHP

Nella prima parte di questo articolo ho illustrato come creare le tabelle del DB dove registrare i dati provenienti dal tracker GPS, le principali funzionalità dello script e la possibilità di “agganciare” questo socket direttamente al software Open Source: OpenGTS.

Quest’ultima caratteristica, la ritengo particolarmente interessante in quanto permette di evitare di scriversi tutta la parte che riguarda la visualizzazione dei punti inviati dal tracker, sulle mappe.

Ed ecco il codice PHP del loop del socket (L’intero script è disponibile qui):

#!/usr/bin/env php
< ?php
/***********************************************************************
 *  SETTINGS
 * ********************************************************************/
define("VERBOSE", true);
define("MOVING_THRESHOLD",.04); //.05 = 50 metres
define("OPENGTS",false);
/* HOST                                                               */
define("IP_ADDR","0");	// "0" = listen all ip
define("TCP_PORT",5050);
/* DATABASE                                                           */
define("DBHOST","localhost");
define("DBUSER","dbuser");
define("DBPASS","dbpassword");
define("DBNAME","gpsd");
/* TRACKER                                                            */
define("POLL_TIME",60); // SET POLL TIME 20,30,60,300,600 default:60 secs
define("SPEED_CONV",1.852); //From NM to Km
define("DFLT_MSG","tracker");
/* SOCKET                                                             */
define("SOCK_RCV_TIMEOUT",120); // Socket receive timeout in seconds
/***********************************************************************
 * END SETTINGS
 * ********************************************************************/
// Do not edit here-----------------------------------------------------
error_reporting(E_ALL);
// Do not exit while waiting for connect...
set_time_limit(0);
// Turn implicit flush on
ob_implicit_flush();

$dblink = dbConnect();
$address =  IP_ADDR;
$port = TCP_PORT;
$allowedIMEI = getAllowedImei($dblink);
$sendPollTime = false;

// Create the socket and bind it to the host and port, with infinite loop.

if (($sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) < 0) {
   writeLog("socket_create() failed: ".socket_strerror($sock),true);
}
if (($ret = socket_bind($sock, $address, $port)) < 0) {
   writeLog("socket_bind() failed: ".socket_strerror($ret),true);
}
if (($ret = socket_listen($sock, 5)) < 0) {
   writeLog("socket_listen() failed: ".socket_strerror($ret),true);
}
do {
	if (!mysql_ping ($dblink)) { //check if mysql connection is active
		mysql_close($dblink);
		$dblink = dbConnect(); //if not, connect!
	}
	try {
		if (FALSE === ($msgsock = socket_accept($sock))) {
		  throw new Exception("socket_accept() failed: " . socket_strerror(socket_last_error($msgsock)));
		}
		socket_set_option($msgsock, SOL_SOCKET, SO_RCVTIMEO, array('sec' => SOCK_RCV_TIMEOUT,'usec' => 0));
		writeLog("CONNECT");
		if (FALSE === ($buf = socket_read($msgsock, 2048))) {
		  throw new Exception("socket_read() failed: " . socket_strerror(socket_last_error($msgsock)));
		}
		writeLog("RECEIVED: ".$buf);
		$actualIMEI = "";
		$outData = array();
		$buf = trim($buf); // clean up input string
		$dirtyMode = (substr($buf, 0, 2) == "##") ? false : true;
		$actualIMEI = (!$dirtyMode) ? substr($buf, 8, 15) : substr($buf, 5, 15);  // returns IMEI

		if (!in_array($actualIMEI, $allowedIMEI)){
		  throw new Exception("Received: $actualIMEI from $buf, IMEI not allowed");
		}
		if (!$dirtyMode){
			$output = "LOAD". "\n";
			writeLog("SEND: LOAD");
			// Send intructions
			socket_write($msgsock, $output, strlen($output));
			if (FALSE === ($buf = socket_read($msgsock, 2048))) {
		  		throw new Exception("socket_read() failed: " . socket_strerror(socket_last_error($msgsock)));
			}
			$buf = trim($buf);
			writeLog("RECEIVED: ".$buf);
			if (empty($buf)){
				 throw new Exception("Received: nothing, disconnect");
			}

			if (($sendPollTime === false)) {
				$output = "ON". "\n";
				writeLog("SEND: ON");
				socket_write($msgsock, $output, strlen($output));
				$output = "**,imei:".$actualIMEI."," . pollTimeString(POLL_TIME)."\n";
				socket_write($msgsock, $output, strlen($output));
				writeLog("SEND: ".$output);
				if (FALSE === ($buf = socket_read($msgsock, 2048))) {
					$sendPollTime = false;
					throw new Exception("socket_read() failed: " . socket_strerror(socket_last_error($msgsock)));
				}
				$buf = empty($buf) ? "NO DATA" : trim($buf);
				$sendPollTime = true;
			}
		}
		$outData = explode ( "," , $buf );
		writeLog("DATA: ".$buf);
		if(count($outData)>=5){
			$outDecodedData = decodeData($outData);
			if ($outDecodedData['DATA_FL'] == "F" || $outDecodedData['MSG'] !== DFLT_MSG){
				if (OPENGTS) {
					$res = updatePosOpenGTS($outDecodedData);
				}
				else{
					$res = updatePos($outDecodedData);
				}
			}
		}
	} catch (Exception $e) {
		writeLog(" ".$e->getMessage(),true);
	}
	socket_close($msgsock);
	writeLog("SOCKET CLOSE");
} while (true);
socket_close($sock);
dbClose($dblink);
// ... continua
?>

Come si può notare il socket $sock è in costante ascolto, e quando arriva una richiesta di connessione viene creato il socket $msgsock che si prende il carico dell’intera comunicazione. Se il tracker sta trasmettendo in “single point”, i primi due caratteri sono: ##, in questo caso viene inviato il comando di polling forzando l’apparecchio a trasmettere in “multi point” con l’intervallo desiderato.

Vediamo adesso la funzione che si occupa della decodifica del messaggio che contiene i dati veri e propri. Questo è formato da 12 campi separati da virgola. Nei commenti iniziali è riportata la loro composizione, il formato e i possibili valori.

function decodeData($arr){
/* *********************************************************************
*   0 = imei:000000000000000	[imei]
*   1 = tracker					[Msg: help me / low battery / stockade /
* 											dt /move / speed / tracker]
*   2 = 0809231929				[acquisition time: YYMMDDhhmm +8GMT cn]
*   3 = 13554900601				[adminphone?]
*   4 = F						[Data: F - full / L - low]
*   5 = 112909.397				[Time (HHMMSS.SSS)]
*   6 = A						[A = available?]
*   7 = 2234.4669				[Latitude (DDMM.MMMM)]
*   8 = N						[Lat direction: N / S]
*   9 = 11354.3287				[Longitude (DDDMM.MMMM)]
*  10 = E						[Lon direction: E / O]
*  11 = 0.11					[speed Mph]
***********************************************************************/
	$out = array();
	$out['IMEI'] = substr($arr[0], 5, 15);
	$out['MSG'] = trim($arr[1]);
	$out['ACQUISITION_TIME'] = substr($arr[2], 0, 2)."-".
						substr($arr[2], 2, 2)."-".substr($arr[2], 4, 2).
						" ".substr($arr[2],6,2).":".substr($arr[2],8,2);
	$out['ADMINPHONE'] = trim($arr[3]);
	$out['DATA_FL'] = trim($arr[4]);
	 if ($out['DATA_FL'] === "F"){
		 $out['TIME'] = substr($arr[5], 0, 2).":" . substr($arr[5], 2, 2).":" . sprintf("%2d",round(floatval(substr($arr[5], 4, 6))));
		 $out['AVAILABLE'] = $arr[6]==="A" ? 1 : 0;
		 $out['LAT'] = floatval(substr($arr[7], 0, 2)) +
					   floatval(substr($arr[7], 2, 7)) / 60;
		 $out['LAT'] = $arr[8]==="N" ? $out['LAT'] : -$out['LAT'];
		 $out['LON'] = floatval(substr($arr[9], 0, 3))  +
					   floatval(substr($arr[9], 3, 7)) / 60;
		 $out['LON'] = $arr[10]==="E" ? $out['LON'] : -$out['LON'];
		 $out['SPEED'] = floatval($arr[11]) * SPEED_CONV;
	}
	else {
		 $out['TIME'] = "00:00:00";
		 $out['AVAILABLE'] = 0;
		 $out['LAT'] = (float) 0;
		 $out['LON'] = (float) 0;
		 $out['SPEED'] = (float) 0;
	}
	return $out;
}

Rimane un dubbio sul campo 3, che quasi sicuramente dovrebbe essere il numero di telefono abilitato alla comunicazione SMS con il tracker e sull’unità di misura utilizzata per la velocità. I cinesi della Cobanch dicono che è Km, ma sperimentalmente è facile smentirli. Sempre sperimentalmente, ho potuto verificare con accettabile precisione che si tratta di NM (miglia nautico internazionale)

Nella terza parte di questo articolo vedremo come avviare lo script su un server Linux facendolo funzionare in background come “demone”.

Tracker GPS 102

Alcuni mesi fa mi è stato regalato questo questo tracker GPS per studiare come registrare su un database MySQL i dati che vengono trasmessi. L’apparecchio si chiama GPS-102 viene prodotto dalla Cobanch ed è disponibile anche in Italia ad un costo inferiore a 100€ su questo sito: www.nonsoloprevenzione.it

Poiché le informazioni della documetazione allegata sono, come spesso accade, piuttosto scarse, mi sono messo alla ricerca nel Web delle specifiche tecniche e del datagramma per la comunicazione dei dati forniti dal tracker (coordinate, velocità, ecc). Fortunatamente ho trovato questo foglio di calcolo, che si riferisce ai modelli TK102, TK103 ma il protocollo risulta identico e fornisce dunque le informazioni necessarie allo sviluppo del software.

Va detto che l’apparecchio necessita di una scheda GSM (come mostrato in foto) e normalmente utilizza SMS sia per le impostazioni che per comunicare i dati relativi alla sua posizione. Se la scheda viene abilitata al traffico GPRS, è possibile inviare i dati sotto forma di pacchetti TCP direttamente ad un server nella rete semplicemente impostando, sempre tramite SMS, l’indirizzo IP del server e la porta di comunicazione TCP.

Sebbene una gran parte dei tracker in commercio utilizzino connessioni UDP, questo apparecchio utilizza il protocollo TCP orientato alla connessione, che a discapito di una maggiore banda richiesta e di una modesta diminuzione delle prestazioni velocistiche, garantisce una trasmissione senza errori.

I dati da registrare sono principalmente:

1. Latitudine
2. Longitudine
3. Velocità

Questi sono i dati necessari per rendere su Google Maps, o qualsiasi altro sistema di mappe di geolocalizzazione (p.e.: OpenstreetMap) il percorso fornito dal tracker. Le altre informazioni sono: il codice IMEI (necessario per l’univoca identificazione dell’apparecchio), i codici di allarme (batteria scarica, ecc), la data e l’ora e la validità del dato.

Ecco l’SQL per la creazione delle due tabelle necessarie, in un DB MySQL:

-- DATABASE SCHEMA:
CREATE SCHEMA IF NOT EXISTS `gpsd` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci ;
USE `gpsd` ;
-- -----------------------------------------------------
-- Table `gpsd`.`devices`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `gpsd`.`devices` (
  `id` INT NOT NULL AUTO_INCREMENT ,
  `imeiNumber` VARCHAR(16) NOT NULL ,
  PRIMARY KEY (`id`) )
ENGINE = MyISAM;
-- -----------------------------------------------------
-- Table `gpsd`.`positions`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `gpsd`.`positions` (
  `IDpositions` INT NOT NULL AUTO_INCREMENT ,
  `msg` VARCHAR(255) NULL ,
  `timestamp` INT NOT NULL ,
  `acq_time` DATETIME NULL ,
  `track_time` TIME NULL ,
  `is_valid` TINYINT NOT NULL DEFAULT 0 ,
  `latitude` DOUBLE NULL ,
  `longitude` DOUBLE NULL ,
  `speedKPH` DOUBLE NULL ,
  `course` DOUBLE NULL DEFAULT 0 ,
  `device_id` INT NOT NULL ,
  PRIMARY KEY (`IDpositions`) )
ENGINE = MyISAM;

Veniamo al codice PHP per la realizzazione del socket. Le caratteristiche sviluppate sono:

• Un socket in loop infinito, in ascolto sulla porta impostata
• Un socket preposto alla comunicazione
• Una funzione di decodifica dei dati
• Una funzione per l’aggiornamento delle tabelle del DB
• Una funzione per il controllo della distanza dall’ultimo punto memorizzato
• Funzioni di servizio per la connessione al DB, l’eco dei messaggi, ecc

In particolare, da una analisi preventiva dello stream TCP attraverso TCPDUMP ho osservato che il tracker invia i dati secondo 2 differenti modalità:

1. Single point: Richiede che il server risponda con un determinato messaggio, consente l’invio di particolare impostazioni come p.e. il tempo di polling.
2. Multi point: non richiede alcuna risposta, invia direttamente il datagramma.

Per questo motivo ho realizzato il codice necessario a “capire” automaticamente se il client sta trasmettendo in una delle due modalità (quella multi point, l’ho chiamata “dirty”).

Un’altra osservazione è che quando il tracker è fermo, a causa di una relativa imprecisione del sistema GPS (i satelliti non sono immobili e non sono sempre gli stessi), le coordinate fornite differiscono leggermente. Questo, oltre a fornire un sovraccarico di dati inutili al DB, comporta come output grafico sulla mappa una nuvola indecifrabile di punti (markers). La contromisura è stata di realizzare una funzione che calcola la distanza fra le coordinate del punto appena trasmesso e quelle dell’ultimo punto registrato. Se la distanza è minore di una certa soglia (definita nei settaggi iniziali), il punto non viene registrato nel DB.

Screenshot di OpenGTS

Un’ultima caratteristica da sottolineare è la possibilità di utilizzare il database MySQL dell’applicazione Open Source: OpenGTS, un sistema integrato basato su Java/Tomcat che permette di visualizzare su mappe personalizzabili, i dati delle coordinate fornite da un vasto numero di tracker commerciali.

Nel prossimo post, fornirò l’intero sorgente dello script e la spiegazione dettagliata dei settaggi iniziali.

Prima di tutto una precisazione: questo articolo è riferito esclusivamente agli utenti MySQL.
Se si pensa di utilizzare esclusivamente P4A Framework per la gestione dei dati del nostro database, sarebbe bene in fase di progettazione evitare di usare gli AUTOINCREMENT perché, come detto, non necessari. Nel caso in cui il framework venga utilizzato come ‘backoffice’ per la gestione di dati che vengono alimentati da un form di un sito web, oppure si abbia la necessità di utilizzare una struttura dati pre-esistente con tanto di chiavi primarie ‘AUTOINCREMENT’, potremmo prima o poi trovarci di fronte ad un problema di disallineamento dei valori fra la chiave primaria della tabella e l’id’ della tabella ‘_seq’ associata.

Immaginiamo di avere una tabella “test” con questi due campi:

+----+---------+
| id | name    |
+----+---------+

con ‘id’ chiave primaria, P4A creerà automaticamente una tabella “test_id_seq” con una campo ‘id’ chiave primaria e ‘AUTOINCREMENT’, ed userà i valori forniti da quest’ultima sia per l’inserimento di nuovi record nella tabella “test“, che per altre operazioni sulla chiave primaria. Dunque utilizzando un programma esterno al framework per fare degli inserimenti e volendo mantenere allineate le tabelle principali e le tabelle “_seq” sarà necessario, per ogni “INSERT” nella tabella principale, fare altrettanto nella “_seq”!
Anche utilizzando questo metodo, potrebbe verificarsi prima o poi il problema di un disallineamento, in questo caso ho pensato potesse utile scrivere un metodo della classe “P4A_DB_SOURCE” da utilizzare in extremis, per risistemare le cose.

Per maggiori informazioni sull’utilizzo degli ‘helper’ in P4A suggerisco questo link

Ecco il codice dell’helper, in pratica viene prelevato il valore massimo della chiave primaria ‘AUTOINCREMENT’ della tabella che funge da sorgente dati, quindi viene eliminata la tabella ‘_seq’ associata e successivamente ricostruita con il valore corretto.

 function p4a_db_source_resync_seq($source)

 {
	$table = $source->getTable();
	$pKField = $source->getPk();
	$seqTable =  $table."_".$pKField."_seq";
	$lastId = P4A_DB::singleton()->fetchOne("SELECT MAX($pKField) FROM $table");
	$query = "DROP TABLE IF EXISTS `$seqTable`";
	$resQ1 = P4A_DB::singleton()->query($query);
	$query = "CREATE TABLE `$seqTable` (
	`id` int(11) NOT NULL auto_increment,
	PRIMARY KEY  (`id`)
	) TYPE=MyISAM AUTO_INCREMENT=$lastId";

	$resQ2 = P4A_DB::singleton()->query($query);
	$query = "INSERT INTO `$seqTable` VALUES ($lastId)";
	$resQ3 = P4A_DB::singleton()->query($query);
  return ($resQ1 && $resQ2 && $resQ3); 

 }

Questo codice deve essere inserito in un file con il nome: “p4a_db_source_resync_seq.php” che deve essere posizionato nella directory “libraries” della nostra applicazione P4A.

Ecco infine un po’ di codice di esempio da aggiungere alla nostra ipotetica maschera di manutenzione del db:

class test extends P4A_Base_Mask

{

	public function __construct()

	{

		parent::__construct();

		// DB Source

		$this->build("p4a_db_source", "source")

			->setTable("test")
			->setPk("id")
			->load();
		$this->setSource($this->source);

		// ....

	    $this->build("p4a_button", "btn_resync")

			->setLabel("resync")

			->implement("onclick", $this, "resync_seq_table");

		// ....
	}

	public function resync_seq_table()
	{
		$res = $this->source->resync_seq();
	}

	// ....
}

Conclusioni

Questo metodo dovrebbe essere usato con una certa cautela, e solo come procedura di emergenza. Non consiglio l’utilizzo se c’è la possibilità di accesso in scrittura alla tabella coinvolta da parte di altri utenti.

Riferimenti ed approfondimenti:

• P4A – PHP For Applications – PHP RAD Framework
• P4A – PHP For Applications Wiki – Helpers
• Documentazione: p4a_helpers
• P4A forum: disable the auto increment

Vi è mai capitato di dover generare una lunga serie di password random da inserire in un database? Esistono diversi generatori, anche piuttosto sofisticati e flessibili nelle regole, ma normalmente generano una password alla volta. Ne ho trovati alcuni, che nelle versioni freeware, generano un massimo di 100 password. Ma se abbiamo la necessità di generarne 10000 o più?

Ho pensato di creare una formula per OpenOffice Calc, che possa generare una stringa alfanumerica rispettando certi requisiti di casualità, lunghezza e robustezza.

Il codice che genera la password è tratto da questo articolo, e tradotto in linguaggio Basic per OO.

E’ possibile stabilire la lunghezza della password e la robustezza. Quest’ultima viene definita da un valore minimo di 0 fin ad un massimo di 8

• Robustezza = 0, solo consonanti e vocali minuscole
• Robustezza = 1, consonanti minuscole e maiuscole e vocali minuscole
• Robustezza = 2, consonanti minuscole e maiuscole e vocali minuscole e maiuscole
• Robustezza = 4, consonanti minuscole e maiuscole, numeri e vocali minuscole e maiuscole
• Robustezza = 8, consonanti minuscole e maiuscole, numeri, caratteri speciali e vocali minuscole e maiuscole

Per la compilazione e l’esecuzione della macro in OpenOffice Calc, ho seguito scrupolosamente le indicazioni di questo post sul sito Wiki di OpenOffice.
In pratica si tratta di creare una nuova macro associata ad un foglio di calcolo “Calc”, utilizzando:

Strumenti > Macro > Organizza Macro > OpenOffice.org Basic

Qunidi cliccando sul bottone “Gestisci” e sul tab “Libreria”, è possibile creare una nuova libreria associata al foglio di calcolo, nel nostro caso in calcTestMacros.ods creo (con poca fantasia…) la libreria: AuthorsCalcMacros.

Utilizzando il bottone “Modifica” si apre un IDE per poter scrivere, con l’aiuto del Syntax highlighting, il codice della macro in linguaggio Basic.
La macro in realtà corrisponde all’implementazione, ma non è la funzione che richiameremo all’interno delle celle del foglio di lavoro. Il motivo è da imputarsi al fatto che, a parte la libreria di default denominata “Standard”, tutte le altre non vengono automaticamente caricate all’avvio, dunque si rende necessario creare una funzione che potremmo chiamare “prototipo” nella libreria “Standard”, che a sua volta richiama l’implementazione vera e propria.

Questo è il codice della implementazione inserito nella libreria “AuthorsCalcMacros”:

Function Passwdgen_implementation(ByVal length AS Integer, ByVal strength As Integer)
	Dim vowels As string
	Dim consonants As string
	Dim password As string
	Dim alt As Integer
	Dim i As Integer

	vowels = "aeuy"
	consonants = "bdghjmnpqrstvz"
	If (strength >= 1) Then
		consonants = consonants + "BDGHJLMNPQRSTVWXZ"
	End If
	If (strength >= 2) Then
		vowels = vowels + "AEUY"
	End If
	If (strength >= 4) Then
		consonants = consonants + "23456789"
	End If
	If (strength >= 8) Then
		consonants = consonants + "@#$%"
	End If
	password = ""
	Randomize()
	alt = Int((2 * Rnd) + 1)
	For i = 0 To length-1
		If (alt = 2) Then
			password = password + Mid(consonants, Int((Len(consonants) * Rnd) + 1), 1)
			alt = 1
		Else
			password = password + Mid(vowels, Int((Len(vowels) * Rnd) + 1), 1)
			alt = 2
		End If
	Next i
	Passwdgen_implementation = password
End Function

Questo è il codice del “prototipo” inserito nella libreria “Standard”:

Function Passwdgen(ByVal l as Integer, ByVal s as Integer)
  If NOT BasicLibraries.isLibraryLoaded("AuthorsCalcMacros") Then
    BasicLibraries.LoadLibrary("AuthorsCalcMacros")
  End If
  Passwdgen = Passwdgen_Implementation(l, s)
End Function

Ed ecco infine il risultato della funzione nel foglio di calcolo:

Per permettere l’esecuzione delle macro, è necessario impostare il livello di sicurezza su “Medio”
Questo parametro si imposta da:

Strumenti > Opzioni

Selezionare: “Sicurezza, quindi premere il bottone “Sicurezza delle macro…”

Aprendo il documento, ovviamente è necessario abilitare le macro, come mostrato nella figura qui sotto:

Download:

Il documento ods che contiene la macro è disponibile qui

Riferimenti e Links:

• OpenOffice.org Wiki: Write your own functions (in inglese)
• OpenOffice.org Wiki: Using a macro as a function (in inglese)
• OpenOffice.org Wiki: OpenOffice.org BASIC Programming Guide (in inglese)
• PHP random password generator (in inglese)

albert einstein 1951, foto di Arthur Sasse, nital.it

Albert Einstein, probabilmente il più grande fisico del XX secolo, è anche riconosciuto come l’icona dell’intelligenza. Non si direbbe dall’espressione che assume nella famosa foto del 1951 scattata dal fotografo Arthur Sasse!

In questo mini post, vi propongo il famoso problema di Einstein: si tratta di un enigma da risolvere mediante la logica, rispettando le 15 condizioni imposte.

Ho preparato uno script PHP con un form e una tabella per formalizzare il problema e trovare la soluzione (o le soluzioni…), al termine, vi verrà  comunicato se avete indovinato o no (mi raccomando, non andate subito a guardare la soluzione nei link qui sotto!!). Dimenticavo, un’ultima cosa: Einstein disse che il 98% della popolazione non sarebbe riuscita a risolverlo, la sfida è lanciata…

Problema di Einstein: chi ha il pesce?

Referenza immagine

Fotografo: Arthur Sasse, Bettmann/CORBIS, Fonte: nital.it

Soluzione e links:

• BASE Cinque – Appunti di Matematica ricreativa
• Who has the fish? Un problema di Albert Einstein
• The Real Solution to the Einstein Quiz (in inglese)
• Einstein’s Puzzle (in inglese)

1) I numeri primi sono le basi di tutta l’aritmetica come si può evincere dal Teorema Fondamentale della matematica che recita:“Ogni intero si fattorizza in modo unico come prodotto di numeri primi” e questo li rende indubbiamente affascinanti.
2) I numeri primi molto grandi (ordine di 2¹⁰²⁴), sono alla base del più utilizzato sistema di crittografia: l’RSA questo invece, attira molto gli esperti in sicurezza informatica…!

Come si trovano i numeri primi?

Fu Eratostene di Cirene (276 – 194 a.c.), il primo a proporre un metodo per “setacciare” i numeri primi, detto appunto: crivello di Eratostene. Esistono diversi algoritmi che risolvono il crivello di Eratostene, questo che propongo mi sembra il più efficiente. Supponiamo dunque di voler trovare tutti i numeri primi da 1 a n, l’algoritmo in pseudocodice è il seguente:


for i := 2 to n-1 do
 a[i] := 1
for i := 2 to n-1 do
 if a[i]
  for j := i to (j*i)<n do
   a[i*j] := 0
for i := 2 to n-1 do
 if a[i]
  print i


In pratica si procede da i=2 a n, eliminando tutti i multipli di i
(nella immagine in alto a sinistra è possibile vedere un’animazione del processo). Va detto che ancora oggi, pur non essendo l’algoritmo più efficiente in assoluto, è molto utilizzato quando si lavora su numeri relativamente piccoli, per la sua estrema semplicità.

Il metodo della ruota di fattorizzazione (Wheel Factorization)

Già il crivello di Eratostene permette un notevole incremento di prestazioni rispetto ad un processo di “forza bruta” specialmente se l’algoritmo è opportunamente ottimizzato. Il metodo della ruota risulta ancora più efficiente, e vediamo il perché:
Si scelgono inizialmente come numeri primi di partenza: 2, 3, 5 per ottenere una ruota di lunghezza 30. La lunghezza della ruota è determinta dal prodotto dei numeri primi che decidiamo di utilizzare. Nel nostro caso 2 * 3 * 5 = 30. A questo punto troviamo tutti gli interi che non sono multipli di 2, 3 e 5, il vettore risultate sarà: s[] = {1, 7, 11, 13, 17, 19, 23, 29 }. Abbiamo ottenuto un insieme di numeri che, non sono multipli di 2, 3, 5 e anche se sommati alla lunghezza della ruota o ai suoi multipli (30, 60, 90, ecc), non daranno mai multipli di 2, 3, 5.
Il concetto è più chiaro osservando la figura sotto, le colonne gialle della tabella contengono i soli numeri che andremo a testare, i rimanenenti non sono sicuramente primi, esclusi i numeri di partenza (2, 3, 5). Se provassimo a visualizzare ciascuna riga della tabella come una circonferenza, potremmo immaginare la tabella come una ruota in cui le colonne gialle rappresentano i raggi dove cercare i numeri primi.

Tabella di fattorizzazione

Il codice è tratto dall’articolo: “Prime Number Determination Using Wheel Factorization” di rickoshay originariamente scritto in C#, e da me convertito in ANSI C

#include <stdio.h>
#include <stdlib.h>

unsigned long FirstDivisor(unsigned long candidatePrime);
int isPrime(unsigned long primeSuspect);

unsigned long FirstDivisor(unsigned long candidatePrime)
{
 const int wheelFactor = 30;
 int aSieve30[] = {7, 11, 13, 17, 19, 23, 29, 31};
 int firstPrimes[] = {2, 3, 5}, i;
 unsigned long sqrtmax, pass;

 if (candidatePrime == 1)
 {
    return 0;
 }
 for (i=0;i<sizeof(firstPrimes)/sizeof(int);i++) {
     if (candidatePrime % firstPrimes[i] == 0) {
        return firstPrimes[i];
     }
 }

 sqrtmax  = (unsigned long) sqrt(candidatePrime);
 for (pass=0; pass<sqrtmax; pass+=wheelFactor) {
  for (i=0;i<sizeof(aSieve30)/sizeof(int);i++) {
      if (candidatePrime % (pass + aSieve30[i]) == 0) {
         return pass + aSieve30[i];
      }
  }
 }
 return candidatePrime;
}

int isPrime(unsigned long primeSuspect)
{
   if (primeSuspect == 0) {
      return 0;
   }
   if (FirstDivisor(primeSuspect) == primeSuspect) {
      return 1;
   }
   else {
      return 0;
   }
}

int main(int argc, char *argv[])
{
  unsigned long x, i;

  if (argc == 2) {
     x = strtoul(argv[1],NULL,10);
     if (isPrime(x)) {
        printf("%u e' un numero primo\n",x);
     }
     else {
        printf("%u non e' un numero primo\n",x);
     }
  }
  else {
   printf ("\nUsage: %s n \nWhere n is an integer number to check for primality\n",argv[0]);
  }
  system("PAUSE");
  return 0;
}

Download

Il download dell’applicazione (compilata per Win32) è disponibile qui, in formato compresso zip. Sono compresi i sorgenti e i files di progetto per il compilatore DevC++ (ver.: 4.9.9.2). Per l’utilizzo è sufficiente lanciare il programma da una console DOS e passare come parametro il numero da testare.

Conclusioni:

Adottare il metodo della Wheel Factorization per testare la primalità di un numero, consente un incremento di performance pari a (1 – 8 /30) * 100 = 73% con una ruota di dimensioni 30. Le prestazioni possono crescere aumentando le dimensioni della ruota, specialmente quando si ragiona con numeri abbastanza grandi. Il codice proposto utilizza al massimo numeri di 4 byte (unsigned long int = 4,294,967,295) e le performance rimangono accettabili ricompilando per numeri di 8 byte (unsigned long long = 18,446,744,073,709,551,615). In questo caso però sarebbe consigliabile utilizzare una ruota prodotta dai primi 8 numeri primi, come suggerito nell’articolo da cui ho tratto lo spunto per il codice.

Riferimenti ed approfondimenti:

• Wikipedia: Numero primo
• Prime Number Determination Using Wheel Factorization (in inglese)
• A Languasco e A. Perelli: Numeri primi e crittografia (pdf)
• Il Crivello di Eratostene (pdf)
• Fun With Prime Numbers (in inglese)

Il triangolo di Tartaglia

Tutti noi ricordiamo, dai tempi delle superiori, la piramide di numeri che compongono il famoso triangolo di Tartaglia, e lo ricordiamo soprattutto in relazione allo studio delle potenze di un binomio.

Ogni riga, riporta i coefficienti dell’espansione del binomio con esponente uguale al numero di riga – 1 (iniziando a contare dal vertice della piramide) Così ad esempio, per esponente 3 avremo:
(a + b)³ = 1a³ + 3a²b + 3ab² + 1b³

La successione di Fibonacci

La successione dei numeri di Fibonacci è nota soprattutto per la particolarità che il rapporto tra un numero e quello precedente, man mano che si procede nella successione, tende alla sezione aurea La successione fu trovata da Fibonacci, rispondendo al quesito: “Supponiamo di avere una coppia di conigli, che dopo un mese è in grado di generare una seconda coppia di conigli, quante coppie avremo in un anno?” (Ammesso che ogni coppia generi sempre e solo una coppia al mese e nessuno muoia…). Il procedimento è molto semplice: ogni numero, ad eccezione dei primi due (1, 1), è la somma dei due che lo precedono. Quindi:
F(12) = 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144

Dove si incontrano Tartaglia e Fibonacci?

Per capire il punto di contatto fra i due, è necessario modificare la forma del triangolo di Tartaglia, disponendo i numeri nelle celle che costituiscono un triangolo rettangolo piuttosto che isoscele, in questo modo:

I numeri che costituiscono le diagonali ascendenti di questa matrice triangolare, sommati fra loro, generano la successione di Fibonacci.

Ecco dunque una classe PHP che calcola i valori del triangolo di Tartaglia e poi estrae dalle diagonali ascendenti i numeri della successione di Fibonacci.

class tartfibo
{
  var $tartaglia;
  var $fibonacci;
  var $max;

  function tartfibo($max=10)
  {
    $this->max = $max;
    $this->tartaglia = array();
    $this->fibonacci = array();
    $this->makeTartaglia();
    $this->makeFibonacci();
  }

  function makeTartaglia ()
  {
    $this->tartaglia[1][1] = 1;
    $this->tartaglia[2][1] = 1;
    $this->tartaglia[2][2] = 1;
    for($row=3; $row<=$this->max; ++$row) {
      $this->tartaglia[$row][1] = 1;
      for ($col=2; $col<$row; ++$col) {
        $this->tartaglia[$row][$col] = $this->tartaglia[$row-1][$col-1]
                                + $this->tartaglia[$row-1][$col];
      }
      $this->tartaglia[$row][$row] = 1;
    }
  }

  function makeFibonacci ()
  {
    for ($d=1; $d<=$this->max; ++$d) {
      $t = 0;
      for($el=1; $el<=($d+1)/2; ++$el) {
        $t += $this->tartaglia[$d+1-$el][$el];
      }
      $this->fibonacci[$d] = $t;
    }
  }
}

Demo:

In questa pagina è visibile una demo della classe per n=15.

Download

Il download della classe è disponibile qui.

Conclusioni:

Il triangolo di Tartaglia racchiude nei suoi numeri, diversi piccoli segreti e non è solo un metodo per calcolare i coefficienti binomiali. Provate, per esempio a sommare i numeri di ciascuna riga, partendo dall’alto, danno le potenze di 2. Esistono persino dei frattali! Infine, due grandi matematici, Newton e Pascal hanno rielaborato il suo triangolo per lo studio del calcolo combinatorio. Anche i numeri di Fibonacci, oltre alla relazione con la sezione aurea, hanno implicazioni interessanti, sia con la disposizione geometrica di molte strutture naturali (piante soprattutto) che con l’informatica, per esempio: Fibonacci heap

Riferimenti ed approfondimenti:

• Le magie del triangolo di tartaglia (pdf)
• Le Proprietà del triangolo di Tartaglia e la successione di Fibonacci (pdf)
• Vialattea.net: Fibonacci
• Progetto PolyMath: Dal Triangolo di Tartaglia ai frattali
• Archweb: La serie di Fibonacci

Screenshot di Gestione fatture

Maschere:

• Gestione azienda: in questa maschera è possibile definire la ragione sociale, i dati anagrafici e il logo dell’azienda, definire l’utente e la password e impostare il tipo di fatturazione: IVA fissa, IVA variabile, ritenuta d’acconto, contributo INPS (queste ultime due opzioni sono possibili solo con IVA fissa).
• Gestione clienti: in questa maschera vengono immessi i dati anagrafici dei clienti.
• Fatture: è la maschera principale per creare e modificare le fatture. E’ divisa in due parti selezionabili attraverso delle ‘linguette’ come per gli schedari. La sezione ‘fatture’ permette di inserire una nuova fattura vuota, indicando la data, il numero, il cliente e la tipologia di pagamento. E’ anche possibile indicare se la fattura è stata pagata attraverso un flag ed inserire eventuali note. Il numero viene suggerito automaticamente seguendo la progressione dell’anno in corso, è però possibile immetterlo manualmente, in questo caso esiste un controllo per evitare duplicati.
  La sezione ‘Dettaglio fattura’ serve per inserire la lista di prestazioni o prodotti da fatturare. E’ possibile raggruppare una lista attraverso il campo ‘sezione’. Gli altri campi da riempire sono la descrizione, la quantità il prezzo e l’IVA (se non si è scelta la modalità IVA fissa). In fondo alla maschera vengono riportati i valori del totale imponibile, totale IVA e totale fattura. (totale ritenuta d’acconto e contributo INPS, solo se lo si è attivato nella Gestione azienda).
  Attraverso il pulsante di stampa, viene generato un documento pdf stampabile con la fattura impaginata in una o più pagine (in questo caso numerate) e la dicitura del destinatario allineata con l’apertura delle buste a ‘finestra’ standard.
• Lista fatture: attraverso questo report è possibile filtrare le fatture di un certo periodo, visualizzare e stampare su pdf l’elenco e i totali dell’imponibile, delle fatture e i totali di quelle pagate e quelle no.
• Tipo pagamenti: E’ possibile inserire le varie modalità di pagamento (assegno, bonifico, riba ecc.)
• Unità di misura: E’ possibile inserire le unità di misura (ore, pezzi, kg, ecc.)

Alcune note sull’utilizzo:
Per aggiungere un nuovo record, è sempre necessario utilizzare il pulsante ‘Inserisci un nuovo elemento’, e una volta compilati i campi, premere il pulsante ‘Conferma e salva’. Nel caso di inserimento di una nuova fattura, dopo aver salvato e prima di inserire la lista delle prestazioni, è necessario selezionare con il puntatore (triangolino nero) la fattura appena creata. Per creare dei blocchi di prestazioni, inserire una dicitura nel campo ‘sezione’, in questo modo, i nuovi record creati con la stessa dicitura nel campo sezione, saranno raggruppati e ordinati alfabeticamente in fattura.

Installazione

Deve innazitutto essere installato il framework P4A versione 3.2.x (dettagli per il download e l’installazione). Poi è sufficiente scompattare l’archivio compresso nella direcory ‘applications’ che si trova sotto la directory ‘P4A’, caricare il dump .sql del database che si trova nella directory ‘_private’ in un server ‘MySQL’ e impostare i parametri per la connessione nel file ‘index.php’ (Nella maggioranza dei casi questo potrebbe non essere necessario). Chi utilizza linux, deve ricordarsi di dare i permessi di scrittura alla directory ‘uploads’ e alle sue subdirectories. Se il server web è installato localmente, per accedere all’applicazione digitare la url ‘http://localhost/p4a/applications/gestionefatture/’
Infine, volendo personalizzare l’aspetto grafico dell’applicazione, suggerisco questo articolo.

Il nome utente e la password per l’accesso iniziale sono: user = ‘utente’ e password = ‘utente’

Demo:

La demo è temporaneamente sospesa.

Download

• gestione fatture in formato compresso zip
• gestione fatture in formato compresso tar bz2

Licenza

La licenza applicata è la LGPLv3

Conclusioni:

Considerando che l’applicazione viene fornita gratuitamente, non garantisco nessun supporto ufficiale e non mi assumo alcuna responsabilità per eventuali anomalie di funzionamento. Sono comunque disponibile a correggere gli errori che mi segnalerete e a valutare eventuali upgrade, compatibilmente con il tempo richiesto.

Riferimenti ed approfondimenti:

• P4A3 framework: porting del codice dell’applicazione per la gestione delle fatture
• P4A – PHP for applications
• Fattureopen fatture open source web based

• la distanza tra due punti che non coincidono deve essere positiva;
• la distanza tra due punti che coincidono è pari a 0;
• la distanza tra due punti deve essere simmetrica (d AB = d BA),

e non contravvengono la proprietà della disuguaglianza triangolare, cioè dati tre punti A, B e C deve essere verificata la condizione che:
d AB < d AC + d BC
riassumendo, si può dire che sono quelle che seguono la metrica pitagorica.

Fatta questa doverosa premessa, passiamo ad analizzare le formule delle distanze metriche utilizzate
nella classe PHP.

Distanze Euclidee

E’ senza dubbio il tipo di distanza più diffuso. La formula per il calcolo deriva dalla formula della distanza fra 2 punti in un piano cartesiano e può essere espressa come:

in cui x_ik e x_jk sono le misure in posizione i e j rispettivamente della k-esima di n variabili.

Distanze city-block (Manhattan)

Viene anche detta distanza assoluta o della metrica del taxi. La sua formula è:

La particolarità di questa formula sta nel fatto che, considerando la distanza euclidea fra 2 punti A e C di un triangolo ABC, e che questa distanza può essere espressa come la radice quadrata della somma dei quadrati costruiti sui cateti del triangolo ABC, la distanza di city-block è la somma dei cateti di questo triangolo. Il concetto risulta forse più chiaro osservando la figura qui sotto.

Non a caso, il nome Manhattan deriva proprio dalla particolare disposizione delle strade del famoso quartiere di New York, che si incrociano ad angolo retto, formando una sorta di scacchiera. In effetti questo tipo di distanza, ben si presta a rappresentare il percorso reale fra due punti che si trovano in prossimità degli angoli opposti di un palazzo (…o grattacielo!)

Distanze di Minkowski

Rappresenta la forma più generalizzata di distanza metrica. La sua formula è:

Si dice di ordine p, e in particolare quando p=1, coincide con la distanza city-block,
e quando p=2, coincide con la distanza euclidea, come si evince dalla formula. Per p -> infinito coincide con la distanza di Lagrange o di Chebychev.

La classe PHP che ho preparato permette di calcolare, scegliendo una delle distanze illustrate sopra, una matrice triangolare (nella quale la diagonale assume valori = 0) di confronto fra tutti i campioni passati in input. La matrice dati da passare come parametro al costruttore deve avere questo formato:

$dataTest = array (
                "sample01" => array(82.897,488,0.6381,8.576),
                "sample02" => array(37.04,512,0.7935,7.9293),
                "sample03" => array(86.571,617,0.1518,0.9705),
                "sample04" => array(76.038,876,0.0883,5.5867),
                "sample05" => array(67.726,687,0.9145,9.2478),
                "sample06" => array(34.407,979,0.8148,3.8348),
                "sample07" => array(52.258,462,0.7132,3.716),
                "sample08" => array(75.141,652,0.8453,8.3466),
                "sample09" => array(17.546,322,0.0483,1.5812),
                "sample10" => array(35.786,502,0.6899,3.1447)
                );

Ed ecco dunque il codice PHP della classe:

class DistanceMatrix
{
 var $dataArray = null;
 var $dataSize = 0;
 var $dataVectSize = 0;

 function DistanceMatrix($data)
 {
  $this->dataArray = array();
  $this->dataArray = $data;
  $this->checkData();
 }

 function checkData()
 {
  $this->dataSize = count($this->dataArray);
  if($this->dataSize < 2){
   die("Cannot proceed: only one sample, or missing data");
  }
  reset ($this->dataArray);
  $this->dataVectSize = count(current($this->dataArray));
  foreach ($this->dataArray as $key => $vectData){
   $vectSize = count($vectData);
   if ($vectSize != $this->dataVectSize){
    die("Cannot proceed: different size vectors!");
   }
  }
 }

 function euclidean ($vect1,$vect2)
 {
  $qdist = 0.0;
  for($i=0;$i<$this->dataVectSize;$i++){
   $qdist += pow($vect1[$i]-$vect2[$i],2);
  }
  return sqrt($qdist);
 }

 function manhattan ($vect1,$vect2)
 {
  $dist = 0.0;
  for($i=0;$i<$this->dataVectSize;$i++){
   $dist += abs($vect1[$i]-$vect2[$i]);
  }
  return $dist;
 }

 function minkowski($vect1,$vect2,$exp) {
  $edist = 0.0;
  for($i=0; $i<$this->dataVectSize; $i++){
   $edist += pow(abs($vect1[$i]-$vect2[$i]), $exp);
  }
  return pow($edist, 1/$exp);
 }

 function printData($distType,$exp=1)
 {
  if (!method_exists($this,$distType)) {
   die ("Sorry, can't find $distType method!");
  }
  echo ("<h1>Matrix of $distType distances </h1>\n");
  echo ("<table class='datatable' summary='Results'>\n");
  echo ("<thead><tr>");
  echo ("<th> </th>");
  foreach ($this->dataArray as $key=>$data){
   echo ("<th>".$key."</th>");
  }
  echo ("</tr></thead><tbody>\n");
  foreach ($this->dataArray as $keyA=>$dataA){
   echo ("<tr>");
   echo ("<td><strong>".$keyA."</strong></td>");
   foreach ($this->dataArray as $keyB=>$dataB){
    if ($distType=="minkowski"){
     printf("<td>%.4f</td>",$this->minkowski($dataA,$dataB,$exp));
    }
    else{
     printf("<td>%.4f</td>",$this->$distType($dataA,$dataB));
    }
   }
   echo ("</tr>\n");
  }
  echo ("</tbody></table>\n");
 }
}

Demo:

In questa pagina è visibile una demo della classe con dei campioni ipotetici e delle variabili di test.

Download

Il download della classe completa del file di esempio è disponibile qui.

Conclusioni:

La naturale conclusione della produzione di una matrice di distanze è l’elaborazione di una cluster analisys. Questo metodo permette di leggere visivamente i raggruppamenti dovuti alle similarità o diseguaglianze indicate dalle distanze calcolate. Tali raggruppamenti potranno essere espressi in forma gerarchica. Un software distribuito con licenza GNU che permette queste elaborazioni, e che suggerisco
è Cluster 3.0, disponibile per Linux, Windows e MacOSX.

Riferimenti ed approfondimenti:

• Wikipedia: Distanza euclidea
• Wikipedia: Distanza (matematica)
• Wikipedia: Geometria del taxi
• G. Massimi, La distanza, WP Web 2001 (pdf)
• Alfonso Iodice D’Enza – Universita degli studi di Cassino – Analisi dei dati e Cluster Analysis (pdf)