display::hd44780( RS, E, D0, D1, D2, D3 );
display::hd44780( RS, E, D0, D1, D2, D3, D4, D5, D6, D7 );

#include <rpi-hw.hpp>
#include <rpi-hw/display/hd44780.hpp>

// Use the Rpi-hw namespace
using namespace rpihw;

int
main( int argc, char *args[] ) {

	// Create the display controller
	display::hd44780 dev( 14, 18, 4, 17, 21, 22 );

	// Initialize the 20x4 display
	dev.init( 20, 4 );

	// Move the cursor position
	dev.move( 3, 0 );

	// Write the string at cursor position
	dev.write( "Hello World!" );

	return 0;
}

keypad::matrix( /* Column pins */ { COL0, COL1, COL2, ... }, /* Rows pins */ { ROW0, ROW1, ROW2, ... } )

/* 
    Title --- 12keys0.cpp [examples]

    Copyright (C) 2012 Giacomo Trudu - wicker25[at]gmail[dot]com

    This file is part of Rpi-hw.

    Rpi-hw is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation version 3 of the License.

    Rpi-hw is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Rpi-hw. If not, see <http://www.gnu.org/licenses/>.
*/


#include <iostream>

#include <rpi-hw.hpp>
#include <rpi-hw/keypad/time.hpp>
#include <rpi-hw/keypad/matrix.hpp>

// Use the Rpi-hw namespace
using namespace rpihw;

int
main( int argc, char *args[] ) {

   // Matrix keypad controller
   keypad::matrix dev( { 21, 10, 4 }, { 22, 14, 15, 17 } );

   // Main loop
   for ( ;; ) {

      // Check some keys state
      if ( dev.pressed(0) )
         std::cout << "You have pressed button 0!\n";

      if ( dev.released(2) )
         std::cout << "You have released button 2!\n";

      if ( dev.pressed(1) && dev.pressed(4) )
         std::cout << "You have pressed buttons 1 and 4!\n";

      // Wait some time
      time::msleep( 100 );
   }

   return 0;
}

/* 
    Title --- s7seg.cpp [examples]

    Copyright (C) 2012 Giacomo Trudu - wicker25[at]gmail[dot]com

    This file is part of Rpi-hw.

    Rpi-hw is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation version 3 of the License.

    Rpi-hw is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Rpi-hw. If not, see <http://www.gnu.org/licenses/>.
*/


#include <iostream>

#include <rpi-hw.hpp>
#include <rpi-hw/display/time.hpp>
#include <rpi-hw/display/s7seg.hpp>

using namespace rpihw;

int
main( int argc, char *args[] ) {

   // Gestore del display a 7 segmenti
   display::s7seg disp( 1, 4, 18, 15, 14, 0, 17 );

   // Iteratore
   size_t i = 0;

   // Ciclo principale
   while ( 1 ) {

      // Imposto la nuova cifra
      disp.set( i++ );

      // Aspetto un po' di tempo
      time::msleep( 500 );
   }

   return 0;
}

/* 
    Title --- m7seg.cpp [examples]

    Copyright (C) 2012 Giacomo Trudu - wicker25[at]gmail[dot]com

    This file is part of Rpi-hw.

    Rpi-hw is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation version 3 of the License.

    Rpi-hw is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Rpi-hw. If not, see <http://www.gnu.org/licenses/>.
*/


#include <iostream>

#include <rpi-hw.hpp>
#include <rpi-hw/time.hpp>
#include <rpi-hw/iface/decoder-out.hpp>
#include <rpi-hw/display/m7seg.hpp>

using namespace rpihw;

