Implementazione, nel linguaggio prolog, del metodo dei Tableaux Analitici studiato nel corso di Logica.

Nel sistema sono stati definiti i seguenti operatori:

:- op(650, xfy, sse).
:- op(640, xfy, implies).
:- op(630, yfx, or).
:- op(620, yfx, and).
:- op(610, fy, not).

Il primo parametro del predicato op/3 rappresenta la priorità dell’operatore definito; nel nostro caso l’operatore con maggior priorità è il not, seguito in ordine da and, or, implies, sse.
Questi operatori rappresentano i connettivi logici come rappresentato in tabella:

Per i quantificatori utilizziamo invece due predicati (forall(x,fbf) e exists(x,fbf)), entrambi hanno bisogno di due parametri: il primo è la variabile da quantificare ed il secondo è la formula ben formata quantificata. I simboli di variabile presenti nelle formule
ben formate passate in input sono in minuscolo in modo da distinguerli dalle variabili Prolog. Il sistema presentato elabora fbf (formule ben formate) della logica del primo ordine chiuse e pure.
Prima di iniziare a sviluppare il tableau per la formula data in input, è interrogato il predicato fbf_chiusa/1:

fbf_chiusa(
X and Y ) :- !, fbf_chiusa(X),fbf_chiusa(Y).

fbf_chiusa(
X or Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X implies Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X sse Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
forall(X,Y) ) :- atomic(X),instantiate(Y,X,-1,Y1),!, fbf_chiusa(Y1).

fbf_chiusa(
exists(X,Y) ) :- atomic(X), instantiate(Y,X,-1,Y1),!,fbf_chiusa(Y1).

fbf_chiusa(
not X ) :- ! ,fbf_chiusa(X).

fbf_chiusa(
X ) :- atomo_ground(X).

%instantiate(Y,X,N,Y1)
:- Y1 è la formula Y dove ogni occorrenza di X è sostituita con N

%atomo_ground(X)
:- X è un atomo ground.

Questo predicato è vero se il suo argomento è una formula ben formata chiusa. In particolare il controllo atomo_ground(X) è fatto verificando che X sia un atomo, e che tutti i suoi termini siano degli interi (istanziamo le variabili sul dominio dei numeri interi).

Descrizione implementazione

Cominciamo la descrizione dell’implementazione presentando i predicati ausiliari. Innanzitutto abbiamo i predicati che ci permettono di identificare il tipo di formula:

is_alpha(_
and _).

is_alpha(_
sse _).

is_alpha(not
(_ or _)).

is_alpha(not
(_ implies _)).

is_beta(_ or
_).

is_beta(_
implies _).

is_beta(not
(_ and _)).

is_beta(not
(_ sse _)).

is_delta(exists(
_ , _ )).

is_delta(not
forall( _ , _ )).

is_fresh_gamma(forall(
X , Y ), forall( X , Y , 0)).

is_fresh_gamma(not
exists( X , Y ), not exists( X , Y , 0)).

is_gamma(forall(
_ , _ , _ )).

is_gamma(not
exists( _ , _ , _ )).

Altri predicati sono atomo/1 e atomo_ground/1 :

atomo_ground(X)
:- compound( X ), X =.. [_|Terms], lista_interi(Terms).

lista_interi([]).

lista_interi([Termine
| Terms]) :- integer(Termine), lista_interi(Terms).

atomo(X) :-
compound( X ), X =.. Parametri, parametri_validi(Parametri).

parametri_validi([]).

parametri_validi([Parametro
| Tail]) :- atomic(Parametro),

Parametro \== not,

Parametro \== and,

Parametro \== or,

Parametro \== implies,

Parametro \== sse,

Parametro \== forall,

Parametro
\== exists,

!,

parametri_validi(Tail).

Questi predicati sono utilizzati da fbf_chiusa/1 (già presentata nel precedente paragrafo) e da istantiate/4 riportato di seguito:

instantiate(
X and Y , Var , Par , X1 and Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X or Y , Var , Par , X1 or Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X implies Y , Var , Par , X1 implies Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X sse Y , Var , Par , X1 sse Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
forall(X,Y),Var,Par,forall(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

instantiate(
forall(X,Y),Var,_,forall(X,Y)) :- X == Var, !.

instantiate(
exists(X,Y),Var,Par,exists(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

instantiate(
exists(X,Y),Var,_,exists(X,Y)) :- X == Var,!.

instantiate(
not X,Var,Par, not X1 ) :-!, instantiate(X,Var,Par,X1).

instantiate(
X,Var,Par,X1 ) :- atomo(X), !, substitute_occurrences(X,Var,Par,X1).

substitute_occurrences(X,Var,Par,X1):-
X =.. [Pred|Terms], substitute(Terms,Var,Par,Terms1),X1=.. [Pred|Terms1].

substitute([],_,_,[]).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term == Var,Term1 = Par,!,
substitute(Tail,Var,Par,Tail1).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term \== Var,Term1 = Term,!,
substitute(Tail,Var,Par,Tail1).

Il predicato istantiate(X, V, P,
X1) è vero quando X1 è la formula ottenuta sostituendo nella formula X tutte le
occorrenze della variabile V con il parametro P.

Passiamo ora allo sviluppo dell’albero di fbf costituente il tableau.

Il cuore del calcolo è nel predicato tclose(Fbf, Limite) che è vero se il tableau sviluppato per la formula Fbf chiude istanziando massimo “Limite” parametri. Fbf deve essere una formula ben formata chiusa:

tclose(Fbf,Limite)
:- fbf_chiusa(Fbf), closed_branch([Fbf],[],[],[],[],[],Limite,0,[]).

Ogni ramo del tableau è descritto dai termini di closed_branch/9:

closed_branch(Fbfs,As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate)

in particolare:

• Fbfs: lista delle formule in attesa di essere
  inserite in uno stack sul ramo
• As: stack delle formule di tipo alfa sul ramo
• Ds: stack delle formule di tipo delta sul ramo
• Bs: stack delle formule di tipo beta sul ramo
• Gs: stack delle formule di tipo gamma sul ramo
• Ls: stack di letterali sul ramo
• Limite: massimo numero di parametri da utilizzare
• Params: parametri introdotti (rappresentati dagli
  interi da 1 a Params)
• Elaborate: lista delle formule già elaborate (utile
  per stampare il ramo)

Il tableau è sviluppato elaborando le formule in base alla priorità: prima le formule alfa, poi le delta, le beta, ed infine le gamma. Per memorizzare le formule del ramo ancora da elaborare sono utilizzati quattro stack (As, Ds, Bs,Gs).

Elaborazione formule alfa

La formula da elaborare è presa in testa allo stack “As” delle formule alfa. Successivamente vengono introdotte due nuove formule Alpha1 ed Alpha2 tali che il predicato regola_alpha(Formula,Alpha1,Alpha2) risulta vero. Tali formule sono poi inserite nello stack delle formule da elaborare. Di seguito è riportato il codice necessario:

%alpha

closed_branch([Formula|As],Ds,Bs,Gs,Ls,Limite,Params,Elaborate)
:-

regola_alpha(Formula,Alpha1,Alpha2),

!,

closed_branch([Alpha1,Alpha2],As,Ds,Bs,Gs,Ls,Limite,Params,[Formula|Elaborate]).

regola_alpha(
A and B, A, B ).

regola_alpha(
not ( A implies B ), A, not B ).

regola_alpha(
not ( A or B ), not A, not B ).

regola_alpha(
A sse B, A implies B, B implies A).

La formula elaborata viene inserita nella lista Elaborate.

Elaborazione formule delta

La formula da elaborare è presa in testa allo stack “Ds”delle formule delta ed a partire da essa viene introdotta una nuova formula Delta1 che soddisfa il predicato regola_delta(Formula,Delta1,Limite,Params). Questa formula è poi inserita nello stack delle formule da elaborare. Di seguito è riportato il codice necessario:

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params < Limite,

regola_delta(Formula,Delta1,Limite,Params),

Params1 is Params + 1,

!,

closed_branch([Delta1],[],Ds,Bs,Gs,Ls,
Limite,Params1,[Formula|Elaborate]).

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params >= Limite,

!,

closed_branch([],[],Ds,Bs,Gs,Ls, Limite,Params,[Formula|Elaborate]).

regola_delta(exists(X,Fbf),Fbf1,_,N):-
N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

regola_delta(not
forall(X,Fbf),not Fbf1,_,N):- N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

La formula elaborata viene inserita nella lista Elaborate.

Elaborazione formule beta

La formula da elaborare è presa in testa allo stack “Bs” delle formule beta e sono introdotte due nuove formule Beta1 e Beta2 che soddisfano il predicato regola_beta(Formula,Beta1,Beta2). Queste formule prodotte sono inserite nello stack delle formule da elaborare, ma in questo caso vi sono due chiamate ricorsive al predicato poichè una formula di tipo beta prevede una biforcazione del ramo.

Di seguito è riportato il codice necessario:

%beta

closed_branch([],[],[Formula|Bs],Gs,Ls,Limite,Params,Elaborate)
:-

regola_beta(Formula,Beta1,Beta2),

!,

closed_branch([Beta1],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]),

closed_branch([Beta2],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]).

regola_beta(
A or B, A, B ).

regola_beta(
A implies B, not A, B ).

regola_beta(
not ( A and B ), not A, not B ).

regola_beta(
not ( A sse B ), not ( A implies B ), not ( B implies A ) ).

La formula elaborata viene inserita nella lista Elaborate.

Elaborazione formule gamma

Le formule di tipo gamma sono date in input nella forma:

forall(x,fbf) oppure
not exists(x,fbf)

Per semplificare la gestione di queste formule sono introdotte nuove formule ad esse equivalenti attraverso il predicato is_fresh_gamma/2:

is_fresh_gamma(forall(
X , Y ), forall( X , Y , 0)).

is_fresh_gamma(not
exists( X , Y ), not exists( X , Y , 0)).

Queste nuove formule hanno la forma:

forall(x,fbf,n) oppure
not exists(x,fbf,n)

dove n è un intero che porta traccia dei parametri per i quali già è stata istanziata la formula fbf. Ogni volta si istanzia la formula, cambiamo il valore di n in questo modo:

incrementa(forall(X,
Fbf, _), forall(X, Fbf, Params), Params).

incrementa(not
exists(X, Fbf, _), not exists(X, Fbf, Params), Params).

La formula gamma da elaborare è presa in testa allo stack “Gs”delle formule gamma. A partire da questa formula vengono introdotte una lista Gammas di nuove formule. Tali formule, introdotte attraverso il predicato regola_gamma(Formula,Gammas,Limite,Params,Params1), rappresentano tutte le instanziazioni della formula quantificata con i parametri da n fino a Params1.

Queste formule prodotte sono inserite nello stack delle formule da elaborare.

Di seguito è riportato il codice necessario:

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params < Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

incrementa(Formula, Formula1,
Params1),

append(Gs, [Formula1], Gs2),

!,

closed_branch(Gammas,
[],[],[],Gs2,Ls, Limite,Params1,[Formula|Elaborate]).

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params >= Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

!,

closed_branch(Gammas,
[],[],[],Gs,Ls, Limite,Params1,[Formula|Elaborate]).

regola_gamma(forall(X,
Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, Fbf, N, N, Limite, Params, Params1).

regola_gamma(not
exists(X, Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, not Fbf, N, N, Limite, Params, Params1).

%
la regola gamma introduce parametri nuovi

regola_gamma([],
_, _, N, _, Limite, Params, _) :- N == Params, N >= Limite,!.

regola_gamma([Fbf1],
X, Fbf, N, _, Limite, Params, Params1) :- N == Params,

Params <
Limite,

!,

Params1 is Params
+ 1,

instantiate( Fbf
, X , Params1 , Fbf1).

%
la regola gamma non introduce parametri nuovi

regola_gamma([Fbf1
| Gammas], X, Fbf, N, Next, _, Params, Params1) :- N < Params,

Next < Params,

Next1 is Next+1,

instantiate( Fbf
, X , Next1 , Fbf1),

!,

regola_gamma(Gammas,
X, Fbf, N, Next1, _, Params, Params1).

regola_gamma([],
_, _, N, Next, _, Params, Params) :- N < Params , Next == Params.

Notiamo che se la formula è stata già istanziata sul ramo su tutti i parametri permessi dal limite, essa non sarà ulteriormente istanziata.

Inserimento delle formule negli stack

Quando il predicato closed_branch ha arietà 9, allora il primo termine è la lista delle fbf in attesa di essere inserite nello stack adatto (push/11).

closed_branch([Fbf|_],As,Ds,Bs,Gs,Ls,_,_,Elaborate)
:-

chiude(Fbf,As,Ds,Bs,Gs,Ls),

!,

stampa_ramo([Fbf],As,Ds,Bs,Gs,Ls,Elaborate,’CHIUSO’).

closed_branch([Fbf|Fbfs],As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate):-

\+ chiude(Fbf,As,Ds,Bs,Gs,Ls),

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1),

!,

closed_branch(Fbfs,As1,Ds1,Bs1,Gs1,Ls1,Limite,Params,Elaborate).

push_formula(not
not Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1) :-

!,

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1).

push_formula(Fbf,As,Ds,Bs,Gs,Ls,[Fbf
| As],Ds,Bs,Gs,Ls) :- is_alpha(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,[Fbf
| Ds],Bs,Gs,Ls) :- is_delta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,[Fbf
| Bs],Gs,Ls) :- is_beta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf1
| Gs],Ls) :- is_fresh_gamma(Fbf, Fbf1), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf
| Gs],Ls) :- is_gamma(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[Fbf
| Ls]) :- atomo(Fbf), !.

