Corso di Metodi Computazionali della Fisica

Alessandro Vicini (Università di Milano)

Introduzione a Mathematica 2

Mathematica può essere utilizzato come:

• calcolatore scientifico/simbolico
• manipolatore di formule e/o oggetti grafici

In Mathematica l'unità elementare è l' "espressione"

Un'espressione può essere:

• un numero
• un simbolo
• una stringa
• una lista
• una regola di sostituzione
• un oggetto grafico
• un file
• uno stream
• ...

Il tipo di espressione pu`o essere ottenuto con il comando Head[expr]

In Mathematica QUALUNQUE enunciato ha la struttura:Op[el1,el2,....]

dove Op indica un operatore, mentre el1, el2,... sono una lista di argomenti su cui l'operatore agisce.

Un elemento può a sua volta avere questa struttura (struttura ad albero).

Ogni espressione è descritta in termini dei suoi livelli e del numero delle sue "foglie".

La struttura di un enunciato può essere ottenuta esplicitamente con il comando FullForm.

esempio: utilizzando FullForm, confrontare a + b + c con a b c

Mathematica è un programma di manipolazione algebrica:

effettua in modo formale operazioni su oggetti

è possibile introdurre operatori che godono di proprietà algebriche (associatività, commutatività, distributività) (Flat, Orderless, Listable)

esempio: SetAttributes[f,Orderless]

Ogni operazione modifica una o più parti di una espressione.

Questo risultato viene ottenuto con:

• regole di sostituzione
• applicazione di funzioni

Le due possibilità si differenziano per i modi e i tempi in cui l'espressione viene modificata.

Regole di sostituzione: a -> b

FullForm[ a -> b] = Rule[a,b]

E' comodo accorpare diverse sostituzioni in una lista

rules = {a1 -> b1, a2 -> b2, ...}

Le regole di sostituzione vengono applicate, una per volta, su ogni sottoespressione, con i comandi Replace e RepeatedReplace

FullForm[expr /. rules] = Replace[expr, rules]

FullForm[expr //. rules] = RepeatedReplace[expr, rules]

Nel secondo caso le regole vengono riapplicate fin quando il risultato non rimane invariato.

Le regole di sostituzione agiscono solo quando vengono applicate con un Replace.

Definizioni immediate e ritardate

Distinguiamo le regole di sostituzione dalle definizioni,
poiché le regole di sotituzione agiscono solo sulle espressioni coinvolte dal comando dove esse compaiono,
mentre le definizioni sono sempre "attive" e vengono cercate e valutate da Mathematica ogni volta che consideriamo un'espressione.

Valutazione immediata di una definizione:

x=3;

f[x_] = a x^2 + b;

Print[f[y]];

Valutazione ritardata di una definizione:

x=3;

g[x_] := a x^2 + b;

Print[g[y]];

L'assegnazione e la sostituzione possono essere immediate o ritardate (=, :=, ->, :>).

La presenza del : indica che il secondo membro deve venire valutato SOLO quando la definizione viene utilizzata.

Nel secondo caso la variabile x=3 e la variabile x della definizione sono per Mathematica due simboli completamente distinti.

Funzioni

Ci sono vari modi di pensare a una funzione, al suo scopo e al suo utilizzo:

• abbreviazione di lunghe formule

f[x_] := a x^2 + b x + c;

sp[x_List, y_List] := Sum[ x[[i]] y[[i]], { i,1,Length[x] }];

s[x_SurfaceGraphics,a_Real,b_Real,c_Real] := Show[ x, ViewPoint-> {a,b,c}]

• procedure da applicare ad una espressione o a parti di essa

agire su di una espressione significa considerarla come argomento di una operazione

l'operazione che si intende applicare sarà quindi la Head di una nuova espressione,

mentre come argomento ci sarà l'espressione di partenza

esempio : expr-> f[expr]

in certi casi, data un'espressione con certi argomenti, si vuole agire proprio su quegli argomenti

sostituendo la Head di partenza (non funziona con i tipi elementari);

per agire sulla Head: Apply[ f, g[a,b,c]] = f @@ g[a,b,c] = f[a,b,c]

spesso, data una lista di elementi (p.es. una somma di addendi è una lista di addendi su cui si agisce con Plus),

si vuole compiere una certa operazione f su ciascuno di essi

per agire sugli elementi: Map[ f, {a,b,c} ] = {f[a],f[b],f[c]};

Map[ f, {{a1, a2}, {b1, b2}, {c1, c2}} ] ={f[a1, a2], f[b1, b2], f[c1, c2]};

f = ( #[[2]] ) &; Map[ f, {{a1, a2}, {b1, b2}, {c1, c2}} ] = {a2, b2, c2};

Pattern

Si chiama pattern un modo di rappresentare in maniera generica una o più espressioni di Mathematica:

x_: una espressione di Mathematica;

x__ : una o più espressioni di Mathematica;

x___ : nessuna, una o più d'una espressione.

MatchQ[expr,pattern] = True/False a seconda che expr soddisfi o meno il pattern assegnato.

MatchQ[ a+b, x_] = True

MatchQ[ a+b, Plus[x_,y_,z_]] = False

MatchQ[ a+b, Plus[x_,y_,z___]] = True

x_h, x__h, x___h sono una, una o più, zero una o più espressioni aventi h come Head

MatchQ[5, x_Integer] = True

MatchQ[5, x_Real] = False

Esercizio

Scrivere la definizione di una funzione che, dato un prodotto di operatori a e a tali che [a, a†] = k, li riordini in modo che tutti gli a† risultino alla fine della manipolazione a sinistra

es.: a1 a† 2 a3= a† 2 a1 a3 + k a3

Semplificazioni

Expand[expr] sviluppa tutti i prodotti presenti in expr e restituisce una somma di termini.

Simplify[expr] cerca di raccogliere a tutti i livelli i fattori comuni, mettendo in evidenza, dove possibile, delle sottostrutture.

Factor[expr] cerca di porre expr in forma fattorizzata.

Together[expr] Mette tutti i termini di expr con un denominatore comune.

Apart[expr] Sviluppa una espressione razionale fratta come somma di frazioni elementari.

Collect[expr,{var1,var2,...},Method->tiposimpl] raccoglie in expr le potenze (anche negative). di var1; in ciascun coefficiente raccoglie le potenze di var2, etc; ciascun coefficiente viene quindi semplificato utilizzando tiposimpl come azione.

Coefficient[ expr, form, power] restituisce il coefficiente da cui è moltiplicato form^power all'interno di expr.

Esercizi:

1) Utilizzando MatchQ, implementare una nostra funzione myCoefficient.

2) Utilizzando Coefficient, implementare una nostra funzione myCollect.