int
main( int argc, char *args[] ) {

   // Gestore del display a 7 segmenti
   display::m7seg disp( 1, 4, 18, 15, 14, 0, 17, 23 );

   // Creo l'interfaccia per l'abilitazione dei display
   iface::decoderOut enabler( { 21, 22 } );

   // Imposto il numero del display e il relativo abilitatore
   disp.setDisplays( 2, enabler );

   // Imposto la frequenza di aggiornamento del display (in Hz)
   disp.setFreq( 100.0 );

   // Imposta la formattazione
   disp.format( 1, false );


   // Iteratore
   float i = 0.0;

   // Ciclo principale
   while ( 1 ) {

      // Imposto la nuova cifra
      disp.set( i );

      // Incremento il numero nel display
      i += 0.1;

      // Aspetto un po' di tempo
      time::msleep( 500 );
   }

   return 0;
}

#!/bin/bash
#=====================================================================================
#
#          Title: cerberus
#         Author: Giacomo Trudu aka `Wicker25` - wicker25 [at] gmail [dot] com
#           Site: http://www.hackyourmind.org/
#        License: GNU Lesser General Public License v3 (LGPL3)
#        Version: 0.6.3
#
#  = Version 0.6.3 =
#   + improved analysis resuming
#
#  = Version 0.6.2 =
#   + changed speed unit to pwds/s
#
#  = Version 0.6.1 =
#   + fixed spinner animation
#
#  = Version 0.6 =
#   + improved statistics output
#
#  = Version 0.5.4 =
#   + improved performance with large dictionary files
#
#=====================================================================================

# Versione
name='cerberus';
version='0.6.3';

# Informazioni sull'attacco
mode='incremental';
mode_opt='';
mode_format='';
mode_resume=false;
mode_length=6;
mode_jobs=( 1 1 );
decrypt='';

# Decrittatore
decrypt_7z='7z t -y -p%s %s';
decrypt_rar='unrar t -y -p%s %s';
decrypt_zip='7z t -y -p%s %s';

# Risposta affermativa del decrittatore
password_found="Everything is Ok|All Ok";