push_formula(not
Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[not Fbf | Ls]) :- atomo(Fbf), !.

In questo punto è fatto il controllo di chiusura del ramo: un ramo è chiuso se contiene una coppia di fbf complementari(chiude/6). Resta invece aperto quando non ci sono più formule da sviluppare.

closed_branch([],[],[],[],[],Ls,_,_,Elaborate)
:- !,

stampa_ramo([],[],[],[],[],Ls,Elaborate,’APERTO’).

closed_branch([Fbf|_],As,Ds,Bs,Gs,Ls,_,_,Elaborate)
:- chiude(Fbf,As,Ds,Bs,Gs,Ls),

!,

stampa_ramo([Fbf],As,Ds,Bs,Gs,Ls,Elaborate,’CHIUSO’).

chiude(not
Fbf,_,_,Bs,_,_) :- is_alpha(Fbf), member(Fbf, Bs), !.

chiude(not
Fbf,_,_,_,Gs,_) :- is_delta(Fbf), member(Fbf, Gs), !.

chiude(not
Fbf,As,_,_,_,_) :- is_beta(Fbf), member(Fbf, As), !.

chiude(not
Fbf,_,Ds,_,_,_) :- is_gamma(Fbf), member(Fbf, Ds), !.

chiude(not
Fbf,_,_,_,_,Ls) :- atomo_ground(Fbf), member(Fbf, Ls), !.

chiude(Fbf,_,_,Bs,_,_)
:- is_alpha(Fbf), member(not Fbf, Bs), !.

chiude(Fbf,_,_,_,Gs,_)
:- is_delta(Fbf), member(not Fbf, Gs), !.

chiude(Fbf,As,_,_,_,_)
:- is_beta(Fbf), member(not Fbf, As), !.

chiude(Fbf,_,Ds,_,_,_)
:- is_gamma(Fbf), member(not Fbf, Ds), !.

chiude(Fbf,_,_,_,_,Ls)
:- atomo_ground(Fbf), member(not Fbf, Ls), !.

Quando è terminata l’elaborazione di un ramo lo si stampa a video con stampa_ramo/8.

Output

Per ogni ramo del tableau sviluppato, è stampata a video la lista delle formule contenute in quel ramo. Il predicato è stampa_ramo/8:

• il primo termine Fbf contiene la lista contenente
  la fbf con la quale viene chiuso quel ramo (se il ramo è aperto questo
  parametro è una lista vuota)
• l’ultimo termine Tipo è una stringa che può essere:
  • APERTO: se il ramo è aperto
  • CHIUSO: se il ramo è chiuso

stampa_ramo(Fbf,As,Ds,Bs,Gs,Ls,Elaborate,Tipo)
:-

write(’===========[RAMO '),
write(Tipo), write(']===========’), nl,

stampa_formule(Elaborate),

stampa_formule(As),

stampa_formule(Ds),

stampa_formule(Bs),

stampa_formule(Gs),

stampa_formule(Ls),

stampa_ultima_formula(Fbf),

nl,

write(’===================================’), nl, nl.

stampa_formule(
[] ).

stampa_formule(
[Formula | Formulas] ) :-

stampa_formule(Formulas),

write(Formula),
nl.

stampa_ultima_formula([]).

stampa_ultima_formula([Fbf])
:- write(Fbf), write(’ XXX’).

Esempi di output a video sono riportati negli esempi d’uso.

Esempi d’uso

In questa sezione sono riportati degli esempi d’uso: il primo con una formula valida (tableau con un unico ramo), il secondo con una formula soddisfacibile ma non valida e infine un esempio con una formula valida
con un tableau con più rami.

Tutte le prove sono state fatte con un limite sul numero di parametri introducibili pari a 10, quindi quando si parlerà di soddisfacibilità  in relazione alla presenza di rami aperti del tableau si intenderà sempre relativamente a un dominio con cardinalità uguale al numero di parametri introducibili.

Esempio formula valida

Per prima cosa bisogna caricare il codice nell’interprete prolog (swi-prolog), e poi chiedere all’interprete:

?- prova(not
exists(y,forall(x,(f(y) implies f(x))))).

===========[RAMO
CHIUSO]===========

not exists(y,
forall(x, f(y)implies f(x)), 0)

not forall(x,
f(1)implies f(x))

not
(f(1)implies f(2))

not exists(y,
forall(x, f(y)implies f(x)), 1)

not forall(x,
f(2)implies f(x))

not
(f(2)implies f(3))

not exists(y,
forall(x, f(y)implies f(x)), 2)

f(1)

not f(2)

f(2) XXX

===================================

true.

?-

E’ stampato a video un unico ramo
chiuso: questo vuol dire che la formula di partenza Ø$y“x(F(y)®F(x))
è insoddisfacibile, e quindi la sua negata $y“x(F(y)®F(x))
è valida.

Esempio formula soddisfacibile

Verifichiamo la non validità di una formula . Con un’analisi semantica si può facilmente vedere che {f(0,1), f(1,0)} è un contro-modello nel dominio {0, 1}. Neghiamo la formula e proviamo a dimostrarla con il metodo dei Tableaux:

?- prova(not
(forall(y,exists(x,f(x,y))) implies exists(x,forall(y, f(x,y))))).

===========[RAMO
APERTO]===========

not
(forall(y, exists(x, f(x, y)))implies exists(x, forall(y, f(x, y))))

not exists(x,
forall(y, f(x, y)), 0)

not forall(y,
f(1, y))

forall(y,
exists(x, f(x, y)), 0)

exists(x,
f(x, 2))

exists(x,
f(x, 1))

not exists(x,
forall(y, f(x, y)), 1)

not forall(y,
f(4, y))

not forall(y,
f(3, y))

not forall(y,
f(2, y))

forall(y,
exists(x, f(x, y)), 2)

exists(x,
f(x, 7))

exists(x,
f(x, 6))

exists(x,
f(x, 5))

exists(x,
f(x, 3))

exists(x,
f(x, 4))

forall(y,
exists(x, f(x, y)), 7)

not exists(x,
forall(y, f(x, y)), 4)

not f(1, 2)

f(3, 2)

f(4, 1)

not f(4, 5)

not f(3, 6)

not f(2, 7)

f(8, 7)

f(9, 6)

f(10, 5)

===================================

true.

?-

Siccome il tableau sviluppato per la formula negata non chiude, allora la formula originale non è valida. Per sapere se essa è soddisfacibile o insoddisfacibile
sviluppiamo un altro tableau non negando la formula:

?-
prova((forall(y,exists(x,f(x,y))) implies exists(x,forall(y, f(x,y))))).

===========[RAMO
APERTO]===========

forall(y,
exists(x, f(x, y)))implies exists(x, forall(y, f(x, y)))

not
forall(y, exists(x, f(x, y)))

not
exists(x, f(x, 1), 0)

not
exists(x, f(x, 1), 1)

not
exists(x, f(x, 1), 2)

not
exists(x, f(x, 1), 3)

not
exists(x, f(x, 1), 4)

not
exists(x, f(x, 1), 5)

not
exists(x, f(x, 1), 6)

not
exists(x, f(x, 1), 7)

not
exists(x, f(x, 1),

not
exists(x, f(x, 1), 9)

not
exists(x, f(x, 1), 10)

not
f(1, 1)

not
f(2, 1)

not
f(3, 1)

not
f(4, 1)

not
f(5, 1)

not
f(6, 1)

not
f(7, 1)

not
f(8, 1)

not
f(9, 1)

not
f(10, 1)

===================================

===========[RAMO
APERTO]===========

forall(y,
exists(x, f(x, y)))implies exists(x, forall(y, f(x, y)))

exists(x,
forall(y, f(x, y)))

forall(y,
f(1, y), 0)

forall(y,
f(1, y), 1)

forall(y,
f(1, y), 2)

forall(y,
f(1, y), 3)

forall(y,
f(1, y), 4)

forall(y,
f(1, y), 5)

forall(y,
f(1, y), 6)

forall(y,
f(1, y), 7)

forall(y,
f(1, y),

forall(y,
f(1, y), 9)

forall(y,
f(1, y), 10)

f(1,
1)

f(1,
2)

f(1,
3)

f(1,
4)

f(1,
5)

f(1,
6)

f(1,
7)

f(1,

f(1,
9)

f(1,
10)

===================================

true.

?-

Abbiamo due rami aperti, quindi la formula è soddisfacibile.

Ultimo esempio d’uso

Vogliamo provare la validità della formula.

?- prova(not
(exists(x, exists(y,r(x,y) or r(y,x)) ) implies exists(x,exists(y,r(x,y))) )).

===========[RAMO
CHIUSO]===========

not
(exists(x, exists(y, r(x, y)or r(y, x)))implies exists(x, exists(y, r(x, y))))

exists(x,
exists(y, r(x, y)or r(y, x)))

exists(y,
r(1, y)or r(y, 1))

r(1, 2)or
r(2, 1)

not exists(x,
exists(y, r(x, y)), 0)

not exists(y,
r(2, y), 0)

not exists(y,
r(1, y), 0)

not exists(y,
r(1, y), 2)

not exists(y,
r(2, y), 2)

not exists(x,
exists(y, r(x, y)), 2)

r(1, 2)

not r(2, 1)

not r(2, 2)

not r(1, 1)

not r(1, 2)
XXX

===================================

===========[RAMO
CHIUSO]===========

not
(exists(x, exists(y, r(x, y)or r(y, x)))implies exists(x, exists(y, r(x, y))))

exists(x,
exists(y, r(x, y)or r(y, x)))

exists(y,
r(1, y)or r(y, 1))

r(1, 2)or
r(2, 1)

not exists(x,
exists(y, r(x, y)), 0)

not exists(y,
r(2, y), 0)

not exists(y,
r(2, y), 2)

not exists(x,
exists(y, r(x, y)), 2)

not exists(y,
r(1, y), 0)

r(2, 1)

not r(2, 1)
XXX

===================================

true.

?-

Dall’output dell’elaborazione si vede che il tableau
sviluppato ha due rami chiusi, quindi la formula è valida.

Codice sorgente completo

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Definizione degli operatori logici

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:-
op(650, xfy, sse).

:-
op(640, xfy, implies).

:-
op(630, yfx, or).

:-
op(620, yfx, and).

:-
op(610, fy, not).

% Per i
quantificatori usiamo forall(x,fbf) e exists(x,fbf).

% Le
costanti devono essere dei numeri, e le lettere in minuscolo sono le variabili

:-
op(600, xfy, \).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Predicato per verificare il tipo

% delle formule ben formate

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

is_alpha(_
and _).

is_alpha(_
sse _).

is_alpha(not
(_ or _)).

is_alpha(not
(_ implies _)).

is_beta(_
or _).

is_beta(_
implies _).

is_beta(not
(_ and _)).

is_beta(not
(_ sse _)).

is_delta(exists(
_ , _ )).

is_delta(not
forall( _ , _ )).

is_fresh_gamma(forall(
X , Y ), forall( X , Y , 0)).

is_fresh_gamma(not
exists( X , Y ), not exists( X , Y , 0)).

is_gamma(forall(
_ , _ , _ )).

is_gamma(not
exists( _ , _ , _ )).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Controllo formula atomica ground

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

atomo_ground(X)
:- compound( X ), X =.. [_|Terms], lista_interi(Terms).

lista_interi([]).

lista_interi([Termine
| Terms]) :- integer(Termine), lista_interi(Terms).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Controllo formula atomica

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

atomo(X)
:- compound( X ), X =.. Parametri, parametri_validi(Parametri).

parametri_validi([]).

parametri_validi([Parametro
| Tail]) :- atomic(Parametro),

Parametro \== not,

Parametro \== and,

Parametro \== or,

Parametro \== implies,

Parametro \== sse,

Parametro \== forall,

Parametro \== exists,

!,

parametri_validi(Tail).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Controllo formula ben formata

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

fbf_chiusa(
X and Y ) :- !, fbf_chiusa(X),fbf_chiusa(Y).

fbf_chiusa(
X or Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X implies Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X sse Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
forall(X,Y) ) :- atomic(X),instantiate(Y,X,-1,Y1),!, fbf_chiusa(Y1).

fbf_chiusa(
exists(X,Y) ) :- atomic(X), instantiate(Y,X,-1,Y1),!,fbf_chiusa(Y1).

fbf_chiusa(
not X ) :- ! ,fbf_chiusa(X).

fbf_chiusa(
X ) :- atomo_ground(X).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Instanziazione di fbf quantificate

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

instantiate(
X and Y , Var , Par , X1 and Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X or Y , Var , Par , X1 or Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X implies Y , Var , Par , X1 implies Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X sse Y , Var , Par , X1 sse Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
forall(X,Y),Var,Par,forall(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

%le
occorrenze interne della variabile sono bounded nel quantificatore

instantiate(
forall(X,Y),Var,_,forall(X,Y)) :- X == Var, !.

instantiate(
exists(X,Y),Var,Par,exists(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

%le
occorrenze interne della variabile sono bounded nel quantificatore

instantiate(
exists(X,Y),Var,_,exists(X,Y)) :- X == Var,!.

instantiate(
not X,Var,Par, not X1 ) :-!, instantiate(X,Var,Par,X1).

instantiate(
X,Var,Par,X1 ) :- atomo(X), !, substitute_occurrences(X,Var,Par,X1).

substitute_occurrences(X,Var,Par,X1):-
X =.. [Pred|Terms], substitute(Terms,Var,Par,Terms1),X1=..

[Pred|Terms1].

substitute([],_,_,[]).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term == Var,Term1 = Par,!,

substitute(Tail,Var,Par,Tail1).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term \== Var,Term1 = Term,!,

substitute(Tail,Var,Par,Tail1).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% calcolo del Tableau

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

prova(Fbf)
:- tclose(Fbf, 10). % il numero 10 e’ un valore indicativo

tclose(Fbf,
Limite) :- fbf_chiusa(Fbf), closed_branch([Fbf],[],[],[],[],[], Limite, 0, []).

closed_branch([],[],[],[],[],Ls,_,_,Elaborate)
:- !, stampa_ramo([],[],[],[],[],Ls,Elaborate,’APERTO’).

closed_branch([Fbf|_],As,Ds,Bs,Gs,Ls,_,_,Elaborate)
:- chiude(Fbf,As,Ds,Bs,Gs,Ls),

!,

stampa_ramo([Fbf],As,Ds,Bs,Gs,Ls,Elaborate,’CHIUSO’).

closed_branch([Fbf|Fbfs],As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate):-

\+
chiude(Fbf,As,Ds,Bs,Gs,Ls),

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1),

!,

closed_branch(Fbfs,As1,Ds1,Bs1,Gs1,Ls1,Limite,Params,Elaborate).

closed_branch([],As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate)
:- closed_branch(As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate).

%alpha

closed_branch([Formula|As],Ds,Bs,Gs,Ls,Limite,Params,Elaborate)
:-

regola_alpha(Formula,Alpha1,Alpha2),

!,

closed_branch([Alpha1,Alpha2],As,Ds,Bs,Gs,Ls,Limite,Params,[Formula|Elaborate]).

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params < Limite,

regola_delta(Formula,Delta1,Limite,Params),

Params1 is Params + 1,

!,

closed_branch([Delta1],[],Ds,Bs,Gs,Ls, Limite,Params1,[Formula|Elaborate]).

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params >= Limite,

!,

closed_branch([],[],Ds,Bs,Gs,Ls, Limite,Params,[Formula|Elaborate]).

%beta

closed_branch([],[],[Formula|Bs],Gs,Ls,Limite,Params,Elaborate)
:-

regola_beta(Formula,Beta1,Beta2),

!,

closed_branch([Beta1],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]),

closed_branch([Beta2],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]).

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params < Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

incrementa(Formula, Formula1,
Params1),

append(Gs, [Formula1], Gs2),

!,

closed_branch(Gammas,
[],[],[],Gs2,Ls, Limite,Params1,[Formula|Elaborate]).

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params >= Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

!,

closed_branch(Gammas,
[],[],[],Gs,Ls, Limite,Params1,[Formula|Elaborate]).

regola_alpha(
A and B, A, B ).

regola_alpha(
not ( A implies B ), A, not B ).

regola_alpha(
not ( A or B ), not A, not B ).

regola_alpha(
A sse B, A implies B, B implies A).

regola_beta(
A or B, A, B ).

regola_beta(
A implies B, not A, B ).

regola_beta(
not ( A and B ), not A, not B ).

regola_beta(
not ( A sse B ), not ( A implies B ), not ( B implies A ) ).

regola_delta(exists(X,Fbf),Fbf1,_,N):-
N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

regola_delta(not
forall(X,Fbf),not Fbf1,_,N):- N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

regola_gamma(forall(X,
Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, Fbf, N, N, Limite, Params, Params1).

regola_gamma(not
exists(X, Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, not Fbf,
N, N, Limite, Params, Params1).

% la
regola gamma introduce parametri nuovi

regola_gamma([],
_, _, N, _, Limite, Params, _) :- N == Params, N >= Limite,!.

regola_gamma([Fbf1],
X, Fbf, N, _, Limite, Params, Params1) :- N == Params, Params < Limite,

!,

Params1 is Params
+ 1,

instantiate( Fbf
, X , Params1 , Fbf1).

% la
regola gamma non introduce parametri nuovi

regola_gamma([Fbf1
| Gammas], X, Fbf, N, Next, _, Params, Params1) :- N < Params,

Next < Params,

Next1 is Next+1,

instantiate( Fbf
, X , Next1 , Fbf1),

!,

regola_gamma(Gammas, X, Fbf, N, Next1, _, Params, Params1).

regola_gamma([],
_, _, N, Next, _, Params, Params) :- N < Params , Next == Params.

push_formula(not not
Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1) :- !,

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1).

push_formula(Fbf,As,Ds,Bs,Gs,Ls,[Fbf
| As],Ds,Bs,Gs,Ls) :- is_alpha(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,[Fbf
| Ds],Bs,Gs,Ls) :- is_delta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,[Fbf
| Bs],Gs,Ls) :- is_beta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf1
| Gs],Ls) :- is_fresh_gamma(Fbf, Fbf1), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf
| Gs],Ls) :- is_gamma(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[Fbf
| Ls]) :- atomo(Fbf), !.

push_formula(not
Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[not Fbf | Ls]) :- atomo(Fbf), !.

chiude(not
Fbf,_,_,Bs,_,_) :- is_alpha(Fbf), member(Fbf, Bs), !.

chiude(not
Fbf,_,_,_,Gs,_) :- is_delta(Fbf), member(Fbf, Gs), !.

chiude(not
Fbf,As,_,_,_,_) :- is_beta(Fbf), member(Fbf, As), !.

chiude(not
Fbf,_,Ds,_,_,_) :- is_gamma(Fbf), member(Fbf, Ds), !.

chiude(not
Fbf,_,_,_,_,Ls) :- atomo_ground(Fbf), member(Fbf, Ls), !.

chiude(Fbf,_,_,Bs,_,_)
:- is_alpha(Fbf), member(not Fbf, Bs), !.

chiude(Fbf,_,_,_,Gs,_)
:- is_delta(Fbf), member(not Fbf, Gs), !.

chiude(Fbf,As,_,_,_,_)
:- is_beta(Fbf), member(not Fbf, As), !.

chiude(Fbf,_,Ds,_,_,_)
:- is_gamma(Fbf), member(not Fbf, Ds), !.

chiude(Fbf,_,_,_,_,Ls)
:- atomo_ground(Fbf), member(not Fbf, Ls), !.

%
incrementa(Fbf, Fbf1) :- Fbf1 e’ la formula di tipo gamma Fbf con il campo
contatore N incrementato

incrementa(forall(X,
Fbf, _), forall(X, Fbf, Params), Params).

incrementa(not
exists(X, Fbf, _), not exists(X, Fbf, Params), Params).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Utilita’

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%
maximum(X, Y, Z) :- Z e’ il massimo tra X e Y

maximum(X,Y,X)
:- X >= Y.

maximum(X,Y,Y)
:- X < Y.

%
delete(X, Lista, Lista1) :- Lista1 e’ la lista risultante dalla cancellazione
di X da Lista

delete(X,
[X|Rest], Rest).

delete(X,
[Y | Rest], [Y|Deleted]) :- !, delete(X, Rest, Deleted).

nonmember(_,
[]).

nonmember(X,
[Y|Ys]):- X \== Y, !, nonmember(X, Ys).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Utilita’ per la stampa

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

stampa_ramo(Fbf,As,Ds,Bs,Gs,Ls,Elaborate,Tipo)
:-

write(’===========[RAMO '), write(Tipo),
write(']===========’), nl,

stampa_formule(Elaborate),

stampa_formule(As),

stampa_formule(Ds),

stampa_formule(Bs),

stampa_formule(Gs),

stampa_formule(Ls),

stampa_ultima_formula(Fbf),

nl,

write(’===================================’), nl, nl.

stampa_formule(
[] ).

stampa_formule(
[Formula | Formulas] ) :- stampa_formule(Formulas), write(Formula), nl.

stampa_ultima_formula([]).

stampa_ultima_formula([Fbf])
:- write(Fbf), write(’ XXX’).

Essa è un esempio di funzione ricorsiva che non è primitiva ricorsiva poiché cresce più velocemente di qualsiasi funzione ricorsiva primitiva.

Qui il codice java che implementa questa funzione:

Ackermann.java

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Ackermann {
 
 static long count = 0;
 
 private static long h(long m, long n) {
  
  count++;
  
  if (m == 0) {
   return n + 1;
  }
  if (n == 0) {
   return h(m-1, 1);
  }
  
  return h(m-1, h(m,n-1) );
 }
 
 private static long ack(long n) {
  return h(n, n);
 }
 
 public static void main(String[] args) {
  
  if (args.length != 1) {
   System.out.println("usage: Ackermann <number>\n\twhere number is a positive integer");
   System.exit(1);
  }
  
  long n = Long.valueOf(args[0]);
  
  count = 0;
  long retValue = ack(n);  
  System.out.println("ack(" + n + ") = " + retValue + " [recursive calls = "+ count +"]");
 
  
  System.exit(0);
 }
 
}

Il meccanismo di calcolo della funzione è estremamente semplice quanto pesante dal punto di vista computazionale. Questi sono i risultati ottenuti:

• ack(0) = 1  [recursive calls = 1]
• ack(1) = 3  [recursive calls = 4]
• ack(2) = 7  [recursive calls = 27]
• ack(3) = 61 [recursive calls = 2432]

Non riesco a calcolare ack(4) causa stack overflow (Exception in thread “main” java.lang.StackOverflowError).

Per gestire questa grossa quantità di dati multimediali, sia da parte degli utenti, sia da parte dei sistemi automatici, ci aiuta Mpeg-7: uno standard nato per codificare i contenuti multimediali attraverso la definizione di metadati sui dati multimediali.

I precedenti standard Mpeg-1 (1992), Mpeg-2 (1994), e Mpeg-4 (1999) riguardano la codifica del video. Nel 2001 è stato definito Mpeg-7 che non definisce il modo di codificare un video, ma riguarda la sua metataggatura attraverso un linguaggio XML.
Perché 7? Mpeg-7 permette di definire metadati sui video codificati con Mpeg 1, 2, e 4. Siccome 4+2+1=7, nasce il nome Mpeg-7.

Notiamo come non è stato nominato Mpeg-3, lo standard per i famosissimi mp3 . In realtà questo standard non esiste, ma il nome Mpeg-3 è usato per riferirsi alla parte audio di Mpeg-2.

Metadati

I metadati associati ad un video permettono di descrivere cosa c’è nel video. Mpeg-7 permette descrizioni sia a basso livello (caratteristiche del segnale, come il colore di un oggetto), sia ad alto livello (informazioni semantiche, come la scena di un goal in una partita di calcio).
Un esempio di file XML in formato Mpeg-7 contenente la descrizione di un video di una notizia è:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--Metadati generati automaticamente dall'applicazione-->
<Mpeg7 xmlns="urn:mpeg:mpeg7:schema:2001" xmlns:mpeg7="urn:mpeg:mpeg7:schema:2001"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="urn:mpeg:mpeg7:schema:2001 Mpeg7-2001.xsd">
 <Description xsi:type="ContentEntityType">
 <MultimediaContent xsi:type="VideoType">
 <Video>
 <MediaInformation>
 <MediaProfile>
 <MediaFormat>
 <Content href="MPEG7ContentCS" />
 <FileFormat href="urn:mpeg:mpeg7:cs:FileFormatCS:2001:3">
 <Name>mpeg</Name>
 </FileFormat>
 <FileSize>17333073</FileSize>
 <VisualCoding>
 <Format colorDomain="color"
 href="urn:mpeg:mpeg7:cs:VisualCodingFormatCS:2001:1" />
 <Frame height="576" rate="8000" width="720" />
 </VisualCoding>
 </MediaFormat>
 <MediaInstance id="v20090201_video_15213221">
 <InstanceIdentifier />
 <MediaLocator>
 <MediaUri>20090201_video_15213221.mov</MediaUri>
 </MediaLocator>
 </MediaInstance>
 </MediaProfile>
 </MediaInformation>
 <CreationInformation>
 <Creation>
 <Title>Obama: presto un piano per famiglie Usa per tagliare costi
 mutui</Title>
 <Abstract>
 <FreeTextAnnotation>
 Presidente cerca arginare effetti devastante crisi economica
 </FreeTextAnnotation>
 <StructuredAnnotation>
 <When>
 <Name>1 Feb 2009</Name>
 </When>
 </StructuredAnnotation>
 </Abstract>
 <Creator>
 <Role href="urn:mpeg:mpeg7:cs:RoleCS:2001:producer">
 <Name>Red</Name>
 </Role>
 <Agent xsi:type="OrganizationType">
 <Name>Apcom</Name>
 </Agent>
 </Creator>
 <CreationCoordinates>
 <Location>
 <Name>milano</Name>
 </Location>
 <Date>
 <TimePoint>2009-02-01T15:21:32</TimePoint>
 </Date>
 </CreationCoordinates>
 <CopyrightString>TMNews</CopyrightString>
 </Creation>
 <Classification>
 <Genre href="urn:mpeg:TVAnytime_v0.1ContentCS:3.14">
 <Name>est</Name>
 </Genre>
 <MediaReview>
 <Rating>
 <RatingValue>0.0</RatingValue>
 <RatingScheme best="5" style="higherBetter" worst="0">
 <Name>Overall</Name>
 </RatingScheme>
 </Rating>
 </MediaReview>
 </Classification>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_17483840.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_18024720.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_18094945.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_18153193.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_13033231.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_13094131.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_16491593.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_17042673.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 </CreationInformation>
 <UsageInformation>
 <Availability id="onDemand">
 <InstanceRef href="MPEG7PublicationTypeCS:4" />
 <Dissemination>
 <Format href="MPEG7PublicationTypeCS:4">
 <Name>Internet</Name>
 </Format>
 <Location>
 <Region>it</Region>
 </Location>
 </Dissemination>
 </Availability>
 <UsageRecord>
 <AvailabilityRef idref="onDemand" />
 <Audience>0</Audience>
 </UsageRecord>
 </UsageInformation>
 <MediaTime>
 <MediaTimePoint>T00:00:00</MediaTimePoint>
 <MediaDuration>PT0H0M29S</MediaDuration>
 </MediaTime>
 </Video>
 </MultimediaContent>
 <MultimediaContent xsi:type="ImageType">
 <Image>
 <MediaInformation>
 <MediaProfile>
 <MediaFormat>
 <Content href="urn:mpeg:mpeg7:cs:ContentCS:2001:2">
 <Name>visual</Name>
 </Content>
 <FileFormat href="urn:mpeg:mpeg7:cs:FileFormatCS:2001:3">
 <Name>JPEG2000</Name>
 </FileFormat>
 <FileSize>12014</FileSize>
 <VisualCoding>
 <Format colorDomain="binary"
 href="urn:mpeg:mpeg7:cs:VisualCodingFormatCS:2001:1">
 <Name>JPEG2000</Name>
 </Format>
 <Frame height="288" rate="0" width="360" />
 </VisualCoding>
 </MediaFormat>
 <MediaInstance id="i20090201_video_15213221">
 <InstanceIdentifier />
 <MediaLocator>
 <MediaUri>20090201_video_15213221.jpg</MediaUri>
 </MediaLocator>
 </MediaInstance>
 </MediaProfile>
 </MediaInformation>
 <CreationInformation>
 <Creation>
 <Title>
 Foto
</Title>
 <Creator>
 <Role href="urn:mpeg:mpeg7:cs:RoleCS:AUTHOR">
 <Name>Red</Name>
 </Role>
 <Agent xsi:type="OrganizationType">
 <Name>MPEG</Name>
 </Agent>
 </Creator>
 </Creation>
 </CreationInformation>
 </Image>
 </MultimediaContent>
 </Description>
</Mpeg7>

Mpeg-7 è un linguaggio XML, ossia usa XML per definire i metadati. In realtà un file Mpeg-7 non è altro che un file ‘.xml’ associato ad uno o più oggetti multimediali. Quindi è possibile memorizzare i metadati indipendentemente dai video… ad esempio un possibile uso di Mpeg-7, è la costruzione di un database multimediale!

Componenti di Mpeg-7

Lo standard Mpeg-7 è composta da quattro elementi fondamentali:

• Description Tools

• Descriptor

• Description Scheme

• DDL – Description Definition
  Language

• System Tool

I metadati di un oggetto multimediale saranno descritti usando i ‘Description Tools’.
I ‘Description Tools’ a loro volta fanno uso del ‘Description Definition Language’ (DDL) che è una estensione di XML Schema proprio per Mpeg-7.
I ‘System Tool’ non riguardano la definizione di metadati, ma la loro rappresentazione e trasmissione. Quindi il file XML è prodotto utilizzando solo ‘Description Tools’ e ‘DDL’, e poi questo file XML può essere diffuso utilizzando le tecniche dei ‘System Tools’.

Description Definition Language (DDL)

Il DDL è basato su XML Schema Language e ne rappresenta una sorta di estensione orientata al multimedia. In particolare XML Schema non è stato progettato per le descrizioni di contenuti audio/video e necessita quindi di tipi di dato per array e matrici, e tipo di dato per gestire il tempo (BasicTimePoint e BasicDuration).

Ad esempio la definizione di TimeType è:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<!-- Definition of Time datatype -->
<complexType name="TimeType">
 <sequence>
 <choice>
 <element name="TimePoint" type="mpeg7:TimePointType" />
 <element name="RelTimePoint" type="mpeg7:RelTimePointType" />
 <element name="RelIncrTimePoint" type="mpeg7:RelIncrTimePointType" />
 </choice>
 <choice minOccurs="0">
 <element name="Duration" type="mpeg7:durationType" />
 <element name="IncrDuration" type="mpeg7:IncrDurationType" />
 </choice>
 </sequence>
</complexType>
 
<!-- Definition of TimePoint datatype -->
<simpleType name="TimePointType">
 <restriction base="mpeg7:basicTimePointType">
 <pattern
 value="(\-?\d+(\-\d{2}(\-\d{2})?)?)?(T\d{2}(:\d{2}(:\d{2} (:\d+)?)?)?)?(F\d+)?(\-|\+\d{2}:\d{2})?" />
 </restriction>
</simpleType>
 
<!-- Definition of duration datatype -->
<simpleType name="durationType">
 <restriction base="mpeg7:basicDurationType">
 <pattern
 value="\-?P(\d+D)?(T(\d+H)?(\d+M)
 ?(\d+S)?(\d+N)?)?( \d+F)?((\-|\+)\d{2}:\d{2}Z)?" />
 </restriction>
</simpleType>

Usando queste definizioni di tipo contenute nella DDL, siamo in grado di descrivere il fatto che un certo filmato rappresenta un evento iniziato il 16 ottobre 2002 alle ore 17:00 in un paese con GTM+1, e dura 10 giorni, con questo codice:

0
1
2
3

<Time>
  <TimePoint>2002-10-16T17:00+01:00</TimePoint>
  <Duration>P10D</Duration>
</Time>

Ovviamente il DDL, oltre ai tipi qui introdotti (TimeType, TimePointType, e durationType), contiene molte altre definizioni che per brevità non tratteremo.

Description Tools

I Description Tools comprendono ‘Descriptor’ e ‘Descriptor Schemes’ che preferisco non distinguere e trattarli insieme, raggruppandoli in base alle loro funzionalità:

• Schema and Basic Elements:
  forniscono tutti i tipi di dato utilizzati nelle descrizioni, e la
  loro corrispondenza con i tag utilizzati in Mpeg-7;

• Content Description:
  rappresentazione dell’informazione audio/video sia a livello
  strutturale (basso livello), sia a livello semantico (alto livello);

• Content Management:
  permette di descrivere caratteristiche come creazione, formato, ed
  uso del materiale multimediale;

• Content Organization:
  Permette di gestire collezioni di materiale multimediale: si possono
  usare questi tool per implementare una base di dati XML di
  informazioni su materiale multimediale;

• Navigation and Access:
  aiutano l’accessibilità al file multimediale;

• User Interaction:
  permettono di memorizzare le preferenze dell’utente.

Con i Description Tools siamo in grado di produrre due tipi di descrizioni Mpeg-7 valide: le “Complete Descriptions” che descrivono interamente un materiale multimediale come un video (l’esempio di file xml Mpeg-7 di questo articolo corrisponde ad una Complete Description perchè descrive completamente il video), e le “Descriptions Units” che non sono descrizioni intere ma dei componenti che possono far parte di una Complete Description.

Conclusioni

Non si è trattata la parte dei System Tools, inoltre della parte dei Description Tool si è data una semplice descrizione generale. I Description Tool sono la parte più corposa dello standard Mpeg-7, e studiarli tutti può richiedere tempo. Si suggerisce a tal proposito di utilizzare i documenti ufficiali dello standard o l’utilissima guida di Chiariglione all’indirizzo http://www.chiariglione.org/mpeg/ .

Relazione tra XQuery ed XPath

Il linguaggio XML è diventato uno degli elementi fondamentali per la realizzazione di sistemi informativi, indipendentemente dalla tecnologia usata.

Storia

Il World Wide Web Consortium (W3C), in seguito alla guerra dei browser fu costretto a seguire le individuali estensioni al linguaggio HTML. Dovette scegliere quali caratteristiche standardizzare e quali lasciare fuori dalle specifiche ufficiali dell’HTML. Fu in questo contesto che iniziò a delinearsi la necessità di un linguaggio di markup che desse maggiore libertà nella definizione dei tag, pur rimanendo in uno standard.

Il “progetto XML”, che ebbe inizio alla fine degli anni ‘80 nell’ambito della SGML Activity del W3C, suscitò un così forte interesse a tal punto che la W3C creò un gruppo di lavoro, chiamato XML Working Group, composto da esperti mondiali delle tecnologie SGML, ed una commissione, XML Editorial Review Board, deputata alla redazione delle specifiche del progetto.

Nel febbraio del 1998 le specifiche divennero una raccomandazione ufficiale con il nome di Extensible Mark-up Language, versione 1.0. Ben presto ci si accorse che XML non era solo limitato al contesto web, ma era qualcosa di più: uno strumento che permetteva di essere utilizzato nei più diversi contesti, dalla definizione della struttura di documenti, allo scambio delle informazioni tra sistemi diversi, dalla rappresentazione di immagini alla definizione di formati di dati.

Il Linguaggio

• Definizione XML: (acronimo di eXtensible Markup Language) è un metalinguaggio di markup, ovvero un linguaggio marcatore che definisce un meccanismo sintattico che consente di estendere o controllare il significato di altri linguaggi marcatori. Costituisce il tentativo di produrre una versione semplificata di SGML che consenta di definire in modo semplice nuovi linguaggi di markup

Quindi quello che si fa con XML è definire/progettare dei propri “Linguaggi XML” (cioè un linguaggio basato su XML); ad esempio possiamo scegliere di codificare in XML i risultati di una giornata del campionato di calcio:

0
1
2
3
4
5
6
7
8
9
10
11

<partite giornata=”3°”>
 <partita numero=”1”>
  <squadra>Napoli</squadra>
  <squadra>Juventus</squadra>
  <risultato>3-0</risultato>
 </partita>
  <partita numero=”2”>
  <squadra>Roma</squadra>
  <squadra>Lazio</squadra>
  <risultato>2-2</risultato>
 </partita>
</partite>

Il processo di sviluppo di un linguaggio XML è detto “XMLificazione”: ossia la scelta dei tag (partite, partita, squadra, risultato), degli attributi (giornata, numero), e della loro struttura.

Ci possono essere però altri linguaggi XML che usano i nostri stessi tag, e mischiare più linguaggi XML con nomi dei tag uguali può portare a confusione, per questo possiamo introdurre un namespace per i nostri nomi.

• Namespace XML: Un namespace è una collezione di nomi di entità, definite dal programmatore, omogeneamente usate in uno o più file sorgente. Lo scopo dei namespace è quello di evitare confusione ed equivoci nel caso siano necessarie molte entità con nomi simili, fornendo il modo di raggruppare i nomi per categorie.Nel linguaggio XML i namespaces sono definiti esplicitamente.

Nel nostro caso la prima riga diventerà:

<partite giornata=”3°” xmlns=”http://www.fireteam.it”>

In questo modo indichiamo che il tag ‘partite’ e tutto il suo contenuto appartengono al namespace ‘http://www.fireteam.it’ di default.

Fin qui XML sembra la più banale delle tecnologie, eppure ha avuto così tanto successo… allora perché è così importante?

La Tecnologia XML

Il primo motivo è che tutti i file XML sono codificati in UNICODE (i famosi UTF-8 UTF-16, ed UTF-32), e sono stati eliminati in questo modo molto dei fastidi che affligevano i formati testuali.

Il secondo motivo è che con XML si può rappresentare l’informazione in modo semplice, mantenendo un minimo di struttura; non a caso l’informazione codificata in XML è detta semistrutturata, che è il compromesso dalla completa strutturazione (come ad esempio la struttura rigida di uno schema di un database relazionale) e l’assenza di struttura (schema-less, ossia il testo puro).

Il terzo motivo, che ritengo più importante, è che attorno a questo semplice linguaggio di markup sono state definite parecchie tecnologie utili a risparmiare lavoro durante il trattamento dei dati. Queste sono:

• Xpath: è un linguaggio parte della famiglia XML che permette di individuare i nodi all’interno di un documento XML.

• Linguaggi Schema: un linguaggio di schema è un linguaggio formale per esprimere “schemi”. Uno schema è la definizione formale della sintassi di un linguaggio XML, ovvero una famiglia di documenti XML.
  • DTD: Il linguaggio DTD è utile a definire schemi DTD per un particolare linguaggio XML. DTD è semplice, con un potere espressivo limitato, non è autoesplicativo poiché non usa una notazione XML (è descritto da una grammatica BNF), e tra i tanti difetti non supporta i namespace in quanto il linguaggio DTD stato definito è stato definito prima dei namespace.
  • Schema: è un linguaggio di schema nato per sostituire DTD. E’ più espressivo, è quasi autoesplicativo (è scritto in XML e la sua sintassi è definibile con XML schema stesso, ma non si riescono a catturare tutti gli aspetti sintattici del linguaggio). Inoltre introduce i tipi di dato e permette di crearne nuovi, in modo da riuscire a fare buoni controlli sui contenuti dei file XML.

• XSL: acronimo di eXtensible Stylesheet Language, è il linguaggio di descrizione dei fogli di stile per i documenti in formato XML. Com’è noto, lo standard XML prevede che i contenuti di un documento siano separati dalla formattazione della pagina in cui verranno pubblicati.
  • XSLT: XSL Transformations – il linguaggio di trasformazione dell’XML. Fa uso di XPath per accedere alle parti di un documento XML. La trasformazione è fatta da un modulo detto Processore XSLT, come ad esempio quello incluso nei browser.
  • XSL-FO: XSL Formatting Objects – usato per l’applicazione degli stili e del modo di apparizione a un documento XML.

• XQuery: abbrevazione per XML Query Language, è un linguaggio di programmazione specificato dal W3C e destinato ad interrogare documenti e basi di dati XML.

Qui è d’obbligo soffermarsi per discutere sull’utilità di un linguaggio di interrogazione XML. Un’ambiziosa applicazione di XML ha come scopo la generalizzazione del tradizionale modello delle basi di dati relazionali. Da tempo si sta cercando un’alternativa ai vecchissimi database relazionali, e si è provato in svariate direzioni… database gerarchici, database multidimensionali, database ad oggetti, ecc.

XML è un alternativa allettane! Oggi si scrive molto in XML, specialmente sul web dove vi sono pagine XHTML (che sono XML), e l’idea di avere un database XML perfettamente integrabile con tutti gli altri nostri dati non è affatto male… il World Wide Web può così diventare una gigantesca base di dati.

XQuery è un linguaggio per interrogare file XML, allo stesso modo in cui SQL interroga base di dati relazionali… ed è qui che una collezione di file XML è spesso chiamata Database XML.

E come tutti i linguaggi di interrogazione che si rispettano anche per XQuery c’è un algebra… XML Query Algebra definita dal W3C. In realtà i lavori sono ancora in progresso e ci sono varie proposte di algebra:

• Algebra per linguaggi di interrogazione XML: sono stati proposti svariati linguaggi di interrogazione XML, come XQuery, XML-QL, ed altri; quindi c’è un interesse crescente verso l’interrogazione di file XML. Non ancora però è stata definita un’algebra comune per questi linguaggi. Un algebra formale è un passo obbligato per avere una buona ottimizzazione delle query.
  • TAX: E’ una proposta di algebra non standard, utilizzata da un motore di database XML chiamato “Timber XML”. TAX sta per “Tree Algebra for XML”, ed è una proposta interessante perché usa un modello di dati dove i documenti XML sono effettivamente visti come alberi, quindi le varie operazioni (Selezione, Proiezione, Prodotto, Set, Raggruppamento, Aggregazione, Renaming, Reordering, Copy-and-Paste, Cancellazione, Inserimento) risultano definite in modo naturale.
  • XML Query Algebra: anche chiamata “The Algebra” è la proposta di standardizzazione da parte del W3C. Questa algebra, che sembra assomigliare ad un linguaggio di programmazione dichiarativo, non definisce le operazioni con operatori ad HOC, ma riesce a ricavare le consuete operazioni mediante l’uso di cicli for, assegnazioni di variabili, costrutti condizionali, ed altro. Inoltre i tipi di dato sono molto importanti, e sono definiti per ogni espressione. Una volta tradotta una query, la sua ottimizzazione sfrutta delle regole di inferenza logica; un metodo del tutto innovativo.

E quando queste tecnologie non riescono a soddisfare le nostre richieste, entra in gioco la solita programmazione:

• Programmazione XML: Benchè gli strumenti XML (Schema, XSLT, XQuery, XPath, ecc…) ci permettono di fare molti tipi di elaborazione, spesso c’è la necessita di manipolare file XML da linguaggi di programmazione di uso generale come ad esempio Java.
  • DOM: Il Document Object Model (DOM) è una forma di rappresentazione dei documenti strutturati come modello orientato agli oggetti. DOM definisce un API per accedere e manipolare file XML comune a diversi linguaggi.
  • SAX: (Simple API for XML) è un’API per numerosi linguaggi di programmazione che permette di leggere ed elaborare dei documenti XML. Contrariarmente al DOM, il SAX processa i documenti linea per linea. Il flusso di dati XML è unidirezionale, così che dati a cui si è acceduto in precedenza non possono essere riletti senza la rielaborazione dell’intero documento.
  • JDOM: JDom è un API per accedere ed elaborare documenti XMl specifica per il linguaggio di programmaziopne Java, che (rispettando il principio del 80/20) permette di sviluppare con semplicità l’80% delle applicazione, mentre richiede una soluzione ad HOC per il restante 20%… cioè JDom sacrifica parte della generalità per dar miglior supporto alle applicazioni più comuni.

• XML Retrieval: L’information retrieval (IR) è la disciplina che studia le tecniche utilizzate per il recupero mirato dell’informazione in formato elettronico.

Le Applicazioni XML

XML è oggi una tecnologia matura ed utilizzata negli ambiti più disparati… basta provare a salvare un documento di testo scritto con il famosissimo word processor OpenOffice, rinominare questo file .zip, e provare ad estrarre il contenuto: dentro troveremo il nostro documento descritto in XML!!!

Un altro esempio è SVG, lo standard aperto per la grafica vettoriale che punta a sostituire la tecnologia ‘flash’ sul web. Un file .svg è interamente scritto in XML, tant’è vero che si può aprire senza problemi con un qualsiasi editor di testo.

Alcuni linguaggi XML hanno avuto particolare successo come XHTML, CML (Chemical Markup Language), WML (usato nella tecnologia WAP dei cellulari), RSS ed altri… in particolare Mpeg7:

• Mpeg-7: MPEG-7 è uno standard nato per codificare i contenuti multimediali; non è uno standard nato per codificare flussi audio o video come, ad esempio, MPEG-1 MPEG-2 o MPEG-4 ma per definire metadati sui dati multimediali.La codifica utilizza l’XML per memorizzare dei metadati che utilizzano a loro volta il timecode del filmato permettendo di sincronizzare i flussi multimediali con particolari eventi. Per esempio, permette di sincronizzare un filmato con i suoi sottotitoli o un video con il testo della canzone.

Il concetto di espressione regolare è un formalismo importante utilizzato, in varie forme, in svariate applicazioni… ad esempio nei linguaggi di schema (come DTD di XML) per descrivere sequenze di elementi o caratteri. I linguaggi regolari sono utilizzati in molte altre aree dell’informatica oltre a XML, dall’elaborazione del testo e del linguaggio naturale alla verifica formale dei componenti hardware.

Potrebbe essere necessario, ad esempio, vincolare un valore ‘data’ in modo tale da rispettare il formato dd-mm-yyyy, ovvero sia composto da due cifre per il giorno, seguite da due per il mese e quattro per l’anno, tutto separato da un segno meno “-”. Alternativamente possiamo specificare che un certo valore deve essere un numero intero.

Chiamiamo Σ un alfabeto consistente in un insieme di atomi, che tipicamente sono caratteri Unicode o nomi di elementi. Un’espressione regolare su Σ è costruita in base alle seguenti regole:

• ogni atomo in Σ, preso da solo, è un espressione regolare;
• se a e b sono espressioni regolari, allora lo sono anche le seguenti:

  • a?

  • a*

  • a+

  • a b

  • a|b

  • (a)

Gli operatori ?, , e + hanno una precedenza superiore alla concatenazione (l’operatore vuoto o “giustapposizione”), che a sua volta ha una precedenza superiore a |. E’ sempre possibile usare le parentesi per raggruppare sotto-espressioni, superando così le precedenze di default. L’espressione ab*|c, in cui l’alfabeto Σ contiene a, b, e c, è interpretata come (a(b*))|c e non a(b*|c).

Una stringa finita di atomi di Σ può corrispondere o meno a una data espressione regolare a:

• un atomo r appartenente a Σ corrisponde unicamente al singolo atomo r;
• a? corrisponde ad a opzionalmente, ovvero a qualsiasi stringa corrisponda ad a più la stringa vuota;
• a* corrisponde a zero o più ripetizioni delle stringhe che corrispondono ad a;
• a+ corrisponde ad una o più ripetizioni delle stringhe che corrispondono ad a;
• a b corrisponde a ciò a cui corrisponde ‘a’ seguito da ciò a cui corrisponde b;
• a|b corrisponde all’unione delle corrispondenze di a e b;
• (a) ha le stesse corrispondente di a.

L’espressione regolare (a(b*))|c corrisponde così a tutte le stringhe composte da una a seguite da zero o più b, oppure una singola c da sola.

Un linguaggio regolare è un insieme di stringhe che corrispondono a una qualche espressione regolare.

E’ possibile definire un’espressione regolare d (che sta per digit, cifra) scrivendo:

0|1|2|3|4|5|6|7|8|9

laddove l’alfabeto è composto ad esempio da tutti caratteri Unicode. Possiamo partire da questa definizione per definire un’altra espressione regolare ‘data’ scrivendo dd-dd-dddd. Naturalmente quest’espressione corrisponde anche a stringhe come 88-26-9995, che non denotano date reali, ma con un po’ più di sforzo è possibile catturare precisamente l’insieme di stringhe desiderato: in effetti su può usare un linguaggio regolare per gestire correttamente anche gli anni bisestili, ma allora le cose si fanno parecchie complicate!

La seguente espressione regolare descrive gli interi con un alfabeto composto dalle dieci cifre e dal segno meno:

0|-?(|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)*

Secondo questa definizione, -42, 0, 117 sono accettabili, mentre 000, -0 e 3.14 non lo sono.

Adesso facciamo l’ultimo esempio, più complicato! In XHTML il contenuto di un elemento table dev’essere una sequenza che consiste in un elemento opzionale ‘caption’ seguito da un certo numero di elementi ‘col’ o alternativamente ‘colgroup’, i quali a loro volta sono opzionalmente seguiti da un elemento ‘thead’ e uno ‘tfoot’, per concludere almeno un elemento ‘tbody’ (o alternativamente ‘tr’). Possiamo scrivere con un’espressione regolare:

caption? ( col* | colgroup* ) thead? tfoot? ( tbody+ | tr+ )

Esistono molte varianti delle espressioni regolari… ad esempio le regular expression del linguaggio perl: tuttavia la maggior parte di queste varianti si limita ad aggiungere zucchero sintattico alla notazione base che abbiamo appena presentato.

Un’estensione tipica sono gli intervalli di caratteri: [0-9], ad esempio, è una comoda abbreviazione per indicare le cifre al posto di 0|1|2|3|4|5|6|7|8|9. In modo analogo a{n,m} con n e m numeri interi non negativi, denota da n ad m ripetizioni di a. Un altro esempio sono le espressioni regolari usate nella suit di ufficio OpenOffice.

Espressioni Regolari in OpenOffice

Questa è l’introduzione alle espressioni regolari; per lavorare efficientemente con un vero implementazione di queste espressioni richiede ulteriore studio.

Se applichiamo un metodo diretto a un sistema lineare con matrice dei
coefficienti sparsi, abbiamo che l’algoritmo esegue operazioni anche su
i valori nulli. Un sistema lineare con matrice dei coefficienti sparsa, si
dice sistema lineare sparso.
Ad esempio se applichiamo Gauss a un sistema sparso, i coefficienti che erano nulli, al
secondo passo diventano coefficienti non nulli: questo e’ uno spreco
computazionale!

DEFINIZIONE MATRICE SPARSA

E’ una matrice a[n,m] in cui ci sono molti elementi uguali a 0. La sparsita’ di una matrice
si misura grazie al “Grado di sparsita’”:

numero coefficienti nulli
SP = —————————-
numero totale coefficienti

Quando gli elementi nulli sono 0, allora  -> SP = 0 |
|-> Quindi 0 <= SP <= 1
Quando non ci sono elementi nulli, allora -> SP = 1 |

La matrice e’ molto sparsa quando SP e’ molto vicino a 1.

METODI ITERATIVI

Dato un sistema lineare:

/ a*x[1] + b*x[2] = c
|
\ d*x[1] + e*x[2] = f

mettiamo da un membro x[1] e x[2]:

/ x[1] = 1/a * (c – b*x[2])
|
\ x[2] = 1/e * (f – d*x[1])

Adesso partiamo da una soluzione a caso x[1]=0 e x[2]=0, e iterando molte
volte i calcoli pian piano si converge alla soluzione.

JACOBI e GAUSS-SEIDEL

Jacobi e Gauss-Seidel sono due metodi iterativi che implementano questa idea.
L’unica differenza tra i due e’ che Jacobi ad ogni iterazione si serve del
vettore delle soluzioni calcolato all’iterazione precedente, mentre
Gauss-Seidel man mano che calcola i nuovi valori li usa anche nell’iterazione
corrente.

SI CONVERGE SEMPRE ALLA SOLUZIONE?

I metodi di Jacobi e Gauss-Seidel convergono quando dato il sistema Ax=b:
- La norma infinito di A e’:    ||A|| < 1
Di conseguenza A e’ a diagonale strettamente dominante

Si noti che queste sono solo condizioni sufficienti e non necessari, infatti
ci sono alcuni sistemi dove ||A|| > 1 e i metodi iterativi convergono
lo stesso.

Notiamo che quando piu’ ||A|| si avvicina a 0, tanto piu’ velocemente
converge il metodo iterativo.

TEOREMA SULLA CONVERGENZA CONSISTENTE

Se il metodo di Jacobi o Gauss-Seidel converge, allora esso converge alla
soluzione.
Quindi non puo’ essere che converge a qualche altra cosa!!!
Si dice che i metodi di Jacobi o Gauss-Seidel sono consistenti.

CRITERIO D’ARRESTO

Sarebbe bellissimo misurare il criterio d’arresto con l’errore relativo o
l’errore assoluto… peccato che queste due formule richiedono la conoscenza
della vera soluzione: cosa che noi vorremmo sapere!
Quindi stimiamo l’errore con l’iterazione precedente:

Assoluto: | x[k+1] – x[k] | <= tolleranza
Relativo: | (x[k+1] – x[k]) / x[k+1] | <= tolleranza

Solo che con questo criterio d’arresto, se il metodo non converge,
l’algoritmo non si fermera’ mai… quindi imponeremo che l’algoritmo deve
effettuare al massimo un mumero preciso di iterazioni (kmax)

Un algoritmo efficiente utilizza entrambi questi criteri d’arresto.

Problem Solving:
Formulazione del problema P, Descrizione di P mediante un modello matematico:M(P) approssimazione di M(P) mediante metodi numerici Mh(P), Sviluppo dell’algoritmo risolutivo Mh(P),Implementazione in uno specifico ambiente di calcolo

Da che cosa dipende il tempo di esecuzione di un software?

Un’ implementazione efficiente dipende oltre che dal numero di operazioni floating-point anche dagli accessi alla MEMORIA
T1 = Nmem x tmem + N flop x t flop    mem=tempo di accesso alla memoria, flop=tempo operazioni floating point
Nmem & Nflop: dipende dall’algoritmo; tmem & tflop: dipende dalla tecnologia.

Ridurre il numero di accessi alla memoria, ridurre il tempo di accesso alla memoria –> riuso dei dati nei registri
La complessità di tempo dell’algoritmo (Nflop) e la velocità del processore (tflop) sono fisse

Vantaggi e caratteristiche delle BLAS

Modularità: sw scritto in termini di building blocks; Chiarezza: codice più breve e più leggibile;
Efficienza: implementazioni ottimizzate da parte dei costruttori di computer; Portabilità: interfacce standard, dipendenza dall’architettura incapsulata in BLAS; Affidabilità, robustezza: gestione accurata di “dettagli” algoritmici e implementativi e di situazioni di errore (es: overflow)

Traffico parassita:
Parametro di valitazione del traffico parassita: q = #accessi alla memoria / #operazioni floating point
SAXPY: y=y+ax  –> preleva x (n accessi), preleva y (n accessi), preleva a (1 accesso), calcolo = (2n op. fl.p.), riponi y (n accessi)
q = m/f = (3n+1) / (2n)
DOT: a = x(trasposto) * y –> preleva x (n accessi), preleva y (n accessi), calcolo = (2n op. fl.p.), riponi in a (1 accesso)
q = m/f = (2n+1) / (2n)  –> quasi 1.
GAXPY: y=y+Mx  –> preleva y (n accessi), preleva M (n^2 accessi), preleva x (n accessi), calcolo y+Mx = (2n^2 op. fl.p.), riponi y (n accessi)
q = m/f = (3n+n^2) / (2n^2)
Strategia: Suddivisione della matrice in blocchi di dimensione pari alla cache

Tecnica di LOOP UNROLLING

Lo “srotolamento” del ciclo consistente nel modificare il controllo del ciclo e nel replicare opportunamente le istruzioni all’interno del ciclo viene detto Tecnica di LOOP UNROLLING
Vantaggi del loop unrolling: Utilizzo ottimale dei processori con architettura pipelined, riduzione dell’overhead del ciclo di iterazione riduzione del numero di trasferimenti fra i vari livelli memoria, aumento delle operazioni concorrenti;L’overhead del programma e il numero di trasferimenti di dati dai livelli più bassi di memoria ai registri, si riducono di un fattore proporzionale alla nuova lunghezza del ciclo (profondità dell’unrolling); Svantaggi del loop unrolling: unrolling;Aumento della memoria destinata al programma; Perdita della generalità del codice

Una matrice si dice simmetrica quando A[i][j] = A[j][i]

Cholesky e matrici simmetriche:
Applicando l’algoritmo di Gauss senza pivoting ad una matrice simmetrica, abbiamo che le sottomatrici attive sono anch’esse simmetriche. Questo è vero in generale e si dimostra.
Si può sfruttare la simmetria considerando solo un triangolo della matrice.
Se si usa il pivoting parziale si perde la simmetria della matrice.
Quindi, in generale, l’utilizzo di una tecnica di pivoting nell’algoritmo di Gauss NON CONSENTE di sfruttare, in termini di efficienza computazionale la simmetria della matrice
In quali condizioni si può evitare il pivoting?
- Matrici a diagonale dominante (al generico passo K, le sottomatrici attive sono a diagonale dominante – il pivot starebbe sempre sulla diagonale)
- Matrici simmetriche e definite positive (una matrice è def positiva se det(A)>0) (criterio di Sylvester)
Se una matrice è simmetrica, la fattorizzazione A=LU (senza pivoting) si specializza in A=LDL^T (A=LU, D^-U=LT quindi U=DL^T, A=LDL^T) L=matrice triangolare inferiore(moltiplicatori), D=matrice diagonale(elementi diagonali di U))
Come si specializza la fattorizzazione LDL^T di una matrice simmetrica e definita positiva?
Esiste un’unica matrice L triangolare inferiore tale che: A=LL^T
A=LLT –> Algoritmo di Cholesky    T(chol)=O((n^3)/6))=Tgauss(n)/2
L’Algoritmo di Cholesky ha una complessità di TEMPO che è la metà di quella dell’Algoritmo di Gauss!!
A è simmetrica allora si memorizza solo una metà degli elementi; L è triangolare allora si memorizzano solo gli elementi non nulli
L’Algoritmo di Cholesky ha una complessità di SPAZIO che è la metà di quella dell’Algoritmo di Gauss!!
Quando è possibile applicare la fattorizzazione LL^T ad una matrice simmetrica e a diagonale dominante? ovvero quando una matrice simmetrica a diagonale dominante è anche definita positiva?
- non singolare (det(A)>0)
- simmetrica
- a diagonale dominante
- ha gli elementi sulla diag non negativi

Matrici TOEPLITZ ottenute l’una da una rotazione dell’altra.

Matrice bidiagonale:
- bidiagonale inferiore se: a(i,j)=0 per j>i e per i>j+1
- bidiagonale superiore se: a(i,j)=0 per i>j e per j>i+1

Matrice tridiagonale: se a(i,j)=0 per |i-j|>1
In una matrice tridiagonale di dim nxn gli elementi che bisogna effettivamente conservare sono quelli delle tre diagonali cioè sono 3n-2.

Matrice a banda: ampiezza di banda inferiore=p, ampiezza di banda superiore=q  se a(i,j)=0 per i>j+p e per j>i+q

Si consideri la seguente matrice a banda 6×6 con p=1 e q=2

a(1,1) a(1,2) a(1,3)
a(2,1) a(2,2) a(2,3) a(2,4)
a(3,2) a(3,3) a(3,4) a(3,5)
a(4,3) a(4,4) a(4,5) a(4,6)
a(5,4)  a(5,5) a(5,6)
a(6,5) a(6,6)

questa matrice viene memorizzata nel seguente modo:

*            *     a(1,3) a(2,4) a(3,5) a(4,6)
*         a(1,2) a(2,3) a(3,4) a(4,5) a(5,6)
a(1,1) a(2,2) a(3,3) a(4,4) a(5,5) a(6,6)
a(2,1) a(3,2) a(4,3) a(5,4) a(6,5)    *
ossia l’elemento a(i,j) è memorizzato nella colonna di posto j e nella riga di posto 3+i-j=q+1+i-j

Fattorizzazione LU senza pivoting di una matrice tridiagonale e risoluzione dei sistemi lineari associati:
si ha che i fattori L ed U di una matrice tridiagonale (che ammette fattorizzazione LU) sono matrici bidiagonali

Fattorizzazione LU di una matrice partizionata a blocchi:
se abbiamo una matrice tridiagonale (w=p+q+1), conduce alle matrici bidiagonali dove
L-> w=p+1=1+1=2; U-> w=q+1=1+1=2
Gli elementi di U e di A appartenenti alla banda superiore coincidono; gli elementi di L da determinare sono L2 e L3; gli elementi di U da determinare sono le matrici diagonali U1, U2, U3

Come si specializzano gli algoritmi di Forward e Back Substitution per matrici a blocchi?
Si risolve Lz=y O(n^2) operazioni poi Ux=z (z è stato ricavato precedentemente)

ALGORITMO FORWARD:

for i=1 to n do
y[i]=b[i]-L[i]y[i-1]
endfor
(L[1]y[0]=0)

ALGORITMO DI BACK

for i=N to 1 do
U[i]x[i]=y[i]-F[i]y[i+1]
endfor
(F[n]x[n+1]=0)

FATTORIZZAZIONE LU DI UNA MATRICE A BLOCCHI

Supponiamo di avere una matrice partizionata in 9=3×3 blocchi
(A11, A12, A13, A21, A22, A23, A31, A32, A33).
Sappiamo che A=LU.
Effettuando il prodotto:
A11=L11 U11     A12=L11 U12                  A13=L11 U13
A21=L21 U11     A22=L21 U12+L22 U22    A23=L21 U13+L22 U23
A31=L31 U11     A32=L31 U12+L32 U22    A33=L31 U13+L32 U23+L33 U33
Da queste uguaglianze si ricavano le espressioni per il calcolo dei blocchi di L e di U
Ricordando l’algoritmo di fattorizzazione LU abbiamo che fissiamo la colonna e la riga e sotto abbiamo la matrice attiva.
PASSO1:
- fattorizzazione LU del “pannello verticale”
- calcolo un pannello orizzontale di U
- aggiorna la matrice attiva
alla fine del passo 1 abbiamo:
- il primo pannello verticale di L
- il primo pannello orizzontale di U

Nel PASSO 2 scendiamo di un livello quindi alla fine avremo:
- il secondo pannello verticale di L
- il secondo pannello orizzontale di U

ALGORITMO LU BLOCK PARTITIONED

A dcomposta in nxn blocchi di dim nbxnb

For k=1, n step nb do
- applica la fatt LU al pannello A(k:n,k:k+nb-1)
- calcola il pannello U(k:k+nb-1, k+nb:n)
- aggiorna la matrice attiva

Sistema sparso:

Un sistema di equazioni lineari si dice “sparso” se ha molti coefficienti nulli; il grado di sparsità è SP=numero di coefficienti nulli / numero totale di coefficienti. In generale in un sistema dove A=nxm e p è il numero di coefficienti non nulli: SP=(n x m) – p / n x m. Dunque 0=<SP>=1, e più SP è prossimo a 1 maggiore è il grado si sparsità della matrice.

I metodi iterativi:

Per sistemi con elevato grado di sparsità l’algoritmo di Gauss non è molto efficiente in quanto non solo effettua operazioni su coefficienti nulli ma può anche portarli a essere non nulli. Per tale motivo c’è bisogno di metodi alternativi detti iterativi, che lavorano sui coefficienti non nulli. Per tale motivo è anche possibile implementare opportune tecniche di memorizzazione di matrici sparse per migliorare la complessità di spazio. Una di queste tecniche è quella dei tre vettori – CSR -  R contenente gli elementi non nulli per riga della matrice A, IC contente l’indice di colonna in A degli elementi presenti in R, J contente la posizione in R del primo elemento non nullo per ciascuna riga di A.

Metodi iterativi: Jacobi

Procedimento iterativo:a partire da arbitrari valori iniziali delle incognite x1(^0), x2(^0), x3(^0) , esegue una sequenza di iterazioni in ognuna delle quali si calcolano nuovi valori per le incognite utilizzando i valori calcolati nella iterazione precedente. Dunque dato un sistema Ax=b:
ad ogni passo i=1…n   ->   xi(^k+1)=1/aii (bi – sum per j=1 to n con j!=i di (aij  xj(^k) )).
La complessità di tale metodo per il calcolo delle n componenti ad ciascuna iterazione è
Tjac(n)=n(2n-1) operazioni=n^2 operazioni, ma siccome le operazioni vengono effettuate solo sui p coefficienti non nulli (SP=1- p/n^2) allora Tjac(n)= p operazioni= n^2 (1-SP) operazioni

Metodi iterativi: Gauss-Seidel

Il procedimento è simile a quella di Jacobi, la differenza sostanziale è che mentre in Jacobi ad ogni iterazione k il nuovo valore delle incognite è calcolato utilizzando unicamente i valori x1(^k-1), x2(^k-1), x3(^k-1) calcolati all’iterata precedente, in Gauss Seidel invece ad ogni passo k nel calcolare una xi(^k) possono essere utilizzati i valori xj(^k), per j<i e xj(^k-1) per j>=i (ossia i valori delle soluzioni del passo precedente k-1). Ad esempio nel calcolare x2(^k) viene utilizzato x1(^k) e x2(^k-1), x3(^k-1). . Dunque dato un sistema Ax=b:
ad ogni passo i=1…n   ->   xi(^k+1)=1/aii (bi – [sum per j=1 to i-1 di (aij  xj(^k+1))] – [sum per j=i+1 to n di (aij  xj(^k))]). Analogamente a quanto accade per jacobi, Tgs(n)= p operazioni= n^2 (1-SP) operazioni.

Convergenza e consistenza dei metodi iterativi:

In generale Gauss-Seidel converge più velocemente alla soluzione rispetto a Jacobi. Tuttavia i metodi iterativi non sempre convergono alla soluzione del sistema.
Un metodo iterativo si dice convergente se la successione generata dal metodo è convergente, qualunque siano i valori iniziali, cioè se lim (k->inf) di xi(^k)= xi(^*) per ogni i=1…n e per ogni xi(^0) approssimazione iniziale. Se il metodo converge allora esso convergerà alla soluzione; per tale caratteristica i metodi si dicono consistenti, ossia che quando converge esso converge alla soluzione. Un metodo iterativo si dive convergente se ||C||<1, dove ||C|| indica la norma della matrice C nxn dei coefficienti cij del sistema. Inoltre Jacobi converge con certezza anche quando la matrice è a diagonale strettamente dominante. Tali condizioni tuttavia sono solo sufficienti non necessarie in quanto il metodo può convergere anche se queste condizioni non sono soddisfatte.

Efficienza di un metodo iterativo:

La complessità totale di un metodo iterativo è: Ttot(n)= k Tit(n); dove k indica il numero di iterazioni eseguite (parametro dipendente dalla velocità di convergenza) e Tit(n) indica la complessità di tempo di 1 iterazione (parametro dipendente dal costo di ciascuna iterazione). Sia per Jacobi che per Gauss Seidel il numero di operazioni effettuate è relativo solo ai coefficienti p non nulli dunque T(n)= p operazioni= n^2 (1-SP) operazioni.

Velocità di convergenza:

||C|| oltre a garantire la convergenza serve a determinare la velocità di convergenza dato che  quanto più piccolo è questo valore tanto più velocemente si convergerà alla soluzione ottima.
Indicando con eps(^k)=x(^k)- x(^*) l’errore di troncamento ammissibile alla k-esima iterazione (differenza all’iterata k tra l’approssimazione e la soluzione), dove || eps(^k)||<=||C^k || ||eps(^0)||, è possibili trovare il numero minimo di iterazioni per avere || eps(^k)||<tol (tol=tolleranza desiderata): k=[ ln (tol) – ln (||eps(^0)||) ]/ ln (||C||).
La convergenza del metodo equivale alla convergenza a 0 dell’errore di troncamento alla k-esima iterazione, cioè di di eps(^k).

Criteri di arresto:

Il metodo iterativo può essere arrestato o agendo sull’errore assoluto e in tal caso il criterio d’arresto sarà: ||x(^k) – x*||<=tol, dove in generale tol=10(^-m) è l’approssimazione corretta a m cifre decimali; oppure sull’errore relativo ||x(^k) – x*|| / ||x*||<=tol, dove in generale tol=10(^-m) è l’approssimazione corretta a m-1 cifre significative; tuttavia utilizzando questi criteri si presuppone la conoscenza della soluzione x* ottima e quindi la necessità di determinare stime calcolabili dell’errore ad ogni iterazione. Mentre criteri d’arresto effettivamente utilizzabili sono quelli basate su quantità già calcolate e quindi basati o sulla stima dell’errore assoluto ||x(^k+1) – x(^k)||<=tol; o sull’errore relativo ||x(^k) – x(^k-1)|| / ||x(^k-1)||<=tol.
Altro criterio di arresto, aggiuntivo e/o sostitutivo, è quello basato sull’impostazione di un numero massimo Maxit di iterazioni che permette l’arresto anche nel caso in cui il metodo non converge e limita il costo computazionale del procedimento iterativo.

In questo articolo si illustra i vari tidi di matrice, e i vari tipi di memorizzazione di matrice. Dal modo in cui sono collocati gli elementi all’interno di una matrice, possiamo distinguere vari tipi

Matrice SINGOLARE

e’ una matrice triangolare (sueriore o inferiore), dove almeno un elemento
a[i,i] della diagonale e’ uguale a 0.
La caratteristica di una matrice triangolare e’ che se fa parte di un
sistema lineare, allora il sistema ammette infinite soluzioni.
Il determinante di una matrice singolare e’ uguale a zero.

Matrice A DIAGONALE DOMINANTE

matrice quadrate appartenente a R[nxn] di dice a diagonale dominante se per
ogni i=1,2,…,n vale:
n
abs(a[i,i]) >=  sum  abs(a[i,j]) quando i != j
i,j=1
se vale il segno > allora di dice DIAGONALE STRETTAMENTE DOMINANTE

Matrice DEFINITA POSITIVA

una matrice quadrata A appartenente a R[nxn], che e’ simmetrice, si dice
definita positiva se per qualsiasi vettore x appartenente a R[n], e x != 0,
risulta:  x(trasposto) * A * x > 0

Matrice ORTOGONALE

una matrice Q e’ ortogonale se la sua inversa e’ proprio uguale alla sua
trasposta.
Da Q * Q(inversa) = I  segue che Q * Q(trasosta) = I

Matrice CIRCOLANTE

e’ una matrice dove il vettore riga k-esimo e’ ottenuto dal vettore riga
(k-1)-esimo shiftato circolarmente di una posizione verso destra:
Esempio:
1 2 3 4 5
5 1 2 3 4
4 5 1 2 3
3 4 5 1 2
2 3 4 5 1

Matrici di TOEPLITZ

Sono uguali alle Matrici CIRCOLANTI, con la caratteristica che non viene
effettuato lo shift circolare, ma ad ogni shift puo’ etrare un nuovo
elemento. Esempio
1 2 3 4 5
9 1 2 3 4
6 9 1 2 3
0 6 9 1 2
1 0 6 9 1
Una matrice di TOEPLITZ puo’ essere immersa in una matrice CIRCOLANTE piu’
grande in modo da poter usare algoritmi per matrici CIRCOLANTI.

Matrice SIMMETRICA

Una matrice si dice simmetrica quando A[i][j] = A[j][i]

Matrice BIDIAGONALE (superiore o inferiore)

Bidiagonale inferiore se: a(i,j)=0 per j>i e per i>j+1
Bidiagonale superiore se: a(i,j)=0 per i>j e per j>i+1

Matrice TRIDIAGONALE

Matrice tridiagonale: se a(i,j)=0 per |i-j|>1
In una matrice tridiagonale di dim nxn gli elementi che bisogna effettivamente conservare
sono quelli delle tre diagonali cioË sono 3n-2.

Matrice SPARSA

E’ una matrice a[n,m] in cui ci sono molti elementi uguali a 0. La sparsita’ di una matrice
si misura grazie al “Grado di sparsita’”:

numero coefficienti nulli
SP = —————————-
numero totale coefficienti

Quando gli elementi nulli sono 0, allora  -> SP = 0 |
|-> Quindi 0 <= SP <= 1
Quando non ci sono elementi nulli, allora -> SP = 1 |

La matrice e’ molto sparsa quando SP e’ molto vicino a 1.

Matrice A BANDA

Ampiezza di banda inferiore=p, ampiezza di banda superiore=q  se a(i,j)=0 per i>j+p e per j>i+q

CONFRONTO: SIMMETRICA DIAGONALE DOMINANTE E SIMMETRICA DEFINITA POSITIVA

|-Simmetrica                        |-Simmetrica
se   A = |                         =>    A = |                         ?
|-Diagonale dominante               |-Definita positiva

Ovvero quando una matrice simmetrica a diagonale dominante e’ anche definita
positiva? L’affermazione e’ vera quando A e’:
- non singolare (det(A)>0)
- simmetrica
- a diagonale dominante
- ha gli elementi sulla diag non negativi

Tipi di Memorizzazione per una Matrice

A secondo del tipo di matrice, possiamo scegliere il metodo di memorizzazione più adatto alle nostre esigenze. Le memorizzazioni sono spesse scelte per ottimizzare lo spazio su disco e i calcoli sulle matrici, come:

1) Prodotto scalare tra due vettori
Da come risultato uno scalare.

2) Prodotto Matrice-Matrice
Basato sul prodotto scalare di sue vettori.
A[nxm] * B[mxp] = C[nxp]

3) Norma 1 di una matrice
Data una matrice facciamo la somma degli elementi riga per riga. La
norma 1 sara’ uguale al massimo, in valore assoluto, di tutte le
somme ottenute.