# Alfabeto
spinner_chars=( '\' '|' '/' '-' );
spinner=0;

# Unità del tempo
time_factors=( 31536000 2628000 604800 86400 3600 60 1 );
time_names=( 'years' 'months' 'weeks' 'days' 'hours' 'minutes' 'seconds' );

# Stato dell'analisi (none, found or interrupted)
status='none';

# Contatore delle password analizzate
count=0;

# Parametri usati per le statistiche
stats_speed='-';
stats_eta='-';
last_count=0;
last_time=`date +%s`;


# Aggiorna le statistiche dell'analisi
function update_stats {

   # Calcolo la velocità di analisi
   speed=`echo "scale = 3; ( $count - $last_count ) / ( $time - $last_time )" | bc`;

   # Converto la velocità in passwords/minuto
   stats_speed="${speed/.*} pwds/s";

   # Calcolo il tempo rimanente alla fine dell'analisi
   eta=`echo "scale = 3; ( $combinations - $count ) / $speed" | bc`;
   stats_eta='';

   # Costruisco la stringa del tempo trascorso
   elapsed="${eta/.*}";

   let 'precision = 2';

   for k in `seq 0 6`;
   do
      let 'value = elapsed / time_factors[k]';

      if [ $value -ne 0 ];
      then
         if [ $value -gt 1 ]; 
         then
            stats_eta="$stats_eta$value ${time_names[$k]} ";
         else
            stats_eta="$stats_eta$value ${time_names[$k]%?} ";
         fi;

         if [ $precision -gt 1 ];
         then
            let 'precision--';
         else
            break;
         fi;
      fi;

      let 'elapsed %= time_factors[k]';
   done;

   if [ -n "$stats_eta" ];
   then
      stats_eta="${stats_eta%?}";
   else
      stats_eta='-';
   fi;

   let 'last_count = count';
}


# Prova la password sull'obiettivo
function test_password {

   # Incremento il contatore delle password testate
   let 'count++';

   # Formatto la password
   if [ -n "$mode_format" ];
   then
      password=`echo "$password" | sed -e "$mode_format"`;
   fi;

   # Controllo che siano passati almeno 3 secondi
   time=`date +%s`;

   if [ `expr $time - $last_time` -ge 1 ];
   then
      # Aggiorna le statistiche dell'analisi
      update_stats;

      # Controllo se un altro processo ha già trovato la password
      if [ -s "$meta_password" ];
      then
         password=`cat "$meta_password"`;
         status='found';
      fi;

      # Memorizzo i progressi dell'analisi
      echo -e "$mode\n$mode_opt\n$mode_length\n$mode_format\n$i $to" > "$meta";

      # Memorizzo l'istante corrente per il prossimo controllo
      let 'last_time = time';

      # Scelgo il carattere dello spinner
      spinner_current="${spinner_chars[`expr $spinner % 4`]}";

      # Stampo i progressi dell'analisi
      printf "\r\033[K%s Checking '%s'... (%d checked, speed %s, eta %s)" "$spinner_current" "$password" $count "$stats_speed" "$stats_eta";

      # Modifico il carattere dello spinner
      let 'spinner++';
   fi;

   # Provo a decrittare l'archivio usando la password corrente
   printf -v password "%q" $password;

   if `printf "$decrypt" "$password" "$target"` 2> /dev/null | grep -Eiq "$password_found";
   then
      echo "$password" > "$meta_password";
      status='found';
   fi;
}


# Cattura il segnale di uscita
function control_attack {

   read -s -n1 -t0.001 key;

   if [ "$key" == $'\x1b' ];
   then
      status='interrupted';
   fi;
}


# Attacco forza bruta
function bruteforce_attack {

   # Costruisco l'alfabeto per l'attacco
   if [ -z $mode_opt ];
   then
      mode_opt='alnum';
   fi;

   case $mode_opt in
      num)      symbols=( {0..9} );;
      alpha)    symbols=( {a..z} );;
      alcase)   symbols=( {a..z} {A..Z} );;
      alpun)    symbols=( {a..z} ' ' '(' ')' '.' ';' ':' '!' '?' '/' '\' );;
      alcpun)   symbols=( {a..z} {A..Z} ' ' '(' ')' '.' ';' ':' '!' '?' '/' '\' );;
      alnum)    symbols=( {a..z} {0..9} );;
      alcnum)   symbols=( {a..z} {A..Z} {0..9} );;
      pun)      symbols=( ' ' '(' ')' '.' ';' ':' '!' '?' '/' '\' );;
      all)      symbols=( {a..z} {A..Z} {0..9} ' ' '(' ')' '.' ';' ':' '!' '?' '/' '\'  );;
   esac;

   symbols_l=${#symbols[*]};

   # Calcolo il numero delle combinazioni da provare
   if [ $mode == 'incremental' ];
   then
      let 'combinations = 0';

      for i in `seq 1 $mode_length`;
      do
         let 'combinations += symbols_l ** i';
      done;
   else
      let 'combinations = symbols_l ** mode_length';
   fi;

   # Carico eventuali configurazioni preesistenti
   if [ $mode_resume == false ];
   then
      total=`echo "scale = 2; $combinations / ${mode_jobs[1]} + 1" | bc`;
      total=${total/.*};

      let 'from += ( mode_jobs[0] - 1 ) * total';
      let 'to = from + total';
   fi;

   # Aggiusto i valori in modo da non uscire dalle combinazioni previste
   if [ $from -lt 0 ];
   then
      let 'from = 0';
   fi;

   if [ $to -gt $combinations ];
   then
      let 'to = combinations';
   fi;

   # Calcolo le combinazioni restanti
   let 'combinations = to - from';

   # Informazioni sull'attacco
   echo "Combinations: $combinations (from `expr $from + 1` to $to)";

   # Ciclo principale
   let 'i = from';

   while [ $i -lt $to ];
   do
      # Catturo il segnale di uscita
      control_attack;

      # Controllo se la ricerca è terminata
      if [ $status != 'none' ];
      then
         break;
      fi;

      # Se è stata richiesta, applico la ricerca incrementale
      let 'current = i';

      if [ $mode == 'incremental' ];
      then
         for j in `seq 1 $mode_length`;
         do
            let 'val = symbols_l ** j';

            if [ $current -ge $val ];
            then
               let 'current -= val';
            else
               break;
            fi;
         done;

         let 'password_l = j - 1';
      else
         let 'password_l = mode_length - 1';
      fi;

      # Costruisco la nuova password
      password='';

      for j in `seq 0 $password_l`;
      do
         let 'val = current % symbols_l';

         if [ $val -ge 0 ];
         then
            printf -v password "%s%s" "${symbols[$val]}" "$password";
         fi;

         let 'current /= symbols_l';

         if [ $current -lt 0 ];
         then
            break
         fi;
      done;

      # Provo la nuova password sull'obiettivo
      test_password;

      # Passo alla prossima password
      let 'i++';
   done;
}


# Attacco con dizionario
function dictionary_attack {

   # Leggo il numero delle parole presenti nel dizionario
   combinations=`wc -l "$mode_opt" | awk '{ print $1 }'`;

   # Carico eventuali configurazioni preesistenti
   if [ $mode_resume == false ];
   then
      total=`echo "scale = 2; $combinations / ${mode_jobs[1]} + 1" | bc`;
      total=${total/.*};

      let 'from = ( mode_jobs[0] - 1 ) * total';
      let 'to = from + total';
   fi;

   # Aggiusto i valori in modo da non uscire dal dizionario
   if [ $from -lt 0 ];
   then
      let 'from = 0';
   fi;

   if [ $to -gt $combinations ];
   then
      let 'to = combinations';
   fi;

   # Calcolo le combinazioni restanti
   let 'combinations = to - from';

   # Informazioni sull'attacco
   echo "Combinations: $combinations (from `expr $from + 1` to $to)";

   # Provo le parole contenute nel dizionario
   exec 3< "$mode_opt";

   let 'i = 0';

   while read -u 3 line;
   do
      # Catturo il segnale di uscita
      control_attack;

      # Controllo se la ricerca è terminata
      if [ $status != 'none' ];
      then
         break;
      fi;

      # Ignoro le password già testate
      if [ $i -ge $from ];
      then
         # Provo la nuova password sull'obiettivo
         password="`echo $line | sed 's/[\n\r]//g'`";

         test_password;
      fi;

      let 'i++';
   done;
}


# Processo i parametri
usage="Usage: `basename $0` [-b <num|...|all>|-i <num|...|all>|-d <file>] [-l <length>] [-j <current,total>] [-p <format>] [-f <type>] [-r] [-h] -t <target>";

if [ $# -eq 0 ];
then
   echo $usage;
   exit 1;
fi;

while getopts 'b:i:d:f:l:j:p:t:rvh' opt;
do
   case $opt in

      b) mode='bruteforce';

         if [[ ! "$OPTARG" =~ ^(num|alpha|alcase|alpun|alcpun|alnum|alcnum|pun|all)$ ]];
         then
            echo "Invalid brute force attack!";
            echo $usage;
            exit 1;
         fi;

         mode_opt="$OPTARG";;

      i) mode='incremental';

         if [[ ! "$OPTARG" =~ ^(num|alpha|alcase|alpun|alcpun|alnum|alcnum|pun|all)$ ]];
         then
            echo "Invalid incremental brute force attack!";
            echo $usage;
            exit 1;
         fi;

         mode_opt="$OPTARG";;

      d) mode='dictionary';

         if [ ! -r "$OPTARG" ];
         then
            echo "Invalid dictionary file!";
            echo $usage;
            exit 1;
         fi;

         directory=`dirname $OPTARG`;
         name=`basename $OPTARG`;
         mode_opt="`cd "$PWD"; cd "$directory"; pwd`/$name";;

      f) case $OPTARG in
            7z)    decrypt=$decrypt_7z;;
            rar)   decrypt=$decrypt_rar;;
            zip)   decrypt=$decrypt_zip;;
         esac;;

      r) mode_resume=true;;

      l) if [[ ! "$OPTARG" =~ ^[0-9]*$ ]];
         then
            echo "Invalid length!";
            echo $usage;
            exit 1;
         fi;

         mode_length="$OPTARG";;

      p) mode_format="$OPTARG";;

      j) if [[ ! "$OPTARG" =~ ^([1-9]+),([1-9]+)$ ]] || [ ${BASH_REMATCH[1]} -gt ${BASH_REMATCH[2]} ];
         then
            echo "Invalid process splitting!";
            echo $usage;
            exit 1;
         fi;

         mode_jobs=( "${BASH_REMATCH[1]}" "${BASH_REMATCH[2]}" );;

      t) target="$OPTARG";;

      v) echo "$name v$version";
         exit 0;;

      h|?)  echo -e "$usage\n";
            echo '  -b <num|alpha|alcase|alpun|alcpun|alnum|alcnum|pun|all>     Brute force attack';
            echo '  -i <num|alpha|alcase|alpun|alcpun|alnum|alcnum|pun|all>     Incremental brute force attack';
            echo '  -d <file>                                                   Dictionary attack';
            echo '  -f <7z|rar|zip>                                             Target format';
            echo '  -l                                                          Length of passwords';
            echo '  -p <format>                                                 Format passwords';
            echo '  -j <current,total>                                          Split process';
            echo '  -r                                                          Resume previous attack';
            echo '  -v                                                          Print version';
            echo '  -h                                                          Print this message';
            echo;
            exit 0;;
   esac;
done;

# Controllo la validità dell'obiettivo
if [ -r "$target" ];
then
   # Costruisco i percorsi ai file d'appoggio
   meta="$target.meta${mode_jobs[0]}";
   meta_password="$target.password";

   # Controllo se la password è già stata trovata
   if [ -s "$meta_password" ];
   then
      password=`cat "$meta_password"`;
      echo "Password already found: $password";
      exit 1;
   fi;

   # Se non è stato scelto il decrittatore imposto quello più adatto al file
   if [ -z "$decrypt" ];
   then
      format=`file -ib "$target"`;

      if [[ "$format" =~ ^application/.*7z ]];
      then
         decrypt=$decrypt_7z;

      elif [[ "$format" =~ ^application/.*rar ]]
      then
         decrypt=$decrypt_rar;

      elif [[ "$format" =~ ^application/.*zip ]]
      then
         decrypt=$decrypt_zip;
      else
         echo "Unknown target format!";
         exit 1;
      fi;
   fi;

   # Continuo l'attacco iniziato in precedenza
   if [ $mode_resume == true ];
   then
      echo "Resuming...";

      if [ -r "$meta" ];
      then
         mode=`head -1 "$meta"`;
         mode_opt=`sed -n "2p" "$meta"`;
         mode_length=`sed -n "3p" "$meta"`;
         mode_format=`sed -n "4p" "$meta"`;
         from=`tail -1 "$meta" | awk '{ print $1 }'`;
         to=`tail -1 "$meta" | awk '{ print $2 }'`;
      else
         echo "Invalid meta file!";
         exit 1;
      fi;
   fi;

   # Inizio l'attacco sull'obiettivo
   case $mode in
      bruteforce|incremental)   bruteforce_attack;;
      dictionary)               dictionary_attack;;
   esac;

   # Memorizzo i progressi dell'analisi
   echo -e "$mode\n$mode_opt\n$mode_length\n$mode_format\n$i $to" > "$meta";

   # Mostro all'utente i risultati dell'elaborazione
   case $status in
      none)          echo -e "\nPassword not found! ($count checked)";;
      found)         echo -e "\nPassword found: '$password' ($count checked)";;
      interrupted)   echo -e "\nInterrupted. ($count checked)";;
   esac;