4) Norma infinito di una matrice
Data una matrice facciamo la somma degli elementi colonna per colonna. La
norma 1 sara’ uguale al massimo, in valore assoluto, di tutte le
somme ottenute.

Qui vi sono alcuni metodi di memorizzazione:

BAND STORAGE

Questa memorizzazione e’ utile per memorizzare matrici a banda.
Si consideri la seguente matrice a bandauna matrice 6×6 con p=1 e q=2

a(1,1) a(1,2) a(1,3)
a(2,1) a(2,2) a(2,3) a(2,4)
a(3,2) a(3,3) a(3,4) a(3,5)
a(4,3) a(4,4) a(4,5) a(4,6)
a(5,4) a(5,5) a(5,6)
a(6,5) a(6,6)

questa matrice viene memorizzata nel formato BAND STORAGE nel seguente
modo:

*      *   a(1,3) a(2,4) a(3,5) a(4,6)
*   a(1,2) a(2,3) a(3,4) a(4,5) a(5,6)
a(1,1) a(2,2) a(3,3) a(4,4) a(5,5) a(6,6)
a(2,1) a(3,2) a(4,3) a(5,4) a(6,5)    *

PACKED STORAGE

Questa memorizzazione e’ utile per matrici simmetriche oppure triangolari (inferiori o superiori).
Si consideri la seguente matrice triangolare:

a(1,1) a(1,2) a(1,3) a(1,4) a(1,5)
a(2,2) a(2,3) a(2,4) a(2,5)
a(3,3) a(3,4) a(3,5)
a(4,4) a(4,5)
a(5,5)

questa matrice memorizzata in PACKED STORAGE per righe:

a(1,1) a(1,2) a(1,3) a(1,4) a(1,5) a(2,2) a(2,3) a(2,4) a(2,5) a(3,3) a(3,4) a(3,5) a(4,4) a(4,5) a(5,5)

mentre memorizzata in PACKED STORAGE per colonne:

a(1,1) a(1,2) a(2,2) a(1,3) a(2,3) a(3,3) a(1,4) a(2,4) a(3,4) a(4,4) a(1,5) a(2,5) a(3,5) a(4,5) a(5,5)

MEMORIZZAZIONE CON TRE VETTORI

Questa memorizzazione e’ utile per matrici sparse.
Dicendo “nz” il numero di elementi non nulli dela matrice sparsa A ed n la sua dimensione, si memorizza
la matrice in tre vettori:

R[nz]  = (elementi non nulli riga per riga)
J[nz]  = (indici di colonna degli elementi di R[])
I[n+1] = (posizione in R del primo elemento non nullo di ogni riga di A; L’ultimo elemento e’ I(n+1)=nz+1)