else
   echo "Invalid target!";
fi;

#!/bin/bash
target='archivio.7z';
cores=`grep -c ^processor /proc/cpuinfo`;
console='urxvt -e';

for i in `seq 1 $cores`;
do
   taskset -c `expr $i - 1` $console cerberus -j $i,$cores -b num -l 2 -t "$target" &
done;

for job in `jobs -p`;
do
   wait $job;
done;

if [ -r "$target.password" ];
then
   echo -e "\nPassword: `cat "$target.password"`";
fi;

#!/bin/bash
target='archivio.7z';

echo "- Single -";

start_time=`date +%s`;
cerberus -b num -l 2 -t "$target";
finish_time=`date +%s`;

echo -e "Time duration: `expr $finish_time - $start_time` secs.\n";

echo "- Multi-core -";

cores=`grep -c ^processor /proc/cpuinfo`;
console='urxvt -e';

start_time=`date +%s`;

for i in `seq 1 $cores`;
do
   taskset -c `expr $i - 1` $console cerberus -j $i,$cores -b num -l 2 -t "$target" &
done;

for job in `jobs -p`;
do
   wait $job;
done;

finish_time=`date +%s`;

echo -e "Time duration: `expr $finish_time - $start_time` secs.";

#!/bin/bash
for target in `ls -1 *.rar`;
do
   echo "Analizzo '$target'...";
   cerberus -b num -l 2 -t "$target";
   echo;
done;

/** Modulo per la gestione di un veicolo **/
( function ( BASE, NAME ) {

BASE[ NAME ] = ( function () {

   /** PRIVATO **/
   var fuel = 0;

   /** PUBBLICO **/
   var setFuel = function ( value ) { fuel = value; };
   var getFuel = function () { return fuel; };
   var move = function () { fuel -= 1; };

   // Restituisco i membri e i metodi pubblici
   return {

      setFuel: setFuel,
      getFuel: getFuel,
      move: move
   };

}() );

}( window, 'Vehicle' ) );

Vehicle.setFuel( 100 );

document.write( 'Vehicle - carburante iniziale: ' + Vehicle.getFuel() + '<br>' );

Vehicle.move();
Vehicle.move();
Vehicle.move();

document.write( 'Vehicle - carburante dopo 3 movimenti: ' + Vehicle.getFuel() + '<br>' );

document.write( Vehicle.fuel ); // Non è definito!

/** Modulo per la gestione di un robot (estende il modulo precedente) **/
( function ( BASE, NAME, PARENT ) {

BASE[ NAME ] = ( function () {

   /** PUBBLICO **/
   var fly = function () {

      PARENT.setFuel( PARENT.getFuel() - 2 );
   };

   // Restituisco i membri e i metodi pubblici
   return {

      setFuel: PARENT.setFuel,
      getFuel: PARENT.getFuel,
      move: PARENT.move,
      fly: fly
   };

}() );

}( window, 'Robot', Vehicle ) );

Robot.setFuel( 100 );

document.write( 'Robot - carburante iniziale: ' + Robot.getFuel() + '<br>' );

Robot.move();
Robot.move();
Robot.move();

document.write( 'Robot - carburante dopo 3 movimenti: ' + Robot.getFuel() + '<br>' );

Robot.fly()
Robot.fly()
Robot.fly()

document.write( 'Robot - carburante dopo 3 voli: ' + Robot.getFuel() + '<br>' );

/** Modulo per la gestione di un cannone **/
( function ( BASE, NAME ) {

BASE[ NAME ] = ( function () {

   /** PRIVATO **/
   var bullets = 0;

   /** PUBBLICO **/
   var setBullets = function ( value ) { bullets = value; };
   var getBullets = function () { return bullets; };
   var shoot = function () { bullets -= 1; };

   // Restituisco i membri e i metodi pubblici
   return {

      setBullets: setBullets,
      getBullets: getBullets,
      shoot: shoot
   };

}() );

}( Robot, 'Gun' ) );

Robot.Gun.setBullets( 10 );

document.write( 'Robot.Gun - proiettili iniziali: ' + Robot.Gun.getBullets() + '<br>' );

Robot.Gun.shoot();
Robot.Gun.shoot();
Robot.Gun.shoot();

document.write( 'Robot.Gun - proiettili rimasti: ' + Robot.Gun.getBullets() + '<br>' );