Iniziamo a parlare di cose più serie, oggi creeremo una finestra!
Per creare una finestra, bisogna fare una semplice chiamata alla funzione CreateWindow!

NON E’ TUTTO!

CreateWindow richiede dei parametri!

Il primo rappresenta la “classe di finestra” da creare… Come vedremo, esistono delle classi gia predefinite, come per esempio i pulsanti(button). Questa classe di finestra di solito è connessa ad una “procedura di finestra” chiamata anche “WINDOW PROCEDURE”. Questa procedura serve a processare gli eventi che arrivano alla finestra e la vedremo in dettaglio tra poco.

Facciamo quindi una panoramica sull’architettura di Windows..

Uno sguardo all’architettura di Windows

Di
solito cosa potrebbe essere per noi una finestra? Beh semplicemente
potrebbe essere quella che abbiamo in casa nostra ma parlando per
una volta seriamente, immaginiamo di avere un contenitore principale!
Di solito contiene un titolo, un icona a fianco, e quei pulsanti di
riduzione e chiusura, e che… possiamo spostare. A
volte contiene anche un menù.. altre volte no.. Anche
le finestre di dialogo sono finestre.

Le
finestre a sua volta contengono le caselle di testo, I pulsanti…
Anche queste… SONO FINESTRE!
Più in dettaglio sono FINESTRE
FIGLIE(Child
Windows), i comuni controlli che troviamo
nelle applicazioni.