/** Modulo che usa la libreria jQuery **/
( function ( $, BASE, NAME ) {

BASE[ NAME ] = ( function () {

   /** PUBBLICO **/
   var fun = function () { 

      alert( 'Titolo della pagina: ' + $('head title').text() );
   };

   // Restituisco i membri e i metodi pubblici
   return { fun : fun };

}() );

}( jQuery, window, 'Modulo' ) );

/** Modulo che usa la libreria jQuery **/
( function ( BASE, NAME ) {

BASE[ NAME ] = ( function () {

   /** PRIVATO **/
   var helloNum = function () { alert( 'Hello world ' + getNum() + '!' ); };
  
   /** PUBBLICO **/
   var getNum = function () { return 21; };

   var fun = function () { 

      setTimeout( helloNum, 3000 );
   };

   // Restituisco i membri e i metodi pubblici
   return { fun : fun };

}() );

}( window, 'Modulo' ) );

/** Istanza di prova **/
var obj = new function () {

   /** PRIVATO **/
   var helloNum = function () { alert( 'Hello world ' + this.getNum() + '!' ); };

   /** PUBBLICO **/
   this.getNum = function () { return 21; };

   this.fun = function () { 

      setTimeout( function ( obj ) { obj.getNum() }, 3000, this );
      setTimeout( helloNum, 3000 ); // ERRORE!!!
      // La funzione `helloNum` cerca di richiamare il metodo `this.getNum` dell'istanza
      // ma il `this` al suo interno ora si riferisce a tutt'altro contesto!!!
   }
};

obj.fun();

/*
    Title --- formatdate.js

    Copyright (C) 2012 Giacomo Trudu - wicker25[at]gmail[dot]com

    This script is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation version 3 of the License.

    This script is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this script. If not, see <http://www.gnu.org/licenses/>.

	= Version 1.1 =
	 + improved performance
*/