L’
utente vede queste finestre come oggetti sullo schermo e interagisce
direttamente con loro usando la tastiera o il mouse. La finestra(cioè
contenitore e widgets vari)
riceve l’input dell’utente sotto forma di MESSAGGI.
Una finestra può
inviare messaggi anche ad altre finestre!
Capire come usarli, è importante per imparare a scrivere
applicazioni Windows.

Facendo
un esempio fesso; come sai, molti programmi a finestre, hanno un
bordo che può essere ridimensionato. Quando cambi la
dimensione della finestra il programma risponde ridimensionando ed
adattando gli elementi al suo interno.

Questo
perché Windows infatti SA
di quello che succede, infatti, è lui ad inviare i messaggi
alla finestra indicando il ridimensionato, e il programma a questa
risposta ridimensiona la finestra e adatta il contenuto. (Vabbe
vabbe… Manco io ci ho capito un accidente di questo… Per ora!)

-
Cosa potrebbe significare?

- Come può un sistema
operativo inviare messaggi ad un programma?

Quando
io dico che Windows invia messaggi ad un programma, intendo dire che
Windows chiama una funzione nel programma, una funzione scritta da
te!.. E che è una parte essenziale del programma. I parametri
di questa funzione descrivono un particolare messaggio inviato da
Windows e ricevuto dal tuo programma. Questa funzione è
conosciuta come la WINDOW
PROCEDURE(Ascoltatore di finestra, nà
cosa simile).