/** Formatta un timestamp o un'oggetto Date  **/
var formatDate = function ( format, time, r ) {

   // Preparo i parametri
   r = ( typeof( r ) != 'undefined' && r );
   var date = ( typeof( time ) != 'undefined' ) ? ( time instanceof Date ? time : new Date( time * 1000 ) ) : new Date;

   // Calcolo il numero dei secondi dall'inizio dell'anno
   var yearSecs = ( date - new Date( date.getFullYear(), 0, 1 ) ) / 1000;

   // Estraggo alcune informazioni dalla formattazione standard
   var meta = String( date ).match( /^.*?([A-Z]{1,4})([\-+]\d{4}) \(([A-Z]+)\).*$/ );

   // Estraggo le informazioni
   date = {

      d : date.getDate(),
      D : date.getDay(),
      m : date.getMonth(),
      y : date.getFullYear(),
      l : ( new Date( date.getFullYear(), 1, 29 ).getMonth() === 1 | 0 ),
      h : date.getHours(),
      M : date.getMinutes(),
      s : date.getSeconds(),
      u : date.getMilliseconds(),
      t : date.getTime(),
      z : date.getTimezoneOffset()
   };

   // Stringa della data formattata
   var str = '';

   // Riempie di zeri le cifre alla sinistra di un numero
   var pad = function ( value, len ) {

      return ( '000000000' + String( value ) ).slice( -len );
   };

   // Parametri della formattazione
   var fmt_values = {

      d : function () { return pad( date.d, 2 ); },
      D : function () { return [ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ][ date.D ]; },
      j : function () { return date.d; },
      l : function () { return [ 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday' ][ date.D ]; },
      N : function () { return date.D + 1; },
      S : function () { return [ 'th', 'st', 'nd', 'rd' ][ date.d % 10 > 3 ? 0 : ( date.d < 10 || date.d > 20 ) * date.d % 10 ]; },
      w : function () { return date.D; },
      z : function () { return Math.ceil( yearSecs / 86400 ); },
      W : function () { return Math.ceil( yearSecs / 604800 ); },
      F : function () { return [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ][ date.m ]; },
      m : function () { return pad( date.m + 1, 2 ); },
      M : function () { return [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ][ date.m ]; },
      n : function () { return date.m + 1; },
      t : function () { return [31, (date.l ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][ date.m ]; },
      L : function () { return date.l; },
      Y : function () { return date.y; },
      y : function () { return String( date.y ).slice( -2 ); },
      a : function () { return ( date.h < 12 ? 'am' : 'pm' ); },
      A : function () { return ( date.h < 12 ? 'AM' : 'PM' ); },
      g : function () { return date.h % 12 || 12; },
      G : function () { return date.h; },
      h : function () { return pad( date.h % 12 || 12, 2 ); },
      H : function () { return pad( date.h, 2 ); },
      i : function () { return pad( date.M, 2 ); },
      s : function () { return pad( date.s, 2 ); },
      u : function () { return date.u * 1000; },
      I : function () { return ( date.m > 2 && date.m < 10 || ( date.m == 2 && date.D - date.d >= 8 - 1 ) ); },
      O : function () { return meta[2]; },
      P : function () { return meta[2].slice( 0, -2 ) + ':' + meta[2].slice( -2 ); },
      T : function () { return meta[3]; },
      Z : function () { return -date.z * 60; },
      c : function () { return ( !r ? formatDate( 'Y-m-d\\TH:i:sP', time, true ) : null ); },
      r : function () { return ( !r ? formatDate( 'D, d M Y H:i:s O', time, true ) : null ); },
      U : function () { return Math.floor( date.t / 1000 ); }
   };

   // Divido la stringa di formattazione in token tenendo conto dei caratteri di escape
   var tokens = format.match( /(\\.|.)/gi );

   // Costruisco la stringa del tempo
   for ( var i = 0; i < tokens.length; i++ )
      str += ( tokens[i] in fmt_values ? fmt_values[ tokens[i] ]() : ( tokens[i].length == 1 ? tokens[i] : tokens[i][1] ) );

   return str;
};

formatDate( 'j, n, Y' ); // => '10, 3, 2001'
formatDate( 'F j, Y, g:i a' ); // => 'March 10, 2001, 5:16 pm'
formatDate( 'd/m/Y', 1230000000 ); // => '23/12/2008'
formatDate( 'H:i', new Date() ); // => '19:52'
formatDate( 'c' ); // => '2012-04-20T19:12:35+02:00'
formatDate( '\\i\\t \\i\\s \\t\\h\\e jS \\d\\a\\y.' ); // => 'it is the 20th day.'

Date.prototype.format = function ( format ) { return formatDate( format, this ); };

// Esempio:
var timestr = new Date().format( 'd/m/Y' );

<html>
<head>
    <script type="text/javascript" src="lib/jquery.js"></script>
    <title>Titolo della pagina</title>
</head>
<body>

<div>\[ \left [ - \frac{\hbar^2}{2 m} \frac{\partial^2}{\partial x^2} + V \right ] \Psi
= i \hbar \frac{\partial}{\partial t} \Psi \]</div>

<a id="loadMathJax" href="#">Carica MathJax</a>

<script type="text/javascript">
<!--

    // Percorso alla libreria
    var MathJax_path = 'lib/mathjax/';

    // Carico MathJax alla pressione del link
    $('#loadMathJax').click( function () {

        // Creo la configurazione di MathJax
        var config =

            "MathJax.Ajax.config.root = '" + MathJax_path + "';" + // <- Importante
            "MathJax.Hub.Config( { " +
            "    extensions: [ 'tex2jax.js' ], " +
            "    jax: [ 'input/TeX', 'output/HTML-CSS' ], " +
            "    tex2jax: { " +
            "      inlineMath: [ ['\[', '\]'] ], " +
            "      processEscapes: true " +
            "    }, " +
            "});";

        $('head').append( $('<script></script>').attr( 'type', 'text/x-mathjax-config' ).text( config ) );

        // Carico la libreria
        $.getScript( MathJax_path + 'MathJax.js?config=TeX-AMS-MML_HTMLorMML', function () {

            // Modifico il pulsante
            $('#loadMathJax').unbind( 'click' ).css( 'text-decoration', 'line-through' );
        } );
    } );

-->
</script>

</body>
</html>