AHHH
Finalmente si capisce una mezza cosa!

Ad
ogni finestra che un programma può creare, è associata
una WINDOW PROCEDURE. Questa funzione puoi scriverla nel tuo
programma o anche in una DLL separata; quindi, per ricapitalore:
Windows invia messaggi alla finestra chiamando la Window Procedure,
la funzione sempre menzionata elabora e processa il messaggio(in base
al tipo di evento farà qualcosa), infine ritorna il controllo
a Windows!

CAPITO?

Abbiamo
accennato poco fa che ogni finestra è sempre creata in base ad
una sua classe.
Qquesta classe di finestra
identifica la sua WINDOW PROCEDURE
che processa i messaggi che ci arrivano… L’uso della classe di
finestra(WINDOW CLASS)
permette anche di creare più istanze della stessa finestra che
a sua volta usano la stessa WINDOW PROCEDURE!

CHE
FIGATA!

Per
esempio, tutti i pulsanti in tutti i programmi di Windows sono basati
su una classe di finestra(Quei button che clicchiamo, abbiamo detto
che anche loro sono finestre!). Avendo fatto la corrispondenza che ad
una classe di finestra(WINDOW CLASS) corrisponde una WINDOW
PROCEDURE, nei bottoni la WINDOW PROCEDURE è locata
in una DLL particolare di Windows che processa i messaggi di tutti i
pulsanti.

Spesso
i messaggi che arrivano alla WINDOW PROCEDURE sono input da
tastiera o da mouse. Per esempio, consideriamo un pulsante e
premiamolo; Windows riconosce che il pulsante è stato ciccato.
Altri messaggi dicono ad una finestra che inizia un ridimensionamento
o quando la finestra deve essere ridisegnata.

Quando
un programma Windows inizia la sua esecuzione, Windows crea per lui
una coda di messaggi in cui può immagazzinare i messaggi che
arrivano alla finestra. Di solito un normale programma Windows
include un piccolo pezzo di codice chiamato MESSAGE
LOOP che
preleva i messaggi dalla coda, li traduce e li invia alla WINDOW
PROCEDURE…
Altri messaggi sono inviati direttamente alla Window Procedure senza
essere messi nella coda di messaggi. Tutto
comincia a prendere forma!

E nella prossima puntata vedrete…

Il w3c ha definito il linguaggio XQuery 1.0; usa la sintassi delle espressioni di XPath  2.0, con l’aggiunta delle cosiddette espressioni FLWOR per la formulazione di query complesse. Il risultato è un linguaggio di programmazione funzionale, dichiarativo, con somiglianze con il vecchio SQL.

Per effettuare delle query xquery su un file XML possiamo usare delle librerie come BaseX e Saxon. Purtroppo attualmente Saxon non è un prodotto del tutto gratuito, quindi scegliamo di usare BaseX, un processore Xquery-XPath open source.

In realtà BaseX, oltre ad essere utlilizzabile come libreria all’interno del linguaggio Java, ci mette a disposizione un’interfaccia grafica dalla quale possiamo effettuare query su file XML ben formati arbitrari.

Primo esempio di query

La prima cosa da fare è inserire i file jar di BaseX nel build path del nostro progetto; la seconda è assicurarsi di avere java 1.6 (non funziona con java 1.5) perché BaseX utilizza il package javax.xml.stream.

Questo è un sempio dove si esegue la query //li sul file ‘input‘:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import javax.xml.xquery.XQConnection;
import javax.xml.xquery.XQDataSource;
import javax.xml.xquery.XQPreparedExpression;
import javax.xml.xquery.XQResultSequence;
 
public final class XQueryAPIExample {
 /** Database Driver. */
 static final String DRIVER = "org.basex.api.xqj.BXQDataSource";
 
 public static void main(final String[] args) throws Exception {
 
 // Gets the XQDataSource for the specified Driver.
 XQDataSource source = (XQDataSource) Class.forName(DRIVER).newInstance();
 
 // Creates an XQConnection
 XQConnection conn = source.getConnection();
 
 // Prepares the Expressionwith the Document and the Query.
 XQPreparedExpression expr = conn.prepareExpression("doc('input')//li");
 
 // Executes the XQuery query.
 XQResultSequence result = expr.executeQuery();
 
 // Gets all results of the execution.
 while(result.next()) {
 // Prints the results to the console.
 System.out.println(result.getItemAsString(null));
 }
 
 }
}

Questo esempio funziona solo se il file XML interrogato non dichiara nessun namespace.

Query in presenza di namespace

Supponiamo adesso di interrogare un file XML con namespace… ad esempio un file in formato XML Mpeg-7 che usa i seguenti namespace:
xmlns=”urn:mpeg:mpeg7:schema:2001″
xmlns:mpeg7=”urn:mpeg:mpeg7:schema:2001″
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

Per far riconoscere i namespace dobbiamo dichiararli nel prologo della xquery in questo modo:
declare default element namespace “urn:mpeg:mpeg7:schema:2001″
declare  namespace mpeg7 = “urn:mpeg:mpeg7:schema:2001″
declare  namespace xsi = “http://www.w3.org/2001/XMLSchema-instance”

Questo è il codice che esegue la query sul file file/video/extract.xml:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

String prologoQuery = "" +
 "declare default element namespace \"urn:mpeg:mpeg7:schema:2001\"; " +
 "declare  namespace mpeg7 = \"urn:mpeg:mpeg7:schema:2001\"; " +
 "declare  namespace xsi = \"http://www.w3.org/2001/XMLSchema-instance\"; ";
 
 // Gets the XQDataSource for the specified Driver.
 XQDataSource source = (XQDataSource) Class.forName(DRIVER).newInstance();
 // Creates an XQConnection
 XQConnection conn = source.getConnection();
 // Prepares the Expressionwith the Document and the Query.
 //XQPreparedExpression expr = conn.prepareExpression("<xml>1 + 2 = { 1+2 }</xml>/text()");
 //XQPreparedExpression expr = conn.prepareExpression("doc('file/video/20090201_video_15213221.xml')//meta");
 XQPreparedExpression expr = conn.prepareExpression(prologoQuery + " doc('file/video/extract.xml')//Name");
 
 // Executes the XQuery query.
 XQResultSequence result = expr.executeQuery();
 // Gets all results of the execution.
 while(result.next()) {
 //element = (org.w3c.dom.Element) result.getObject();
 System.out.println(result.getItemAsString(null));
 }

Nella riga 18 è commentato un altro modo per usare gli oggetti restiuiti dalla query, che ci restituisce il risultato come elementi della struttura DOM del file XML.