Mathematica Dispense 2011

Tecniche Informatiche per la Fisica
A.A. 2011-2012
Testi di S. Berardi, M. Grangetto e M. Billo'
Basato sulle dispense di Laboratorio di Calcolo I del 1998-2007 e di TIF del 2008 e 2009
Introduzione e motivazioni.
Mathematica e' uno strumento per il calcolo simbolico e numerico, include la possibilita' di scrivere programmi, di
visualizzare in molti modi funzioni, superfici, grafi, fittare dati sperimentali, ...
Esempio 1 Risoluzione di un sistema lineare
In[1]:=
Solve[{16 x + 3 y - 2 z = 2,
x - 4 y + z = 0,
-7 x + 9 z = 1}, {x, y, z}]
Out[1]= x -
77
568
, y -
25
284
, z -
123
568
Esempio 2 Disegno di un ellisse e una retta date in forma parametrica per visualizzare le loro intersezioni
In[2]:= ellisse =
ParametricPlot[{2 Cos[t] + 1, Sin[t] - 1 / 2}, {t, 0, 2 Pi}, AspectRatio - Automatic]
Out[2]=
1 1 2 3
1.5
1.0
0.5
0.5
In[3]:=
ellisse =
ParametricPlot[{2 Cos[t] + 1, Sin[t] - 1 / 2}, {t, 0, 2 Pi}, AspectRatio - Automatic]
retta = ParametricPlot[{1 + t, t / 2}, {t, -2, 2},
AspectRatio - Automatic, PlotStyle - Red]
Show[ellisse, retta]
Out[3]=
1 1 2 3
1.5
1.0
0.5
0.5
Out[4]=
1 1 2 3
1.0
0.5
0.5
1.0
Out[5]=
1 1 2 3
1.5
1.0
0.5
0.5
Esempio 3. Fit di un insieme di dati. Il Fit consiste nel cercare la formula che meglio approssima un
insieme di dati in un insieme di formule dato. In questo esempio cerchiamo di approssimare un insieme di dati
attraverso una equazione di secondo grado.
In[6]:=
data = {{-2.`, 7.6}, {-1.75`, 6.1}, {-1.5`, 5.12},
{-1.25`, 4.2}, {-1., 3.18}, {-0.75`, 2.5}, {-0.5`, 2.1},
{-0.25`, 1.49}, {0.`, 1.27}, {0.25`, 1.02}, {0.5`, 1.1}, {0.75`, 1.12},
{1.`, 1.24}, {1.25`, 1.58}, {1.5`, 1.92}, {1.75`, 2.58}, {2.`, 3.22}};
In[7]:= data
Out[7]= {{-2., 7.6], {-1.75, 6.1], {-1.5, 5.12], {-1.25, 4.2], {-1., 3.18],
{-0.75, 2.5], {-0.5, 2.1], {-0.25, 1.49], {0., 1.27], {0.25, 1.02], {0.5, 1.1],
{0.75, 1.12], {1., 1.24], {1.25, 1.58], {1.5, 1.92], {1.75, 2.58], {2., 3.22]]
2 Mat hemat ica- Dispense- 2011. nb
In[8]:=
ListPlot[data, PlotRange - {{-2, 2}, {0, 8}}]
Out[8]=
2 1 0 1 2
2
4
6
8
In[9]:=
yfit = Fit[data, {1, x, x^2}, x]
Out[9]= 1.24232 - 1.04265 x + 1.02826 x
2
In[10]:=
fitted = Table[{x, yfit}, {x, -2, 2, 0.25}];
In[11]:=
ListPlot[{data, fitted}, PlotStyle - {Blue, Red},
Joined - {False, True}, PlotRange - {{-1, 2}, {0, 3}}]
Out[11]=
1.0 0.5 0.0 0.5 1.0 1.5 2.0
0.5
1.0
1.5
2.0
2.5
3.0
Esempio 4 Le prime cento cifre decimali di r
Mat hemat ica- Dispense- 2011. nb 3
In[12]:=
N[Pi, 1000]
Out[12]= 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998
6280348253421170679821480865132823066470938446095505822317253594081284811174502841
0270193852110555964462294895493038196442881097566593344612847564823378678316527120
1909145648566923460348610454326648213393607260249141273724587006606315588174881520
9209628292540917153643678925903600113305305488204665213841469519415116094330572703
6575959195309218611738193261179310511854807446237996274956735188575272489122793818
3011949129833673362440656643086021394946395224737190702179860943702770539217176293
1767523846748184676694051320005681271452635608277857713427577896091736371787214684
4090122495343014654958537105079227968925892354201995611212902196086403441815981362
9774771309960518707211349999998372978049951059731732816096318595024459455346908302
6425223082533446850352619311881710100031378387528865875332083814206171776691473035
9825349042875546873115956286388235378759375195778185778053217122680661300192787661
1195909216420199
Vi sono molti programmi con caratteristiche di questo tipo (Maple, Maxima, ...), alcuni piu' rivolti alla manipo-
lazione simbolica, altri piu' a qualla numerica, etc. La logica di base pero' non e' molto diversa.
In questo corso si usa Mathematica ma si potrebbe benissimo usare un altro programma. Cio' che conta e' che
impariate la logica di base che permette di sfruttare strumenti di questo tipo.
Il punto fondamentale, secondo me, e' il seguente: se imparate a usare un po' Mathematica o programmi analoghi,
cio' vi permettera'di concentrarvi maggiormente sull'aspetto concettuale dei problemi.
Esempio 5 Innumerevoli problemi che affronterete nella vostra futura vita da studenti di fisica e poi di fisici
(non solo in Geometria e algebra lineare!) si esprimono molto efficacemente in termini di oggetti detti matrici,
che studierete a fondo nel corso di Geometria Lineare. All'inizio, pero', spesso si tende a non sfruttare questa
possibilita' perche'intimiditi dalla lunghezza dei calcoli richiesti per moltiplicare due matrici o invertire una
matrice. Se un'equazione puo' essere messa nella forma
(1) M X = A
dove M e' una matrice nota, A un vettore noto, X un vettore di incognite, la soluzione generale e' immediata (se
siamo in grado di calcolare la matrice inversa M
-1
di M e il prodotto di M
-1
e di A):
(2) X = M
-1
A
Supponiamo pero' di avere 4 incognite, e che M sia dunque una matrice 4 x 4, ad esempio
M =
2 5 0 7
-h 2 -1 9 h
3 2 -6 0
-3 h h 9 4
Calcolarsi l' inversa a mano e' decisamente un' impresa scoraggiante! Avendo pero' un programma di calcolo
simbolico a disposizione, lui fara' questo passo puramente tecnico per noi. Ad esempio, in Mathematica,
inseriamo i vettori e la matrice:
In[13]:=
X = {x1, x2, x3, x4}; (+ vettore delle incognite +)
A = {1, h, 2, 3 h}; (+ vettore noto +)
M = {{2, 5 , 0, 7}, {-h, 2 , -1, 9 h}, {3, 2, -6, 0}, {-3 h, h, 9, 4 }};
(+ matrice dei coeff +)
Quindi calcoliamo la matrice inversa:
In[16]:=
MatrixForm[Inverse[M]]
Out[16]//MatrixForm=
-40+162 h+54 h
2
238-1074 h+960 h
2
-6-42 h
238-1074 h+960 h
2
106-398 h
238-1074 h+960 h
2
70-270 h
238-1074 h+960 h
2
-12-267 h+162 h
2
238-1074 h+960 h
2
141-126 h
238-1074 h+960 h
2
8+246 h
238-1074 h+960 h
2
21+150 h
238-1074 h+960 h
2
-24-8 h+81 h
2
238-1074 h+960 h
2
44-63 h
238-1074 h+960 h
2
16+62 h-160 h
2
238-1074 h+960 h
2
42-85 h
238-1074 h+960 h
2
54-9 h+6 h
2
238-1074 h+960 h
2
-99+102 h
238-1074 h+960 h
2
-36-62 h
238-1074 h+960 h
2
-35-30 h
238-1074 h+960 h
2
Infine moltiplichiamo la matrice inversa per A e semplifichiamo:
In[17]:= MatrixForm[Inverse[M].A]
2 (106-398 h)
238-1074 h+960 h
2
+
3 (70-270 h) h
238-1074 h+960 h
2
+
(-6-42 h) h
238-1074 h+960 h
2
+
-40+162 h+54 h
2
238-1074 h+960 h
2
(141-126 h) h
238-1074 h+960 h
2
+
3 h (21+150 h)
238-1074 h+960 h
2
+
2 (8+246 h)
238-1074 h+960 h
2
+
-12-267 h+162 h
2
238-1074 h+960 h
2
3 (42-85 h) h
238-1074 h+960 h
2
+
(44-63 h) h
238-1074 h+960 h
2
+
2 16+62 h-160 h
2
,
238-1074 h+960 h
2
+
-24-8 h+81 h
2
238-1074 h+960 h
2
2 (-36-62 h)
238-1074 h+960 h
2
+
3 (-35-30 h) h
238-1074 h+960 h
2
+
h (-99+102 h)
238-1074 h+960 h
2
+
54-9 h+6 h
2
238-1074 h+960 h
2
In[18]:=
MatrixForm[Simplify[Inverse[M].A]]
86-215 h-399 h
2
119-537 h+480 h
2
4+429 h+486 h
2
238-1074 h+960 h
2
8+286 h-557 h
2
238-1074 h+960 h
2
-18-337 h+18 h
2
238-1074 h+960 h
2
Qundi, l' unica cosa di cui dobbiamo preoccuparci e' di come arrivare all' equazione (1) e di sapperla risolvere
in forma generale come in (2). Tutti questi non sono certo problemi da poco, ma la buona notizia e che possi-
amo delegare la parte puramente meccanica della soluzione a un linguaggio di programmazione.
In questo breve corso si analizzeranno una minima parte delle capacita di Mathematica, quelle che saranno piu'
immediatamente utili per il corso di Geometria e Algebra lineare 1 (di cui queste lezioni fanno parte) e per i
laboratori di Sperimentazione di fisica che seguirete piu' avanti, dove questo programma e' utilizzato per l'analisi
dei dati (per esempio, per calcolare un Fit).
1) Mathematica ci serve come ausilio per calcolare, visualizzare e capire meglio Geometria e l' analisi dei dati.
2) Fare esercizi motivati da Geometria e analisi dati e' un mezzo per imparare la logica di Mathematica (e di
programmi simili).
Lezione 1: Generalit, Calcolo numerico.
1. Prime operazioni. Scrivere e calcolare 2+2, 2*2, 2-2, 2/2, 2^2. Dovete scrivere questi calcoli uno alla volta,
oppure separarli con un "a capo" (ENTER). Per valutare le operazione utilizzare SHIFT-ENTER. Le operazioni
inserite, e separate da ENTER formano un "Cell" (cella), che costituisce l'unita' base di un foglio (o notebook)
Mathematica. La cella e' contraddistinta da una parentesi quadra sul lato destro della finestra. La cella puo' essere
manipolata una volta selezionata la parentesi corrispondente (selezionare e cancellare con il tasto DELETE oppure
operazioni pi' complesse disponibili dal menu Cell nella barra degli strumenti in alto).
In[19]:= 2 + 2
2=2
2 - 2
2[ 2
2^2
Out[19]= 4
Out[20]= 4
Out[21]= 0
Out[22]= 1
Out[23]= 4
2. Precedenza degli operatori. Mathematica, come tutti i linguaggi di programmazione, applica le operazioni con
regole fisse di precedenza. Per esempio e' chiaro che in un espressione algebrica la moltiplicazione/divisione ha
sempre precedenza rispetto alla somma. Per forzare l'ordine con cui svolgere le operazioni occorre usare solo e
soltanto le parentesi tonde (). Non e' corretto usare { } oppure [ ] che assumono significati completamente diversi
come vedremo nel seguito. Se due costanti o simboli non sono separati da alcuna operazione ma solo da spazi
viene implicitamente assunta l'operazione di moltiplicazione. Le operazioni non devono necessariamente coinvol-
gere solo costanti numeriche: si possono anche utilizzare simboli alfanumerici (escludendo i caratteri speciali come
parentesi, punti, virgola, +,*,-,/, _ ,ecc). Qualsiasi sequenza alfanumerica (cioe' di lettere e numeri), con il vincolo
che il primo simbolo della sequenza sia una lettera e non sia un valore numerico), viene identificata come una
variabile: dunque a,c,d, ma anche c5a sono variabili. Le variabili compaiono scritte in un colore particolare.
Eseguire i calcoli 5+2*6, (5+2)*6, 3*2^2, (3*2)^2, a+ 2 * c + d, (a+4)*c, 5c +8, c5a +8
In[24]:= 5 + 2=6
(5 + 2) =6
3=2^2
(3=2) ^2
a + 2 =c + d
(a + 4) c
5 c + 8
c5a + 8
Out[24]= 17
Out[25]= 42
Out[26]= 12
Out[27]= 36
Out[28]= a + 2 c + d
Out[29]= (4 + a) c
Out[30]= 8 + 5 c
Out[31]= 8 + c5a

3. Come dare un comando. Un comando di Mathematica si scrive come segue:
Command[e1, e2, ..., en]
Un comando inizia sempre con la maiuscola e accetta una serie di parametri e1,e2,...,en racchiusi tra parentesi
quadre [ ] e separati da virgole.
e1, e2, ..., en sono espressioni, che possono a sua volta essere costruita con delle costanti, con le operazioni +,*,-,/,
^ (dove x*y = xy e x^y = x
y
), oppure con altri comandi.
In presenza di uno spazio, ma mancanza di un segno di operazione, Mathematica sottointende un prodotto: 2 2
22.

3 bis. Gli errori pi comuni (a partire dai pi frequenti)
command[e1, e2, ..., en]
(con la c minuscola)
Command(e1, e2, ..., en)
(con la parentesi tonda, se n=1 viene interpretato come: Command*e1)
Command[e1 e2 ... en]
(senza virgole, viene intepretato un prodotto: Command[e1*e2*...*en])
Command(e1, , e2, ..., en)
(una virgola di troppo, viene capito: Command(e1,Null, e2, ..., en) dove Null la costante = comando vuoto).
Provare i comandi piu' comuni.
Radice quadrata: Sqrt[ ]
Valore assoluto Abs[ ]
Funzioni trigonometriche Sin[ ], Cos[ ], Tan[x], Sec[x]
Per esecizio calcolare la radice quadrata di 4, il valore assoluto di 10.6, il seno di Pi/2 (Pi si usa per indicare il
valore di pigreco), seno di 0, la tangente di Pi/4.
In[32]:= Sqrt|4]
Abs|-10.6]
Sin|Pi [ 2]
Sin|0]
Tan|Pi [ 4]
Out[32]= 2
Out[33]= 10.6
Out[34]= 1
Out[35]= 0
Out[36]= 1
4. Applicazione di funzioni: l'errore pi comune. L'applicazione di una funzione f ad un argomento x, in Mathemat-
ica, si indica come un comando, dunque con f[x]. Provate a scrivere sia Log[2+3], sia Log(2+3). La prima espres-
sione calcola il logaritmo (in base e) di 5, la seconda Log*5.
La parentesi tonda si limita a raggruppare e far eseguire 2+3. Poi, in mancanza di segni di operazione tra Log e 5,
Mathematica sottintende un prodotto.
In[37]:= Log|2 + 3]
Log (2 + 3)
Out[37]= Log[5]
Out[38]= 5 Log
5.Calcolo numerico e calcolo simbolico. Mathematica e' un potete strumento per la valutazione simbolica. Per
questo motivo ove possibile le espressioni simboliche non vengono semplificate quando questo comporta una
perdita di precisione. Si provi a valutare la radice quadrata di 4 e quindi la radice quadrata di 2. Il seno di Pi/2 e il
seno di Pi/3, la divisione 6/3 e 3/4.
In[39]:= Sqrt|4]
Sqrt|2]
Sin|Pi [ 2]
Sin|Pi [ 3]
6[ 3
3[ 4
Out[39]= 2
Out[40]= 2
Out[41]= 1
Out[42]=
3
2
Out[43]= 2
Out[44]=
3
4
6. Risultati interattivi. Mathematica puo' restituire una famiglia di risultati dipendenti da un parametro, insieme a
un pulsante che ci consente di scegliere quale risultato vedere. Il comando si chiama Manipulate[.,.], e richiede due
argomenti: una espressione con un parametro, per esempio 2
n
, e un "range" per questo parametro, per esempio
{n,1,300,1} ("n che varia tra 1 e 300, con passo 1").
Ogni volta che vedete un nuovo comando, come Manipulate, abituatevi a scrivere Manipulate? per richiedere
informazioni sul comando a Mathematica.
In[45]:= ?Manipulate
Manipulat e[expr, u, u
min
, u
max
] generat es a version
of expr wit h cont rols added t o allow int eract ive manipulat ion of t he value of u.
min
, u
max
, du] allows t he value of u t o vary bet ween u
min
and u
max
in st eps du.
init
, u
min
, u
max
, ] t akes t he init ial value of u t o be u
init
.
init
, u
lbl
, ] labels t he cont rols f or u wit h u
lbl
.
1
, u
2
, ] allows u t o t ake on discret e values u
1
, u
2
, .
Manipulat e[expr, u, , v, , ] provides cont rols t o manipulat e each of t he u, v, .
Manipulat e[expr, c
u
> u, , c
v
> v, , ]
links t he cont rols t o t he specif ied cont rollers on an ext ernal device.>
In[46]:= Manipulate|2^n, {n, 1, 300, 1}]
Out[46]=
n
2
7. Interrompere un calcolo. E' facile iniziare calcoli troppo lunghi o con risultato troppo lungo, per es., 2 alla
milionesima, che per essere scritto richiede oltre 300 mila cifre. Se il risultato tarda a venire, dovete interrompere il
calcolo usando l'opzione "Abort Evaluation" (Alt+.). In Mathematica 7 si trova nella colonna "Evaluation" del
Menu'.
Per non provateci adesso! Rischiereste di danneggiare la rete in cui vi trovate. Tenetelo solo presente come
ultima risorsa.
8. Precisione. Calcolare una versione approssimata di 2^1000000, e una versione approssimata alle prime 20 cifre,
utilizzando la funzione N[.,.].
In[47]:= N|2^1000 000]
N|2^1000 000, 20]
Out[47]= 9.90065622929590 x 10
301029
Out[48]= 9.9006562292958982507 x 10
301029
Attenti a non scrivere N (2^1000000), significa N * 2^1000000.
9. Calcolare una versione approssimata di sqrt[2], e una versione approssimata alle prime 20 cifre, utilizzando la
funzione N[.,.].
In[49]:= N|Sqrt|2]]
N|Sqrt|2], 20]
Out[49]= 1.41421
Out[50]= 1.4142135623730950488
Attenti a non scrivere N[Sqrt[2] 20], senza virgola viene capito un prodotto: N[Sqrt[2]*20].
10. Altre operazioni. Calcolare le prime 100 cifre di utilizzando la costante Pi e la funzione N[.,.].
In[51]:= N|Pi, 100]
Out[51]= 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998
628034825342117068
11. Costanti numeriche. Un altro modo di forzare mathematica a utizzare l'approsimazione numeriche e scrivere
esplicitamente i valori approssimati (2.0, 2.4) nelle espressioni da valutare. Provare a valutare Sqrt[2] e Sqrt[2.0] e
notare la differenza di comportamento.
In[52]:= Sqrt|2]
Sqrt|2.0]
Out[52]= 2
Out[53]= 1.41421
12. Mathematica ha un enorme collezioni di comandi per svolgere operazioni complesse. Ad esempio calcolaimo i
fattori primi del numero:
111111111111111111111111111111111111
(composto di 36 cifre "uno") usando FactorInteger[.]
In[54]:= FactorInteger|111 111111 111111 111111 111111 111111 111]
Out[54]= {{3, 2], {7, 1], {11, 1], {13, 1], {19, 1], {37, 1],
{101, 1], {9901, 1], {52579, 1], {333667, 1], {999999000001, 1]]
13. Calcolare un risultato interattivo con cento milioni di numeri primi (l'ultimo supera i due miliardi) usando la
funzione Prime[.]. Chiedete informazioni sul comando Prime per cominciare.
In[55]:= ?Prime
Prime[n] gives t he n
t h
prime number. >
In[56]:= Manipulate|Prime|i], {i, 1, 100000 000, 1}]
Out[56]=
i
2
14. Calcolare il fattoriale dei primi 1000 interi (1000! e' il numero 1*2*3*4* ... *999*1000).
In[57]:= Manipulate|n!, {n, 1, 1000, 1}]
Out[57]=
n
1
14. Definizioni statiche di variabili. Provate a scrivere x, poi x=2 e di nuovo x, poi x=3 e di nuovo x: la prima
volt si otterr x (se non avete ancora definito un valore per x), la seconda 2, la terza 3. Insomma: ogni volta,
ridefinendo x cancelliamo la definizione precedente.
In[58]:= x
x = 2;
x
x = 3;
x
Out[58]= x
Out[60]= 2
Out[62]= 3
E' facile scrivere una definizione x=3 e dimenticarsi di valutarla: in questo caso la definizione di x non e' avvenuta.
Abituatevi a controllare che x sia davvero una variabile e sia definita correttamente. Basta scrivere ?x : il risultato
e' il messaggio "Global x" (x e' una variabile globale), seguito dalla definizione corrente di x.
In[63]:= ?x
Global`x
x = 3
15. Nel risultato precedente, notiamo che di ogni definizione, tipo x=100, viene stampato il valore usato, 100 in
questo caso. Se non volete vederlo, scrivete un punto e virgola alla fine della definizione, scrivete cio
x=100;
Il punto e virgola impedisce di vedere il risultato di una operazione (che viene, per, ugualmente eseguita).
In[64]:= x = 100;
x
Out[65]= 100
16. Provate ora a scrivere a=2, x=a, x, a=3, x. Scoprirete che il valore di x resta 2 (il valore che aveva a quando
abbiamo posto x=a), e non cambia seguendo il valore di a. Questo tipo di definizione di x (che usa il simbolo "=")
viene, per questa ragione, detto statico.
In[66]:= a = 2;
x = a;
x
a = 3;
x
Out[68]= 2
Out[70]= 2
17. E' buona norma, prima di iniziare un nuovo calcolo, ripulire tutte le variabili che si intendono usare dai con-
tenuti precedenti. Questo perch pu capitare di studiare la funzione y=(x^2+1) senza ricordarsi di aver definito
x=5. In questo caso, Mathematica studier in realt la funzione y=(5^2+1)=26: una retta orizzontale anzich una
parabola.
1 0 Mat hemat ica- Dispense- 2011. nb
Il comando per ripulire le variabili Clear[.]. Utilizzate Clear[.] per ripulire i valori di x e di a. Ricalcolate x e a
per controllare che ora siano indefiniti.
In[71]:= Clear|x, a]
In[72]:= ?x
?a
Global`x
Globalà
Attenti a non scrivere Clear[x, ,a], con una virgola di troppo. Mathematica intende Clear[x, Null, a], dove Null
la costante "comando vuoto", non capisce, e segnala errore.
18. Gli operatori = (assegnazione statica), := (assegnazione dinamica), == (test di eguaglianza)
L'operazione x=expr assegna una valore numerico oppure simbolico alla variabile x. Attenzione: l'espressione
expr viene valutata immediatamente e assegnata ad x.
L'operazione x:=expr reppresenta invece una assegnazione dinamica. La variabile x viene definita come expr. A
differenza del caso precendete l'espressione expr non viene valutata immediatamente ma solo solo ogni qual volta x
viene utilizzata. L'operatore := viene in genere usato per la definizione di funzioni. L'operatore = per copiare e
memorizzare dati numerci o un risultato simbolico.
Infine l'operazione == (ripetuto due volte rappresenta) l'uguaglianza logica (o operatore di confronto) e restituisce i
valori vero (True) o falso (False). Si utilizza nelle espressioni logiche e nella definizione delle equazioni.
In[74]:= a = -1
x = a
a = a + 1
a
x
a =x
Out[74]= -1
Out[75]= -1
Out[76]= 0
Out[77]= 0
Out[78]= -1
Out[79]= False
In[80]:= a = -1
x := a
a = a + 1
a
x
a =x
Out[80]= -1
Out[82]= 0
Out[83]= 0
Out[84]= 0
Out[85]= True
18. Definizione di funzioni tramite := (assegnazione dinamica).
Possiamo definire noi stessi nuovi comandi, scrivendo una espressione ...x...., quindi ponendo f[x_]:=...x.... Ogni
volta che scriveremo f[a] verra' eseguito il comando ...a... . Dopo aver definito f, controllate subito con ?f che la
Mat hemat ica- Dispense- 2011. nb 1 1
definizione sia avvenuta correttamente: questo e' essenziale, spesso dimentichiamo una definizione oppure non la
scriviamo come vorremmo.
In[86]:= f|x_] := x^2 + a;
In[87]:= ?f
Global`f
f[x_] := x
2
+ a
In[88]:= f|1]
f|10]
f|100]
Out[88]= 1
Out[89]= 100
Out[90]= 10000
19. Ripulite tutte le variabili usate. Anzich scrivere Clear[var1,var2, ...], si pu dare il comando abbreviato:
Clear["Global`*"].
In[91]:= Clear|"Global`="]
Lezione 2: Liste, vettori, matrici.
1. Liste. Una lista un gruppo di dati qualsiasi (di solito numeri, ma non sempre) disposti in un certo ordine. Una
lista di elementi e_1,...,e_n si scrive disponendo gli elementi tra parentesi graffe e separati da virgole:
{e_1,...,e_n}. Costruite la lista di elementi 1, 2, 3.
In[92]:= {1, 2, 3} (= Il valore di una lista e' la lista medesima =)
Out[92]= {1, 2, 3]
2. Costruzione di liste. Il comando Table[e_i,{i,1,n}] costruisce la lista {e_1,...,e_n}. Tutte le volte che conosci-
amo una legge che consente di calcolare l'elemento i-esimo di una lista, e conosciamo il numero degli elementi di
una lista, possiamo costruire la lista usando il comando Table: questo comando cruciale in molti usi di Mathemat-
ica. Al posto di i pu trovarsi una qualsiasi variabile. Una forma pi generale del comando :
Table[e_i,{i,min,max,step}]
Costruisce la lista {e_min, e_min+step, ..., e_max}. Costruire, utilizzando il Comando Table, una lista l1 di cento
"uno", una lista l2 dei primi cento interi, una lista l3 lista dei quadrati dei primi cento interi.
In[93]:= ?Table
Table[expr, i
max
] generat es a list of i
max
copies of expr.
Table[expr, i, i
max
] generat es a list of t he values of expr when i runs f rom 1 t o i
max
.
Table[expr, i, i
min
, i
max
] st art s wit h i = i
min
.
Table[expr, i, i
min
, i
max
, di] uses st eps di.
Table[expr, i, i
1
, i
2
, ] uses t he successive values i
1
, i
2
, .
Table[expr, i, i
min
, i
max
, j, j
min
, j
max
, ] gives a nest ed list . The list associat ed wit h i is out ermost . >
In[94]:= l1 = Table|1, {i, 1, 100}];
l2 = Table|i, {i, 1, 100}];
l3 = Table|i^2, {i, 1, 100}];
In[97]:= l1
l2
l3
Out[97]= {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Out[98]= {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]
Out[99]= {1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400,
441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225,
1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304,
2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721,
3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476,
5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569,
7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801, 10000]
3. Si pu decidere di incrementare l'indice i, anzich di un passo alla volta, di un numero qualunque di passi ogni
ogni volta. La forma del comando in tal caso :
Table[e_i,{i,min,max,passo}]
Esso costruisce {e_min, e_min+passo, e_min+2passo, ...}, per ogni valore di min+k*passo s max. Costruire,
utilizzando il comando dato, la lista dei multipli di 10 tra 0 e 100. Si costruisca una lista l4 valutando la funzione
Log[x], x a partire dal valore 0.1 a passi di 0.25 fino a x=2.
In[100]:= Table|i, {i, 0, 100, 10}]
Table|Log|i], {i, 0.1, 2, 0.25}]
Out[100]= {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Out[101]= {-2.30259, -1.04982, -0.510826, -0.162519, 0.0953102, 0.300105, 0.470004, 0.615186]
23. Operazioni su liste. Calcolate le lunghezze delle liste l1, l2, l3 (comando Length), e controllate che sia 100 in
ogni caso.
In[102]:= ?Length
Lengt h[expr] gives t he number of element s in expr. >
In[103]:= Length|l1]
Length|l2]
Length|l3]
Out[103]= 100
Out[104]= 100
Out[105]= 100
4. L'operatore list[[ j ]] con j intero compreso fra j=1 e j=Length[list] permette di prelevare l'elemento in posizione
j della lista list. Calcolate alcuni elementi delle liste l1, l2 e l3, usando l'operazione l[[i]] per calcolare l'elemento
numero i della lista l.
In[106]:= {l1||13]], l2||13]], l3||13]]}
Out[106]= {1, 13, 169]
5. Oltre a un singolo elemento e possibile isolare un insieme di elementi della lista sostituendo j con una lista di
indici; ad esempio list[[listj]] dove listj={1,4,7} e' la lista delle posizioni che si vuole prelevare. Il risultato sara'
una sottolista costituita dagli elementi selezionati secondo listj. Creare una sottolista di l2 costituita dai soli ele-
menti si posizione dispari {1,3, ecc.}
In[107]:=
l2||Table|j, {j, 1, Length|l2], 2}]]]
Out[107]= {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31,
33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65,
67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
6.Altri comandi sulle liste. Costruite una nuova lista aggiungendo l'elemento 0 all'inizio di l2, o l'elemento 101
alla fine, utilizzando Prepend e Append. Trovate questi comandi per costruire nuove liste sia nelle Palettes (voce
File/Palettes/BasicCalculations/ListsAndMatrices del Menu qui sopra), sia alla voce ListsAndMatrices/ListsOpera-
tions dell'Help (sempre nel Menu qui sopra). Il comando Join permette di unire piu' liste.
Si noti che Prepend, Append costruiscono una nuova lista. Ricalcolate la lista l2 per verificare che non cambia.
Concatenare le lista l2 e l1 con il comando Join.
In[108]:= ?Prepend
?Append
Prepend[expr, elem] gives expr wit h elem prepended. >
Append[expr, elem] gives expr wit h elem appended. >
In[110]:= Prepend|l2, 0]
Out[110]= {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]
In[111]:= Append|l2, 101]
Join|l2, l1]
Out[111]= {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]
Out[112]= {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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
In[113]:= l2
Out[113]= {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]
7. Ordinare una lista. Il comando Sort[list], oppure Sort[list, Less] ordina gli elementi della lista dal piu' piccolo
al piu' grande. Per l'ordinamento decrescente occorre specificare come secondo parametro Greater. Sort[list,
Greater]. Si oridini l2 in modo crescente e decrescente.
In[114]:= ?Sort
Sort [list] sort s t he element s of list int o canonical order .
Sort [list, p] sort s using t he ordering f unct ion p. >
In[115]:= Sort|l2]
Sort|l2, Less]
Sort|l2, Greater]
Out[115]= {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]
Out[116]= {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]
Out[117]= {100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82,
81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63,
62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43,
42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23,
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
8. Operazioni su liste. Tutte le operazioni elementari si possono applicare alle liste; le operazioni vengono eseguite
elemento per elemento. Le operazioni possono avvenire tra liste e costanti (scalari). Costruite nuove liste partendo
dalla lista {1,2,3}, ed eseguendo su ogni elemento di l2 le operazioni:
+1, *2, ^2. E' sufficiente indicare l'operazione sull'intera lista: per esempio l2+1 crea una nuova lista aggiungendo
1 ad ogni elemento di l2.
In[118]:= {1, 2, 3} + 1
{1, 2, 3} =2
{1, 2, 3} ^2
Out[118]= {2, 3, 4]
Out[119]= {2, 4, 6]
Out[120]= {1, 4, 9]
9. Tra liste con lo stesso numero di elementi e' possibile definire le operazioni tra gli elementi nella stessa
posizione. Costruite nuove liste sommando, moltiplicando, ed elevando a potenza ogni elemento della lista {1,2,3}
con il corrispondente elemento della lista {10,20,30}.
In[121]:= {1, 2, 3} + {10, 20, 30}
{1, 2, 3} ={10, 20, 30}
{1, 2, 3} ^{10, 20, 30}
Out[121]= {11, 22, 33]
Out[122]= {10, 40, 90]
Out[123]= {1, 1048576, 205891132094649]
10. Matrici. Una Matrice un gruppo di dati disposto in forma rettangolare, su n righe tutte di m elementi. In altre
parole, una tabella di n righe ed m colonne, che in ogni posizione (riga i, colonna j) contiene un dato. Diciamo
che la matrice ha dimensione n x m. Una Matrice viene rappresentata da una lista di liste, ad esempio
{{a,b},{c,d}}. Gli elementi {a,b} e {c,d} sono considerati le righe della matrice, e devono avere la stessa
lunghezza (la matrice dell'esempio ha dimensione 2x2). Definite M come la matrice 2x2 di elementi 1,2,3,4.
Disegnate M in forma rettangolare usando MatrixForm[M]. Calcolate quindi la trasposta di M, l'inverso di M, il
prodotto di M per se stessa e per il suo inverso, il determinante di M (sono operazioni su matrici che vedrete pi
avanti nei corsi, e che trovate alla voce "Matrici" dell'Help).
In[124]:= M = {{1, 2}, {3, 4}}
MatrixForm|M]
MatrixForm|Transpose|M]]
M.M
Inverse|M]
M.Inverse|M]
Det|M]
Out[124]= {{1, 2], {3, 4]]
1 2
3 4

1 3
2 4

Out[127]= {{7, 10], {15, 22]]
Out[128]= {-2, 1],
3
2
, -
1
2
Out[129]= {{1, 0], {0, 1]]

Out[130]= -2
10 bis. Scrittura di matrici. Costruire una matrice 3x3 di nome M usando il comando della Palette "Basic Math
Assistant" relativo a matrici (cercate "Basic Commands", poi premete il tasto con il simbolo di una matrice). Tale
comando costruisce matrici 2x2: per aggiungere una terza riga, scrivere Control+Enter, per aggiungere una terza
colonna, Control+il tasto "virgola".
In[131]:=
1 2 3
4 5 6
7 8 9
Out[131]= {{1, 2, 3], {4, 5, 6], {7, 8, 9]]
Matrici e Vettori sono distinti. Anche nel caso in cui una matrice abbia una sola riga (es. {{a,b}}) oppure una sola
colonna (es. {{a},{b}}) va considerata distinta dal vettore {a,b} con gli stessi elementi. Bisogna tener conto di
questo fatto per non inserire un vettore in un problema in cui richiesta una matrice, o viceversa, altrimenti
Mathematica non capisce.
11. Attenzione al tipo dei dati: una matrice e' diversa dal disegno che la rappresenta. Il comando MatrixForm
brevemente introdotto al punto 10 e' spesso fonte di errore. Tale comando infatti produce, a partire da una lista di
liste, un oggetto grafico (un "disegno") con la rappresentazione della matrice come tabella. Essendo solo un
disegno, fatto di pixels e non di numeri, il risultato di MatrixForm[.] non puo' essere utilizzato per calcoli succes-
sivi. Si crei una matrice M 2x2 e si assegni il risultato di MatrixForm[M] alla variabile Mg. Si provi ora a fare
delle semplici operazioni come ad esempio Mg.Mg: il risultato sara' solo disegnare Mg.Mg, non eseguirlo.
In[132]:= M = {{-1, 1}, {0, 1}}
Mg = MatrixForm|M]
Mg.Mg
Out[132]= {{-1, 1], {0, 1]]
-1 1
0 1

Out[134]=
-1 1
0 1
.
-1 1
0 1

12. Il comando Table[e_i,j, {i,1,n}, {j,1,m}], analogo al comando gi visto per le liste, costruisce la matrice
{{e_1,1,e_1,2,...,e_1,m}, {e_2,1,e_2,2,...,e_2,m}, ....,{e_n,1,e_1,2,...,e_n,m}}
Costruire la matrice 10x10 contenenta la tavola pitagorica (cio, nella riga 1, 2, 3,..., i primi dieci multipli di 1, 2,
3, ...) .
In[135]:= MatrixForm|tt = Table|i j, {i, 1, 10}, {j, 1, 10}]]
tt
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Out[136]= {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10], {2, 4, 6, 8, 10, 12, 14, 16, 18, 20],
{3, 6, 9, 12, 15, 18, 21, 24, 27, 30], {4, 8, 12, 16, 20, 24, 28, 32, 36, 40],
{5, 10, 15, 20, 25, 30, 35, 40, 45, 50], {6, 12, 18, 24, 30, 36, 42, 48, 54, 60],
{7, 14, 21, 28, 35, 42, 49, 56, 63, 70], {8, 16, 24, 32, 40, 48, 56, 64, 72, 80],
{9, 18, 27, 36, 45, 54, 63, 72, 81, 90], {10, 20, 30, 40, 50, 60, 70, 80, 90, 100]]
12bis. Come nel caso delle liste si puo' usare l'operatore [[ i, j ]] per estrarre l'elemento in posizione i,j. Per estrarre
delle sottoliste (ad esempio una colonna o una riga) si puo' usare l'operatore All per identificare tutte le righe o le
colonne. Ad esempio estrarre l'elemento 5,7 e la seconda colonna della precedente tabella:
In[137]:= tt||5, 7]] (= Stampa la casella che contiene 5=7 =)
tt||2, All]] (= Stampa la tabellina del 2: la riga che contiene i multipli di 2 =)
Out[137]= 35
Out[138]= {2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
13. Se l1={e_1,...,e_n}, possiamo disegnare il grafico di{1,e_1},...,{n,e_n} usando ListPlot[l1].Disegnare, i grafici
delle liste l1,l2,l3 (la lista di 100 uno, dei primi cento interi, dei quadrati dei primi 100 interi).
In[139]:= ListPlot|l1]
ListPlot|l2]
ListPlot|l3]
Out[139]=
20 40 60 80 100
0.5
1.0
1.5
2.0
Out[140]=
20 40 60 80 100
20
40
60
80
100
Out[141]=
20 40 60 80 100
2000
4000
6000
8000
10 000
14. ListPlot. Il comando ListPlot produce un grafico dei dati di una lista in funzione della posizione di ogni ele-
mento nella lista. In altre parole l'asse delle ascisse e' determinato dai valori 1,2,3,... In molti casi sperimentali e'
necessario associare all'asse x un significato fisico e non semplicemente un insieme crescente di interi. ListPlot[{
{x1,y1},{x2,y2}...}] disegna i punti di ascissa x1,x2,.. e ordinata y1,y2,.. I dati vengono inseriti in forma di matrice
Nx2, la prima colonna rappresenta N ascisse, la seconda colonna rappresenta i dati. Utilizzare i comandi Table e
ListPlot per disegnare la funzione y=x^3 tra -1 e 1 a passi di 0.1.
In[142]:= lc = Table|i^3, {i, -1, 1, 0.1}];
lcx = Table|{i, i^3}, {i, -1, 1, 0.1}];
ListPlot|lc]
ListPlot|lcx]
Out[144]=
5 10 15 20
1.0
0.5
0.5
1.0
Out[145]=
1.0 0.5 0.5 1.0
1.0
0.5
0.5
1.0
15. Tutti gli oggetti grafici si possono personalizzare con moltissime opzioni: etichette degli assi, titolo, legenda,
rapporto d'aspetto tra gli assi, ecc. Il comando Options[ListPlot] permette di ottenere una lista di tutte le possibili
opzioni.
Ogni opzione e' accompagnata dal suo valore di default, elencato qui sotto.
In[146]:= Options|ListPlot]
Out[146]= AlignmentPoint - Center, AspectRatio -
1
GoldenRatio
, Axes - True,
AxesLabel - None, AxesOrigin - Automatic, AxesStyle - {], Background - None,
BaselinePosition - Automatic, BaseStyle - {], ClippingStyle - None,
ColorFunction - Automatic, ColorFunctionScaling - True, ColorOutput - Automatic,
ContentSelectable - Automatic, CoordinatesToolOptions - Automatic,
DataRange - Automatic, DisplayFunction : $DisplayFunction, Epilog - {],
Filling - None, FillingStyle - Automatic, FormatType : TraditionalForm, Frame - False,
FrameLabel - None, FrameStyle - {], FrameTicks - Automatic, FrameTicksStyle - {],
GridLines - None, GridLinesStyle - {], ImageMargins - 0., ImagePadding - All,
ImageSize - Automatic, ImageSizeRaw - Automatic, InterpolationOrder - None,
Joined - False, LabelStyle - {], MaxPlotPoints - , Mesh - None,
MeshFunctions - {1 &], MeshShading - None, MeshStyle - Automatic, Method - Automatic,
PerformanceGoal : $PerformanceGoal, PlotLabel - None, PlotMarkers - None,
PlotRange - Automatic, PlotRangeClipping - True, PlotRangePadding - Automatic,
PlotRegion - Automatic, PlotStyle - Automatic, PreserveImageOptions - Automatic,
Prolog - {], RotateLabel - True, Ticks - Automatic, TicksStyle - {]
14. La freccia "->" indica l'assegnazione temporanea. Un esempio: la variabile Axes vale True se disegnamo
gli assi, False se non li disegnamo. Se inseriamo Axes False tra gli argomenti di ListPlot, assegnamo temporanea-
mente (per la sola durata del comando ListPlot) Axes a False, e gli assi scompaiono. Nel comando successivo Axes
riprende il suo valore di default, True, e gli assi ricompaiono.
Cambiare i grafici precedenti di l1,l2,l3 congiungendo i punti consecutivi con tratti di retta, assegnado all'opzione
PlotJoined il valore temporaneo True con una assegnazione "->".
Nota: lo stesso risultato si puo' ottenere anche con il comando ListLinePlot
In[147]:= ListPlot|l2, Joined -> True]
ListPlot|l3, Joined -> True]
Out[147]=
20 40 60 80 100
20
40
60
80
100
Out[148]=
20 40 60 80 100
2000
4000
6000
8000
10 000
In[149]:= ListLinePlot|l3]
Out[149]=
20 40 60 80 100
2000
4000
6000
8000
10 000
15. L'opzione Joined si puo' combinare con l'opzione PlotMarkers per sovrappore alla linea anche i punti (che in
un esercizio di laboratorio rappresentano i valori sperimentali). PlotMarkers deve essere associato a un oggetto
grafico per rappresentare i punti. Il modo piu' semplice e' utilizzare le scelte automatiche del software inserendo
l'opzione PlotMarkers->Automatic. Per esercizio si crei una lista contente i valori di Sin[x] con x tra 0 e 2r a passi
di r/6 e si produca un grafico usando l'opzione Joined->True e PlotMarkers->Automatic.
In[150]:= lcs = Table|Sin|x], {x, 0, 2 Pi, Pi [ 6}];
ListPlot|lcs, Joined -True, PlotMarkers -Automatic]
Out[151]=

2 4 6 8 10 12
1.0
0.5
0.5
1.0
16. Ridisegnare il grafico di y=x^3 inserendo le etichette x, y degli assi e il titolo del grafico. Si utilizzino le opzioni
AxesLabel e PlotLabel
In[152]:= ListPlot|lcx, AxesLabel -{x, y}, PlotLabel -y =x^3]
Out[152]=
1.0 0.5 0.5 1.0
x
1.0
0.5
0.5
1.0
y
y x
3
17. Ridisegnare il grafico di y=x^3 inserendo le etichette degli assi e il titolo del grafico. Si utilizzino le opzioni
AxesLabel e PlotLabel
In[153]:= ListPlot|lcx, AxesLabel -{x, y}, PlotLabel -"La funzione y=x^3"]
Out[153]=
1.0 0.5 0.5 1.0
x
1.0
0.5
0.5
1.0
y
La funzione y=x^3
35. Inserimento di testo nei grafici. In Mathematica un testo viene scritto tra virgolette: "y = x
3
" e' il testo "y
uguale a x al cubo" (una frase del nostro linguaggio) non l'assegnazione x
3
di a y (non dunque un comando di
Mathematica). Un testo puo' venir ritoccato con il comando StyleForm[testo, opz1-> valore1, ...], cambiando per
esempio la dimensione e il colore. Un testo puo' venir assegnato a una variabile Title e poi venire riutilizzato.
In[154]:= "La funzione y = x
3
"
Out[154]= La funzione y = x
3
In[155]:= Title = StyleForm["La funzione y = x
3
", FontSize -24, FontColor - Blue, FontWeight - Bold]
Out[155]//StyleForm=
La funzione y = x
3
In[156]:= ?Title
Global`Title
Title = StyleForm[La funzione y = x
3
,
FontSize - 24, FontColor - RGBColor[0, 0, 1], FontWeight - Bold]
Un testo puo' venir inserito entro un grafico:
In[157]:= ListPlot|lcx, AxesLabel - {x, y}, PlotLabel - Title]
Out[157]=
1.0 0.5 0.5 1.0
x
1.0
0.5
0.5
1.0
y
La funzione y = x
3
35. Definizione di funzioni. Puo' essere difficile ricordarsi la successione esatta di comandi necessaria, per
esempio, per creare un testo in grassetto di date dimensioni e colore. In questo caso occorre definire una funzione
che svolge tale compito. La funzione viene salvata in un Notebook e ricopiata ogni volta che ci serve quella
particolare successione di comandi.
In[158]:= Grassetto|text_, size_, color_] := StyleForm|text, FontSize -size, FontColor -color, FontWeight - Bold]
In[159]:= Grassetto|"TESTO DI PROVA", 18, Magenta]
Out[159]//StyleForm=
TESTO DI PROVA
18. Ripulite tutte le variabili usate.
Lezione 3: Grafica 2D
Esercizio. Scrivete una lista casuale di 1000 numeri naturali compresi tra 0 e 1000 (cercate la parola "Random"
nell'Help) Estraete la sottolista dei soli elementi di indice pari. Generalizzate la soluzione a una funzione Par-
i[L_]:= ..., che applicata a una lista L restituisca la sottolista dei soli elementi di indice pari.
1. Creare grafici di funzioni. Il comando Plot[f[x],{x,a,b}] disegna il grafico di f[x] tra x=a ed x=b. La forma pi
generale del comando
Plot[f[x],{x,a,b}, opzione_1->valore_1, ..., opzione_n -> valore_n]
Le "opzioni" sono scelte di modi con cui stampare un grafico. Ogni opzione ha diversi valori possibili, corrispon-
denti a diverse scelte. Normalmente ogni opzione ha un valore di default, ma scrivendo opzione->valore entro
Plot[...] possiamo assegnarle temporaneamente un valore diverso. Vedremo ora diversi esempi di opzioni, che ci
consentono di stampare un grafico con le caratteristiche desiderate.
Come prima prova disegnare sin(x) per x tra 0 e 2r.
In[161]:= Options|Plot]
Out[161]= AlignmentPoint - Center, AspectRatio -
1
GoldenRatio
, Axes - True,
AxesLabel - None, AxesOrigin - Automatic, AxesStyle - {], Background - None,
BaselinePosition - Automatic, BaseStyle - {], ClippingStyle - None,
ColorFunction - Automatic, ColorFunctionScaling - True, ColorOutput - Automatic,
ContentSelectable - Automatic, CoordinatesToolOptions - Automatic,
DisplayFunction : $DisplayFunction, Epilog - {], Evaluated - Automatic,
EvaluationMonitor - None, Exclusions - Automatic, ExclusionsStyle - None,
Filling - None, FillingStyle - Automatic, FormatType : TraditionalForm,
Frame - False, FrameLabel - None, FrameStyle - {], FrameTicks - Automatic,
FrameTicksStyle - {], GridLines - None, GridLinesStyle - {], ImageMargins - 0.,
ImagePadding - All, ImageSize - Automatic, ImageSizeRaw - Automatic,
LabelStyle - {], MaxRecursion - Automatic, Mesh - None, MeshFunctions - {1 &],
MeshShading - None, MeshStyle - Automatic, Method - Automatic,
PerformanceGoal : $PerformanceGoal, PlotLabel - None, PlotPoints - Automatic,
PlotRange - {Full, Automatic], PlotRangeClipping - True, PlotRangePadding - Automatic,
PlotRegion - Automatic, PlotStyle - Automatic, PreserveImageOptions - Automatic,
Prolog - {], RegionFunction - (True &), RotateLabel - True,
Ticks - Automatic, TicksStyle - {], WorkingPrecision - MachinePrecision
In[162]:= Plot|Sin|x], {x, 0, 2 Pi}]
Out[162]=
1 2 3 4 5 6
1.0
0.5
0.5
1.0
2. PlotRange. PlotRange->{c,d} fa disegnare i soli valori della y compresi tra c e d: dunque disegna solo la parte
del grafico tra le due rette orizzontali y=c ed y=d.
Ridisegnare sin(x) per x tra 0 e 2r, e per y tra -0.5 e 0.5.
In[163]:= Plot|Sin|x], {x, 0, 2 n}, PlotRange -> {-0.5, 0.5}]
Out[163]=
1 2 3 4 5 6
0.4
0.2
0.2
0.4
3. AspectRatio->x. Rende l'altezza del disegno pari a x volte la base. Se x=1 il disegno diventa quadrato. Tuttavia,
la scala sugli assi x e y pu essere diversa: la forma quadrata o rettangolare del disegno non ha nulla a che vedere
con la scala usata sui due assi.
Ridisegnare sin(x) entro un quadrato e con la larghezza del grafico pari a tre volte l'altezza.
In[164]:= Plot|Sin|x], {x, 0, 2 Pi}, AspectRatio -> 1]
Plot|Sin|x], {x, 0, 2 Pi}, AspectRatio -1[ 3]
Out[164]=
1 2 3 4 5 6
1.0
0.5
0.5
1.0
Out[165]=
1 2 3 4 5 6
1.0
0.5
0.5
1.0
4. Stessa scala negli assi x e y. Per avere la stessa scala sui due assi occorre scegliere AspectRatio -> Automatic.
Ridisegnare sin(x) in un rettangolo [-10,10]x[-5,5], usando la stessa scala per x e y .
In[166]:= Plot|Sin|x],
{x, -10, 10},
AspectRatio -> Automatic, ImageSize - 800] (= ImageSize determina il numero di pixels alla base del disegno =)
Out[166]=
10 5 5
1.0
0.5
0.5
1.0
4bis. Stessa scala negli assi x e y. Per comprendere meglio cosa avviene a seconda se chiediamo oppure no la
stessa scala sui due assi, disegnare la funzione Sqrt[1-x^2], per x nell'intervallo [-1,1], che rappresenta un arco di
circoferenza, prima senza specificare alcuna opzione, e poi specificando AspectRatio->Automatic
In[167]:= Plot|Sqrt|1 - x^2], {x, -1, 1}]
Plot|Sqrt|1 - x^2], {x, -1, 1}, AspectRatio -Automatic]
Out[167]=
1.0 0.5 0.5 1.0
0.2
0.4
0.6
0.8
1.0
Out[168]=
1.0 0.5 0.5 1.0
0.2
0.4
0.6
0.8
1.0
5. Colori. L'opzione PlotStyle si puo' usare per assegnare un particolare colore alla curva. Mathematica ha una
serie di colori predefiniti: Red, Blue, Yellow, Green, ... (indicati dal loro nome con la prima lettera maiuscola).
Provare a fare un grafico di una funzione con l'opzione PlotSytle->Green.
In[169]:= Plot|Sin|x], {x, -10, 10}, PlotStyle -> Yellow]
Out[169]=
10 5 5 10
1.0
0.5
0.5
1.0
In[170]:=
5bis. Colori. Si possono creare colori personalizzati con la funzione RGBColor[r,g,b], che crea la mistura di r parti
di red (rosso), g parti di green (verde), b parti di blue (blu). r,g,b sono valori tra 0 e 1.
Altre funzioni disponibili sono CMYKColor[c,m,y,k], che fornisce una mistura dei colori primari definiti invece
"per sottrazione" da uno sfondo bianco (cyan , magenta, yellow, black), GrayLevel[g], che fornisce una gradazione
di grigio. Provare a definire alcuni colori: red, green, blue, ... , mescolando i colori rosso, verde e blu in diverse
proporzioni, e usando RGBColor.
In[171]:= red = RGBColor|1, 0, 0];
green = RGBColor|0, 1, 0];
blue = RGBColor|0, 0, 1];
cyan = CMYKColor|1, 0, 0, 0]; (= "cyan" o "color cianuro" e' l'azzurro =)
magenta = CMYKColor|0, 1, 0, 0];
yellow = CMYKColor|0, 0, 1, 0];
black = CMYKColor|0, 0, 0, 1];
gray = GrayLevel|0.8];
6.Grafici di pi funzioni. Per i grafici di pi funzioni con dei colori voluti, sufficiente fornire a Plot la lista di
funzioni da disegnare. Disegnate il grafico di sin(x), cos(x), tan(x) in colori diversi ( sufficiente assegnare a
PlotStyle la lista {col_1, ..., col_n} dei colori). Se non precisiamo qualii colori usare per ogni funzione, Mathemat-
ica li sceglie al posto nostro.
In[179]:= red = RGBColor|1, 0, 0];
green = RGBColor|0, 1, 0];
Plot|{Sin|x], Cos|x], Tan|x]}, {x, 0, 2=Pi}, PlotStyle -> {red, green, blue}]
Plot|{Sin|x], Cos|x], Tan|x]}, {x, 0, 2=Pi}]
Out[182]=
1 2 3 4 5 6
3
2
1
1
2
3
Out[183]=
1 2 3 4 5 6
3
2
1
1
2
3
7.Come viene costruito il grafico?. Per disegnare un grafico il comando Plot valuta la funzione su nun numero
limitato di punti; il grafico prodotto e' frutto di interpolazione (ogni punto viene collegato al successivo da un
opportuno arco di parabola), e non sempre permette di ottenere il risultato desiderato. L'opzione Mesh->All
permette di mostrare i punti in cui la funzione viene valutata. L'opzione PlotPoints si puo' usare per fissare il
numero di punti iniziali su cui valutare la funzione (tuttavia, Mathematica in seguito ne aggiunge altri per miglio-
rare il disegno, a meno che chiediamo MaxRecursion->1). Provare a disegnare le funzioni Sin[x] e Sin[1/x] con le
opzioni PlotPoints->100, Mesh->All, MaxRecursion->1. Nel caso Sin[1/x] provare anche con PlotPoints->10.
In[184]:= Plot|Sin|x], {x, -Pi, Pi}, Mesh -All, PlotPoints - 10]
(= ai 10 punti iniziali Mathematica ne aggiunge altri la' dove la precisione del disegno lo richiede =)
Plot|Sin|1[ x], {x, -2, 2}, Mesh -All, PlotPoints -100, MaxRecursion -1]
(= i punti usati sono 100 e non se ne aggiungono altri. Di
conseguenza in alcuni punti la precisione del grafico lascia a desiderare. =)
Out[184]=
3 2 1 1 2 3
1.0
0.5
0.5
1.0
Out[185]=
2 1 1 2
1.0
0.5
0.5
1.0
In[186]:=
8. Origine degli assi: l'opzione AxesOrigin->{x,y} permette di fissare l'origine degli assi alle coordinate (x,y).
Disegnare la funzione 2 (x - 4)^2 + 1 prima senza scegliere l'origine, e poi fissando l'origine in (0,0).
In[187]:= Plot|2 (x - 4) ^2 + 1, {x, 3, 5}]
Plot|2 (x - 4) ^2 + 1, {x, 3, 5}, AxesOrigin -{0, 0}]
Out[187]=
3.5 4.0 4.5 5.0
1.5
2.0
2.5
3.0
Out[188]=
1 2 3 4 5
0.5
1.0
1.5
2.0
2.5
3.0
In[189]:=
9. Griglia degli assi. Le opzioni GridLines e e GridLinesStyle si possono usare per aggingere una griglia quadret-
tata al grafico.
In[190]:= Plot|Sin|x] ^2, {x, 0, 2 Pi}, GridLines - Automatic, GridLinesStyle -Dashed]
(= "Dashed" significa "tratteggiato" =)
Plot|Sin|x] ^2, {x, 0, 2 Pi}, GridLines - {{0, Pi [ 2, Pi, 3 Pi [ 2 , 2 Pi}, {0, 0.25, 0.5, 0.75, 1}}, GridLinesStyle -Dashed]
Out[190]=
1 2 3 4 5 6
0.2
0.4
0.6
0.8
1.0
Out[191]=
1 2 3 4 5 6
0.2
0.4
0.6
0.8
1.0
10. L'opzione Ticks (ovvero "tacche") si puo' usare per scegliere i punti in cui mostrare le tacche degli assi.
In[192]:= Plot|Sin|x] ^2, {x, 0, 2 Pi}, Ticks -{{0, Pi , 2 Pi}, {0, 0.5, 1}}]
(= la prima lista di valori si riferisce alla x, la seconda alla y =)
Out[192]=
r 2 r
0.5
1
11. L'opzione AxesLabel->{stringa_x, stringa_y} aggiunge le etichette testuali agli assi.
In[193]:= Plot|Sin|x] ^2, {x, 0, 2 Pi}, AxesLabel -{x, Sin|x] ^2}]
Out[193]=
1 2 3 4 5 6
x
0.2
0.4
0.6
0.8
1.0
sin
2
(x)
12. Altre opzioni utili.
In[194]:= Needs|"PlotLegends`"] (= Carica il pacchetto PlotLegends con i relativi comandi,
a meno che il pacchetto sia gia' stato caricato di default =)
In[195]:= Plot|{Sin|x], Cos|x]}, {x, 0, 2 Pi}, Ticks -{Range|0, 2 Pi, Pi [ 2], Range|0, 1, 0.25]},
PlotStyle -{Directive|Red, Dashed], RGBColor|0, 0.5, 0]}, AxesLabel -{x,}, PlotLegend -{Sin|x], Cos|x]}]
Out[195]=
r
2
r
3 r
2
2 r
x
0.25
0.5
0.75
1.
cos(x)
sin(x)
RGBColor[0, 0.5, 0] e' una media tra RGBColor[0, 0, 0] (il nero) e RGBColor[0, 1, 0] il verde. Corrisponde
quindi al verde scuro.
13. Eslusione di punti singolari (asintoti verticali) dal grafico della funzione con opzione Exclusions. Con
ExclusionsStyle-> ... possiamo scegliere un modo per disegnare la parte "esclusa" del grafico.
In[196]:= Plot|1[ ((x - 2) =(x - 5)), {x, 0, 7}]
Plot|1[ ((x - 2) =(x - 5)), {x, 0, 7}, Exclusions -{x =2, x =5}]
Plot|1[ ((x - 2) =(x - 5)), {x, 0, 7}, Exclusions -{x =2, x =5}, ExclusionsStyle -Dashed]
Out[196]=
1 2 3 4 5 6 7
2
1
1
2
Out[197]=
1 2 3 4 5 6 7
2
1
1
2
Out[198]=
1 2 3 4 5 6 7
2
1
1
2
Ci sono un gran numero di altre opzioni, basta leggere Options[Plot] e poi l'Help ...
In[199]:= Plot|2=x=Sin|x], {x, 0, 15}, Filling -Top]
Plot|2=x=Sin|x], {x, 0, 15}, Filling -Bottom]
Plot|2=x=Sin|x], {x, 0, 15}, Filling -Axis]
Out[199]=
Out[200]=
Out[201]=
In[202]:=
Esercitazione 1: Liste e Grafica 2D
Lezione 4: Data fitting
1. Approssimazione o Fitting lineare. Mathematica ha un comando, Fit[.] che, dato una serie di dati nella forma di
una lista V di lunghezza n, determina la "migliore" formula E, tra quelle che appartengono a un insieme dato e che
generano V. In un certo senso, il Fit e' un comando opposto al comando V = Table[E, {i,1,n}], che data una
formula E nella variabile i, genera una lista V di lunghezza n il cui i-esimo elemento e' descritto dalla formula E.
Fit, al contrario, prende V e ricostrusce la "migliore" formula E che genera V. Per formula "migliore" si intende
quanto segue: la formula E, in realta', genera una lista V' di dati leggermente diversi da V. La "migliore" formula E,
tra quelle in un insieme dato, e' quella che rende la distanza euclidea tra i vettori V' e V dello spazio R
n
minima.
L'insieme delle formule in cui cercare la formula migliore e' uno spazio vettoriale, ottenuto prendendo tutte le
combinazioni lineari di un numero finito di formule di partenza.
Fit lineare
1.
L'help del comando restituisce la seguente descrizione di Fit:
In[203]:= ?Fit
Fit [data, funs, vars] f inds a least -squares f it t o
a list of dat a as a linear combinat ion of t he f unct ions funs of variables vars. >
I parametri di Fit[data,funs,vars] sono una lista V di dati numerici (data), una lista di funzioni {f_1[x,y,...], ...
f_n[x,y,...]} (funs), e la lista delle variabili indipendenti x,y,... (vars). Fit determina, usando un metodo detto "dei
minimi quadrati" e che vedrete nei corsi di teoria, la combinazione lineare f[x,y...] = a_1*f_1[x,y,...] + ... +
a_n*f_n[x,y...] delle funzioni f_1, ..., f_n che meglio e' grado di approssimare i dati sperimentali. Uno studio
teorico garantisce che, nel caso delle combinazioni lineari di funzioni, la soluzione migliore esiste ed e' unica.
Ad esempio nel caso di una lista di dati V={r_1, ... r_n}, come funzione della variabile indipendente i possiamo
usare:
Fit[V, {f[i], g[i], h[i],...}, i]
per determinare la funzione f[i]=(a*f[i] + b*g[i] + c*h[i] + ...), in grado di ricostruire una lista V'={r'_1, ... r'_n} il
piu' vicino possibile a V.
Definire un vettore V, e, usando il comando Fit[.,.,.], cercare la funzione costante e1, la retta e2, e la parabola e3
che meglio approssimano i dati contenuti in V.
In[204]:= V = {0.71, 0.88, 0.95, 1.59, 1.99};
E1 = Fit|V, {1}, x]
(= le combinazioni lineari della funzione 1 sono tutte e sole le funzioni costanti a =)
E2 = Fit|V, {1, x}, x]
(= le combinazioni lineari delle funzioni 1,x sono tutte e sole le funzioni a+b=x =)
E3 = Fit|V, {1, x, x^2}, x]
(= le combinazioni lineari delle funzioni 1,x,x^2 sono tutte e sole le funzioni a+b=x+c=x^2 =)
Out[205]= 1.224
Out[206]= 0.243 + 0.327 x
Out[207]= 0.758 - 0.114429 x + 0.0735714 x
2
2. Utilizzando le formule E1, E2, E3 ottenute qui sopra, definite tre tabelle, V1, V2, V3, che contengano i cinque
valori di e1, e2, e3 per x=1, ..., 5. V1, V2, V3 contengono cinque valori che meglio approssimano i cinque valori
di V.
In[208]:= V1 = Table|E1, {x, 1, 5}]
V2 = Table|E2, {x, 1, 5}]
V3 = Table|E3, {x, 1, 5}]
Out[208]= {1.224, 1.224, 1.224, 1.224, 1.224]
Out[209]= {0.57, 0.897, 1.224, 1.551, 1.878]
Out[210]= {0.717143, 0.823429, 1.07686, 1.47743, 2.02514]
2bis. Confrontate il grafico di V con quello delle liste V1, V2, V3 ottenuto con le formule E1, E2, E3. Usate
ListPlot. Il risultato migliore si ottiene con la formula E3, che cerca di approssimare V usando una parabola; il
risultato peggiore, con la formula E1, che cerca di approssimare V usando una retta costante.
In[211]:= Needs|"PlotLegends`"]
In[212]:= ListPlot|{V, V1, V2, V3},
PlotStyle -> {Black, Directive|Dashed, Red], Directive|Dashed, Blue], Directive|Dashed, Yellow]},
Joined -{False, True, True, True}, PlotLegend -{L, "const", "retta", "parabola"}, AxesLabel -{i,}]
Out[212]=
1 2 3 4 5
i
0.5
1.0
1.5
2.0
parabola
retta
const
L
3. Il fitting al punto precedente e' stato effettuato assumendo che la variabile indipendente i assumesse i valori
1,2,3,...(vedi grafico). In molti casi questo non e' vero e occorre specificare in maniera esplicita i valori della
variabile indipendente x. Si pensi a dati sperimentali in cui un certa grandezza viene acquisita nello spazio, nel
tempo, in frequenza, ecc., dove e' evidente il significato fisico della variabile indipendente x ai fini del fitting. A
questo si puo' ovviare specificando i dati sperimentali con una matrice data anziche' una lista V. Come gia' visto al
punto 14 della lezione 2 nel caso di ListPlot, e' possibile descrivere una serie numerica con una particolare ascissa
creando una matrice Nx2 dove la prima colonna rappresenta l'ascissa e la seconda i dati misurati. A tal proposito
proviamo a ripetere l'eservizio precedente supponendo che i dati in V siano acquisiti per i valori della variabile
indipendente x={-1,-0.5,0,0.5,1}.
In[213]:= xdata = Table|x, {x, -1, 1, 0.5}]
data = Table|{xdata||i]], V||i]]}, {i, 1, 5}]
MatrixForm|V]
Out[213]= {-1., -0.5, 0., 0.5, 1.]
Out[214]= {{-1., 0.71], {-0.5, 0.88], {0., 0.95], {0.5, 1.59], {1., 1.99]]
0.71
0.88
0.95
1.59
1.99
In[216]:=
In[217]:= E1n = Fit|data, {1}, x]
E2n = Fit|data, {1, x}, x]
E3n = Fit|data, {1, x, x^2}, x]
Out[217]= 1.224
Out[218]= 1.224 + 0.654 x
Out[219]= 1.07686 + 0.654 x + 0.294286 x
2
Le formule ottenute sono diverse rispetto alle precendenti (ad eccezzione di E1n che costituisce un caso particolar-
mente semplice) visto che ora e' cambiato il significato della variabile x (che non specifica piu' semplicemente
l'indice del valore nel vettore. Concludiamo ora l'esercizio disegnando i punti e tutte le curve ottenute avendo cura
di rappresentare correttamente la variabile x.
In[220]:= MatrixForm|data1 = Table|{x, E1n}, {x, -1, 1, 0.5}]]
MatrixForm|data2 = Table|{x, E2n}, {x, -1, 1, 0.5}]]
MatrixForm|data3 = Table|{x, E3n}, {x, -1, 1, 0.5}]]
-1. 1.224
-0.5 1.224
0. 1.224
0.5 1.224
1. 1.224
-1. 0.57
-0.5 0.897
0. 1.224
0.5 1.551
1. 1.878
-1. 0.717143
-0.5 0.823429
0. 1.07686
0.5 1.47743
1. 2.02514
In[223]:= ListPlot|{data, data1, data2, data3},
PlotStyle -> {Black, Directive|Dashed, Red], Directive|Dashed, Blue], Directive|Dashed, Yellow]},
Joined -{False, True, True, True}, PlotLegend -{L, "const", "retta", "parabola"}, AxesLabel -{x,}]
Out[223]=
1.0 0.5 0.5 1.0
x
0.5
1.0
1.5
2.0
parabola
retta
const
L
Fit non lineare
4. Approfondimento: Il comando di Fit funziona anche per dati con piu' di due dimensioni. Basta operare con
matrici di dati NxM dove M e' la dimensione del problema. Ad esempio nel caso di dati in 3 dimensioni si avra'
data={{x1,y1,z1},{x2,y2,z2}...}. I primi M-1 dati rappresentano le variabili indipendenti del problema, l'ultimo
dato, nella colonna M, la variabile dipendente. L'obbiettivo del Fit in questo caso e' trovare una formula che
esprima la il valore della variabile dipendente a partire dai valori delle M-1 variabili indipendenti. Quando M=3,
per la visualizzazione dei dati si puo' usare ListPlot3D.
Torneremo sull'argomento quando parleremo di grafica 3D (tridimensionale).
5. Fitting non lineare. Il comando Fit e' limitato ad approssimazioni costituite dalla combinazione lineare di
funzioni. Dove la formula ricercata dipenda in modo non lineare dai parametri occorre usare il comando FindFit. In
questo caso, l'unicita' della soluzione "migliore" non e' piu' garantita. Come esempio si voglia approssimare una
serie di dati sperimentali con un esponenziale :
ox
con parametro o da ottimizzare, in modo da ottenere una lista
valori il piu' vicino possibili a quelli sperimentali. Questa funzione non e' lineare nel parametro o per cui non si
puo' usare il comando Fit.
Per cominciare vediamo l'Help rapido del comando:
In[224]:= ?FindFit
FindFit [data, expr, pars, vars] f inds numerical values of t he paramet ers pars t hat make expr give a best
f it t o data as a f unct ion of vars. The dat a can have t he f orm x
1
, y
1
, , f
1
, x
2
, y
2
, , f
2
, ,
where t he number of coordinat es x, y, is equal t o t he number of variables in t he list vars. The
dat a can also be of t he f orm f
1
, f
2
, , wit h a single coordinat e assumed t o t ake values 1, 2, .
FindFit [data, expr, cons, pars, vars] f inds a best f it subj ect t o t he paramet er const raint s cons.>
In questo caso expr puo' essere un espressione qualsiasi funzione delle variabili nella lista vars e dei parametri
nella lista pars. Proviamo a usare il comando per determinare il parametro o della formula :
ox
.
In[225]:= sub4 = FindFit|data, Exp|o=x], {o}, {x}]
Out[225]= {c - 0.67976]
In[226]:= {o -0.6797600345399801`}
Out[226]= {c - 0.67976]
In[227]:= ?sub4
Global`sub4
sub4 = {c - 0.67976]
L'output sub4 di questo formato e' leggermente diverso rispetto al precedente. Esso fornisce una lista di valori da
sostituire ai parametri nella formula expr (nel nostro caso Exp[a x]. L'operatore e' gia stato utilizzato per
assegnare i valori alla proprieta' dei grafici. In Mathematica questo tipo di assegnamento, detto "temporaneo" si
usa anche per specificare delle regole di sostituzione in combinazione con l'operatore di sostituzione (./.). Si veda
ad esempio:
In[228]:= (a + b) [. {a -1, b -2}
(a + b) [. {c - 10}
Out[228]= 3
Out[229]= a + b
Utilizziamo ora la sostituzione {o 0.67976} per costruire una tabella dei dati secodo il Fitting non lineare
ottenuto e creiamo un grafico.
In[230]:= MatrixForm|data4 = Table|{x, Exp|o=x] [. sub4}, {x, -1, 1, 0.5}]] (= substitution = {o-0.6797600345399801`} =)
-1. 0.506739
-0.5 0.711856
0. 1.
0.5 1.40478
1. 1.9734
In[231]:= ListPlot|{data, data4},
PlotStyle -> {Black, Directive|Dashed, Red]},
Joined -{False, True}, PlotLegend -{"Original Data", Exp|o=x]}, AxesLabel -{x,}]
Out[231]=
1.0 0.5 0.5 1.0
x
0.5
1.0
1.5
2.0
:
o x
Original Data
5bis. Proviamo ora a determinare il fitting con un funzione non lineare di due parametri :
o(x)
.
In[232]:= sub5 = FindFit|data, Exp|a=(x - m)], {a, m}, {x}]
?sub5
Out[232]= {a - 0.56997, m - -0.210934]
Global`sub5
sub5 = {a - 0.56997, m - -0.210934]
In[234]:= (= sub5 = {a-0.5699695344036192`,m--0.21093427960503208`} =)
data5 = Table|{x, Exp|a (x - m)] [. sub5}, {x, -1, 1, 0.5}]
ListPlot|{data, data4, data5},
PlotStyle -> {Black, Directive|Dashed, Red], Directive|Dashed, Blue]},
Joined -{False, True, True}, PlotLegend -{"data", Exp|a x], Exp|a (x - m)]}, AxesLabel -{x,}]
Out[234]= {{-1., 0.637792], {-0.5, 0.848098], {0., 1.12775], {0.5, 1.49962], {1., 1.99411]]
Out[235]=
1.0 0.5 0.5 1.0
x
0.5
1.0
1.5
2.0
:
a (xm)
:
a x
data
Import e Export da file
6. Lettura e scrittura di dati sperimentali (Import, Export). In molti casi i dati sperimentali possono essere
generati da un software o da strumenti di misura, che possono scrivere i dati in vari formati (.xls, .dat, ...) . Vicev-
ersa, puo' essere necessario esportare i dati numerici ottenuti con Mathematica in altri formati, perche' possano
essere utilizzati da altri programmi. A tal proposito si possono usare i comandi Import e Export che possono
gestire la maggior parte dei formati dei dati (documenti, immagini, audio, file di testo, video, ecc).
Scaricate dal sito del corso, lezione 4, i dati nella tabella Excel in dati4.xls. Per importare tali dati entro Mathemat-
ica, utilizziamo il comando Import["indirizzo_file_da_importare"]. L'indirizzo del file puo' consistere del solo
nome del file da importare seguito dal tipo, per esempio Import["dati4.xls"], purche' il file si trovi nella stessa
cartella (o "directory") in cui lavora Mathematica. Per conoscere tale directory utilizzate il comando Directory[].
Se il file da importare si trova in un'altra directory, di indirizzo "indirizzo_nuova_directory", potete spostare la
directory di lavoro con il comando SetDirectory["indirizzo_nuova_directory"]. In alternativa, potete usare l'indi-
rizzo completo del file da importare. Nel sistema operativo Window, per esempio, potremmo scrivere: Import["C:\-
Documents and Settings\utente\Documenti\dati4.xls"] se il file si trova nella cartella Documenti di un certo utente.
I dati importati devono venire assegnati a una variabile, oppure ricopiati con copia e incolla, altrimenti vanno persi.
In[236]:= Directory|]
Out[236]= C:\Documents and Settings\stefano\Documenti
In[237]:= (= Se la directory di lavoro e quella dove si trova il file da importare coincidono, basta scrivere il nome e il tipo del file =)
MatrixForm|dataxls = Import|"dati4.xls"]]
-10.
28.0316

-9.8
26.2238

-9.6
24.5325

-9.4
22.9504

-9.2
21.4702

-9.
20.0855

-8.8
18.7902

-8.6
17.5783
In[238]:= ?dataxls
Global`dataxls
dataxls =
{{{-10., 28.0316], {-9.8, 26.2238], {-9.6, 24.5325], {-9.4, 22.9504], {-9.2, 21.4702],
{-9., 20.0855], {-8.8, 18.7902], {-8.6, 17.5783], {-8.4, 16.4446], {-8.2, 15.3841],
{-8., 14.3919], {-7.8, 13.4637], {-7.6, 12.5954], {-7.4, 11.7831], {-7.2, 11.0232],
{-7., 10.3123], {-6.8, 9.64719], {-6.6, 9.02501], {-6.4, 8.44296], {-6.2, 7.89845],
{-6., 7.38906], {-5.8, 6.91251], {-5.6, 6.4667], {-5.4, 6.04965], {-5.2, 5.65949],
{-5., 5.29449], {-4.8, 4.95303], {-4.6, 4.6336], {-4.4, 4.33476], {-4.2, 4.0552],
{-4., 3.79367], {-3.8, 3.549], {-3.6, 3.32012], {-3.4, 3.10599], {-3.2, 2.90568],
{-3., 2.71828], {-2.8, 2.54297], {-2.6, 2.37897], {-2.4, 2.22554], {-2.2, 2.08201],
{-2., 1.94773], {-1.8, 1.82212], {-1.6, 1.7046], {-1.4, 1.59467], {-1.2, 1.49182],
{-1., 1.39561], {-0.8, 1.30561], {-0.6, 1.2214], {-0.4, 1.14263], {-0.2, 1.06894],
{0., 1.], {0.2, 0.935507], {0.4, 0.875173], {0.6, 0.818731], {0.8, 0.765928],
{1., 0.716531], {1.2, 0.67032], {1.4, 0.627089], {1.6, 0.586646], {1.8, 0.548812],
{2., 0.513417], {2.2, 0.480305], {2.4, 0.449329], {2.6, 0.42035], {2.8, 0.393241],
{3., 0.367879], {3.2, 0.344154], {3.4, 0.321958], {3.6, 0.301194], {3.8, 0.281769],
{4., 0.263597], {4.2, 0.246597], {4.4, 0.230693], {4.6, 0.215815], {4.8, 0.201897],
{5., 0.188876], {5.2, 0.176694], {5.4, 0.165299], {5.6, 0.154638], {5.8, 0.144665],
{6., 0.135335], {6.2, 0.126607], {6.4, 0.118442], {6.6, 0.110803], {6.8, 0.103657],
{7., 0.096972], {7.2, 0.090718], {7.4, 0.0848673], {7.6, 0.0793939],
{7.8, 0.0742736], {8., 0.0694835], {8.2, 0.0650023], {8.4, 0.0608101],
{8.6, 0.0568882], {8.8, 0.0532193], {9., 0.0497871], {9.2, 0.0465762],
{9.4, 0.0435723], {9.6, 0.0407622], {9.8, 0.0381333], {10., 0.035674]]]
7. Si nota che la tabella presente nel file xls e' costituita da due colonne. Tuttavia, Mathematica ha importato una
lista che contiene come unico elemento quella matrice. Questo si vede dal fatto che datixls inizia con 3 parentesi:
{{{ anziche' con 2: {{. Il motivo e' il seguente: nel caso generale un file xls e' costituito da piu' fogli, dunque
Mathematica importa una lista, con primo elemento la matrice nel primo foglio, secondo elemento la matrice nel
secondo foglio, e cosi' via.
Proviamo a selezionare la matrice scelta, modificare la seconda colonna applicando il logaritmo a tutti i suoi
elementi. Qundi utilizziamo il comando Export["indirizzo_file_da_salvare"] per salvare la nuova matrice. Se
vogliamo salvare in formato xls, il file deve terminare con ".xls".
In[239]:= datatab = dataxls||1]];
(= questo comando seleziona il primo e unico elemento della lista dataxls. questo elemento a sua volta e' una matrice =)
Print|"Il prossimo comando stampa il VECCHIO valore della matrice datatab, senza bordi"]
Grid|datatab]
Il prossimo comando stampa il VECCHIO valore della matrice datatab, senza bordi
Out[241]=
-10. 28.0316
-9.8 26.2238
-9.6 24.5325
-9.4 22.9504
-9.2 21.4702
-9. 20.0855
-8.8 18.7902
-8.6 17.5783
-8.4 16.4446
-8.2 15.3841
-8. 14.3919
-7.8 13.4637
-7.6 12.5954
-7.4 11.7831
-7.2 11.0232
-7. 10.3123
-6.8 9.64719
-6.6 9.02501
-6.4 8.44296
-6.2 7.89845
-6. 7.38906
-5.8 6.91251
-5.6 6.4667
-5.4 6.04965
-5.2 5.65949
-5. 5.29449
-4.8 4.95303
-4.6 4.6336
-4.4 4.33476
-4.2 4.0552
-4. 3.79367
-3.8 3.549
-3.6 3.32012
-3.4 3.10599
-3.2 2.90568
-3. 2.71828
-2.8 2.54297
-2.6 2.37897
-2.4 2.22554
-2.2 2.08201
-2. 1.94773
-1.8 1.82212
-1.6 1.7046
-1.4 1.59467
-1.2 1.49182
-1. 1.39561
-0.8 1.30561
-0.6 1.2214
-0.4 1.14263
-0.2 1.06894
0. 1.
0.2 0.935507
0.4 0.875173
0.6 0.818731
0.8 0.765928
1. 0.716531
1.2 0.67032
1.4 0.627089
1.6 0.586646
1.8 0.548812
2. 0.513417
2.2 0.480305
2.4 0.449329
2.6 0.42035
2.8 0.393241
3. 0.367879
3.2 0.344154
3.4 0.321958
3.6 0.301194
3.8 0.281769
4. 0.263597
4.2 0.246597
4.4 0.230693
4.6 0.215815
4.8 0.201897
5. 0.188876
5.2 0.176694
5.4 0.165299
5.6 0.154638
5.8 0.144665
6. 0.135335
6.2 0.126607
6.4 0.118442
6.6 0.110803
6.8 0.103657
7. 0.096972
7.2 0.090718
7.4 0.0848673
7.6 0.0793939
7.8 0.0742736
8. 0.0694835
8.2 0.0650023
8.4 0.0608101
8.6 0.0568882
8.8 0.0532193
9. 0.0497871
9.2 0.0465762
9.4 0.0435723
9.6 0.0407622
9.8 0.0381333
10. 0.035674
In[242]:= datatab||All, 2]] = Log|datatab||All, 2]]];
(= riassegnamo a tutti gli elementi della colonna 2 il logaritmo dei loro valori originali =)
Print|"Il prossimo comando stampa il NUOVO valore della matrice datatab, senza bordi"]
Grid|datatab]
(= Questo e' un indirizzo di un computer di un docente: per far funzionare questo comando nel vostro computer,
dovete scegliere un indirizzo del vostro computer =)
Export|"C:\Documents and Settings\stefano\Documenti\prova.xls", datatab]
Il prossimo comando stampa il NUOVO valore della matrice datatab, senza bordi
-10. 3.33333
-9.8 3.26667
-9.6 3.2
-9.4 3.13333
Out[244]=
-9.2 3.06667
-9. 3.
-8.8 2.93333
-8.6 2.86667
-8.4 2.8
-8.2 2.73333
-8. 2.66667
-7.8 2.6
-7.6 2.53333
-7.4 2.46667
-7.2 2.4
-7. 2.33333
-6.8 2.26667
-6.6 2.2
-6.4 2.13333
-6.2 2.06667
-6. 2.
-5.8 1.93333
-5.6 1.86667
-5.4 1.8
-5.2 1.73333
-5. 1.66667
-4.8 1.6
-4.6 1.53333
-4.4 1.46667
-4.2 1.4
-4. 1.33333
-3.8 1.26667
-3.6 1.2
-3.4 1.13333
-3.2 1.06667
-3. 1.
-2.8 0.933333
-2.6 0.866667
-2.4 0.8
-2.2 0.733333
-2. 0.666667
-1.8 0.6
-1.6 0.533333
-1.4 0.466667
-1.2 0.4
-1. 0.333333
-0.8 0.266667
-0.6 0.2
-0.4 0.133333
-0.2 0.0666667
0. 0.
0.2 -0.0666667
0.4 -0.133333
0.6 -0.2
0.8 -0.266667
1. -0.333333
1.2 -0.4
1.4 -0.466667
1.6 -0.533333
1.8 -0.6
2. -0.666667
2.2 -0.733333
2.4 -0.8
2.6 -0.866667
2.8 -0.933333
3. -1.
3.2 -1.06667
3.4 -1.13333
3.6 -1.2
3.8 -1.26667
4. -1.33333
4.2 -1.4
4.4 -1.46667
4.6 -1.53333
4.8 -1.6
5. -1.66667
5.2 -1.73333
5.4 -1.8
5.6 -1.86667
5.8 -1.93333
6. -2.
6.2 -2.06667
6.4 -2.13333
6.6 -2.2
6.8 -2.26667
7. -2.33333
7.2 -2.4
7.4 -2.46667
7.6 -2.53333
7.8 -2.6
8. -2.66667
8.2 -2.73333
8.4 -2.8
8.6 -2.86667
8.8 -2.93333
9. -3.
9.2 -3.06667
9.4 -3.13333
9.6 -3.2
9.8 -3.26667
10. -3.33333
Out[245]= C:\Documents and Settings\stefano\Documenti\prova.xls
8. Esportare la tabella ottenuta in formato "puro testo" o ASCII. Usare estensione .dat per ottenere una tabella in
formato ASCII. Individuare ed aprire il file ottenuto con un Editor di testo per verificare il risultato ottenuto
In[246]:= Export|"C:\Documents and Settings\stefano\Documenti\prova.dat", datatab]
Out[246]= C:\Documents and Settings\stefano\Documenti\prova.dat
9. Per conoscere tutti i tipi di file supportati su una certa installazione di Mathematica utilizzare i seguenti comandi
In[247]:= $ImportFormats
Out[247]= {3DS, ACO, Affymetrix, AIFF, ApacheLog, ArcGRID, AU, AVI, Base64, BDF, Binary, Bit,
BMP, Byte, BYU, BZIP2, CDED, CDF, Character16, Character8, CIF, Complex128,
Complex256, Complex64, CSV, CUR, DBF, DICOM, DIF, DIMACS, Directory, DOT, DXF,
EDF, EPS, ExpressionML, FASTA, FITS, FLAC, GenBank, GeoTIFF, GIF, GPX, Graph6,
Graphlet, GraphML, GRIB, GTOPO30, GXL, GZIP, HarwellBoeing, HDF, HDF5, HTML,
ICO, ICS, Integer128, Integer16, Integer24, Integer32, Integer64, Integer8,
JPEG, JPEG2000, JSON, JVX, KML, LaTeX, LEDA, List, LWO, MAT, MathML, MBOX,
MDB, MGF, MMCIF, MOL, MOL2, MPS, MTP, MTX, MX, NASACDF, NB, NDK, NetCDF, NEXUS,
NOFF, OBJ, ODS, OFF, Package, Pajek, PBM, PCX, PDB, PDF, PGM, PLY, PNG, PNM,
PPM, PXR, QuickTime, RawBitmap, Real128, Real32, Real64, RIB, RSS, RTF, SCT,
SDF, SDTS, SDTSDEM, SHP, SMILES, SND, SP3, Sparse6, STL, String, SurferGrid,
SXC, Table, TAR, TerminatedString, Text, TGA, TGF, TIFF, TIGER, TLE, TSV,
UnsignedInteger128, UnsignedInteger16, UnsignedInteger24, UnsignedInteger32,
UnsignedInteger64, UnsignedInteger8, USGSDEM, UUE, VCF, VCS, VTK, WAV,
Wave64, WDX, XBM, XHTML, XHTMLMathML, XLS, XLSX, XML, XPORT, XYZ, ZIP]
In[248]:= $ExportFormats
Out[248]= {3DS, ACO, AIFF, AU, AVI, Base64, Binary, Bit, BMP, Byte, BYU, BZIP2, C, CDF, Character16,
Character8, Complex128, Complex256, Complex64, CSV, DICOM, DIF, DIMACS, DOT, DXF,
EMF, EPS, ExpressionML, FASTA, FITS, FLAC, FLV, GIF, Graph6, Graphlet, GraphML,
GXL, GZIP, HarwellBoeing, HDF, HDF5, HTML, Integer128, Integer16, Integer24,
Integer32, Integer64, Integer8, JPEG, JPEG2000, JSON, JVX, KML, LEDA, List, LWO,
MAT, MathML, Maya, MGF, MIDI, MOL, MOL2, MTX, MX, NASACDF, NB, NetCDF, NEXUS, NOFF,
OBJ, OFF, Package, Pajek, PBM, PCX, PDB, PDF, PGM, PLY, PNG, PNM, POV, PPM, PXR,
QuickTime, RawBitmap, Real128, Real32, Real64, RIB, RTF, SCT, SDF, SND, Sparse6,
STL, String, SurferGrid, SVG, SWF, Table, TAR, TerminatedString, TeX, Text,
TGA, TGF, TIFF, TSV, UnsignedInteger128, UnsignedInteger16, UnsignedInteger24,
UnsignedInteger32, UnsignedInteger64, UnsignedInteger8, UUE, VideoFrames, VRML, VTK,
WAV, Wave64, WDX, WMF, X3D, XBM, XHTML, XHTMLMathML, XLS, XLSX, XML, XYZ, ZIP, ZPR]
Lezione 5: Grafica 3D e Quadriche.
Come disegnare funzioni z = f(x,y): il comando Plot3D
1. Plot3D e' un comando del tutto simile al comando Plot in grado di generare grafici in tre dimensioni. Questo
comando si puo' usare per disegnare funzioni note in forma esplicita grafici che si possano ridurre alla forma z=
f(x,y). Come esempio, disegnamo z=sin(x) nello spazio xyz (in questa equazione la variabile y manca):
In[249]:= Plot3D|Sin|x], {x, 0, 10}, {y, 0, 5}]
Out[249]=
2. Esempio di grafica 3D con problemi di ottimizzazione. Disegnare di un'onda a cerchi concentrici:
z = sin( x
2
+ y
2
)
usando il comando Plot3D senza particolari opzioni. Gli argomenti di Plot3D sono:
Plot3D[espr, {x, xmin, xmax}, {y, ymin, ymax}]
dove espr una espressione in x, y. Al posto di x, y possiamo usare due variabili qualunque.
In[250]:= Plot3D_Sin_ x
2
+ y
2
_,
{x, -20, 20}, {y, -20, 20}_
Out[250]=
3. Commento. La superficie viene disegnata congiungendo su una griglia di valori discreti per x e y un gran numero
di elementi di superficie in varie inclinazioni (in origine si usavano dei rettangoli). Mathematica 7 di solito rende
bene la grafica 3D, ma in questo caso, in assenza di indicazioni ha scelto di usare una griglia costituita di pochi
rettangoli; il fatto che tale griglia sia stata lasciata visibile rende pi difficile vedere la figura. Infine, Mathematica
ha deformato notevolmente la figura, scegliendo unit di misura molto diverse sui vari assi. Questo puo' non essere
il risultato desiderato. Per "forzare" Mathematica a generare un grafico migliore occorre configurare alcune
opzioni.
In[251]:= ?Plot3D
Plot 3D[ f , x, x
min
, x
max
, y, y
min
, y
max
] generat es a t hreedimensional plot of f as a f unct ion of x and y.
Plot 3D[ f
1
, f
2
, , x, x
min
, x
max
, y, y
min
, y
max
] plot s several f unct ions. >
In[252]:= Options|Plot3D]
Out[252]= {AlignmentPoint - Center, AspectRatio - Automatic, AutomaticImageSize - False,
Axes - True, AxesEdge - Automatic, AxesLabel - None, AxesOrigin - Automatic,
AxesStyle - {], Background - None, BaselinePosition - Automatic, BaseStyle - {],
BoundaryStyle - GrayLevel[0], Boxed - True, BoxRatios - {1, 1, 0.4], BoxStyle - {],
ClippingStyle - Automatic, ColorFunction - Automatic, ColorFunctionScaling - True,
ColorOutput - Automatic, ContentSelectable - Automatic, ControllerLinking - Automatic,
ControllerMethod - Automatic, ControllerPath - Automatic,
CoordinatesToolOptions - Automatic, DisplayFunction : $DisplayFunction,
Epilog - {], Evaluated - Automatic, EvaluationMonitor - None, Exclusions - Automatic,
ExclusionsStyle - None, FaceGrids - None, FaceGridsStyle - {], Filling - None,
FillingStyle - Opacity[0.5], FormatType : TraditionalForm, ImageMargins - 0.,
ImagePadding - All, ImageSize - Automatic, LabelStyle - {], Lighting - Automatic,
MaxRecursion - Automatic, Mesh - Automatic, MeshFunctions - {1 &, 2 &],
MeshShading - None, MeshStyle - Automatic, Method - Automatic,
NormalsFunction - Automatic, PerformanceGoal : $PerformanceGoal,
PlotLabel - None, PlotPoints - Automatic, PlotRange - {Full, Full, Automatic],
PlotRangePadding - Automatic, PlotRegion - Automatic, PlotStyle - Automatic,
PreserveImageOptions - Automatic, Prolog - {], RegionFunction - (True &),
RotationAction - Fit, SphericalRegion - False, TextureCoordinateFunction - Automatic,
TextureCoordinateScaling - Automatic, Ticks - Automatic, TicksStyle - {],
ViewAngle - Automatic, ViewCenter - Automatic, ViewMatrix - Automatic,
ViewPoint - {1.3, -2.4, 2.], ViewRange - All, ViewVector - Automatic,
ViewVertical - {0, 0, 1], WorkingPrecision - MachinePrecision]
4. Per ovviare alle scelte erronee fatte, useremo una versione con opzioni del comando Plot3D:
Plot3D[e, {x, xm, xM}, {y, ym, yM}, opzione1->valore1, ...]
Come esempio di opzioni, scegliamo: aumentare il numero di rettangoli a 100 x 100 (opzione PlotPoints->100);
rendere invisibile la griglia sulla superficie (opzione Mesh); limitare l'asse verticale tra -20 e 20 (opzione
PlotRange->{-20,20}); rendere uguale l'unita' di misura usata sui tre assi (opzione BoxRatios-> Automatic) (Si
veda nell'Help come usare queste opzioni).
La stessa superficie apparir ora molto diversa (e pi vicina al suo aspetto reale).
In[253]:= Plot3D_Sin_ x
2
+ y
2
_, {x, -20, 20}, {y, -20, 20},
PlotPoints -> 100,
BoxRatios -> Automatic,
PlotRange -> {-20, 20}, Mesh -False _
Out[253]=
Nota: su AspecRatio e BoxRatios. Il comando per rendere uguali le tre unita' di misura sugli assi non e' piu'
AspectRatio->Automatic come nella grafica 2D. AspectRatio->Automatic rende uguali le due unita' di misura sugli
assi nella grafica 2D, ma nella grafica 3D ha un effetto piu' blando, sceglie base e altezza del disegno in base alle
tre dimensioni della "scatola" immaginaria che contiene il disegno. Attenzione: se usiamo BoxRatios->Automatic,
come risultato possiamo ottenere una scatola con tre dimensioni molto diverse, non effettivamente disegnabile.
Il comando "BoxRatios" puo' essere usato per rendere le tre unita' di misura uguali, ma ha anche un uso opposto:
scegliere il rapporto tra le tre dimensioni della "scatola" indipendentemente dal disegno, e deformare di con-
seguenza le tre unita' di misura in modo che il disegno si iscriva nella scatola. Per esempio BoxRatios->{1,1,1}
disegna sempre la figura in un cubo, anche a prezzo di deformarla notevolmente. Rivediamo come esempio la
prima figura della sezione per accorgerci quanto cambia:
In[254]:= Plot3D|Sin|x], {x, 0, 10}, {y, 0, 5}, BoxRatios - {1, 1, 1}]
Out[254]=
Infine, molte superfici non si possono scrivere nella forma z=f(x,y) e devono venire descritte in forma parametrica
(x=f(t,u), y=g(t,u), z=h(t,u)) oppure implicita (P(x,y,z)=0). In questo caso il comando Plot3D non e' adatto a
disegnarle. Nella prossima sezione spieghiamo come disegnare linee e superfici parametriche nello spazio.
Quadriche. Come disegnare linee e superfici parametriche nel piano e nello spazio.
Come complemento al corso di Geometria in questa lezione vedremo le diverse superfici nello spazio che possono
venire descritte da una equazione di secondo grado P(x,y,z)=0: paraboloide ellittico e a sella, cilindro, cono, ellisse,
sfera, iperboloide a una e due falde. Oltre a spiegare come disegnare le quadriche, spieghiamo anche come diseg-
nare superfici descritte in forma parametrica (x=f(t,u), y=g(t,u), z=h(t,u)).
Quadriche: il Paraboloide ellittico
5. Un paraboloide ellittico, di braccia a e b, e' una qualunque superficie che con rotazioni e traslazioni si puo'
portare nella forma:
z = |x
2
a
2
] | y
2
/b
2
)
Le sezioni orizzontali sono tutte ellissi di braccia a,b, e le sezioni verticali sono tutte parabole. La figura si puo'
ruotare con l'uso del mouse. Potete disegnare da un opportuno punto di vista usando l'opzione ViewPoint ->
{x,y,z}, dove {x,y,z} sono le coordinate dell'osservatore del disegno (leggete l'Help per saperne di pi).
In[255]:= a = 2; b = 3;
ParaboloideEllittico = Plot3D[[x
2
a
2
] + [y
2
b
2
], {x, -20, 20}, {y, -20, 20},
PlotRange -> {0, 20},
AspectRatio -> 1, ViewPoint -> {0.062, -0.114, 3.381}, PlotPoints -> {100, 100}]
Out[256]=
6. Notate che Mathematica riempe eventuali "buchi" presenti nella superficie, aggiungendo dei "rammendi" che
non fanno parte del disegno originale. Il valore dell'opzione ClippingStyle determina la modalita' con cui vengono
disegnate le parti "tagliate" della superficie. Se non volete riempire le parti tagliate dovete porre ClippingStyle-
>None. Ponendo ClippingStyle->Opacity[r], con un valore di r tra 0 e 1, si puo' rendere la parte tagliata semitraspar-
ente. Nell'esempio che segue definiamo una lista di disegni di z=sin(xy) usando diversi valori per l'opzione Clip-
pingStyle: None (nessun riempimento), Opacity[1/3] (riempimento trasparente al 33%), Opacity[2/3]
(riempimento trasparente al 33%), Automatic (riempimento pieno).
In[257]:= L = Table|Plot3D|Sin|x y], {x, -3, 3}, {y, -3, 3}, PlotRange -> {-.7, .7}, ImageSize -300, ClippingStyle -cs],
{cs, {None, Opacity|1[ 3], Opacity|2[ 3], Automatic}}];
In[258]:= ListAnimate|L] (= facciamo scorrere le immagini di L =)
Out[258]=
6. Rivediamo ora il paraboloide ellittico senza riempire i "buchi" presenti nella superficie (ClippingStyle None).
In[259]:= Plot3D[[x
2
a
2
] + [y
2
b
2
], {x, -20, 20}, {y, -20, 20},
AspectRatio -> 1, ViewPoint -> {0.062, -0.114, 3.381}, PlotPoints -> {100, 100}, ClippingStyle - None]
Out[259]=
Un caso particolare di paraboloide e' il paraboloide circolare, quando a=b e le sezioni orizzontali sono circon-
ferenze. Il paraboloide circolare puo' ottenere facendo ruotare una parabola intorno al proprio asse verticale.
In[260]:= a = 3; b = 3;
Plot3D[[x
2
a
2
] + [y
2
b
2
], {x, -20, 20}, {y, -20, 20},
AspectRatio -> 1, ViewPoint -> {0.062, -0.114, 3.381}, PlotPoints -> {100, 100}, ClippingStyle - None]
Out[261]=
Quadriche: Paraboloide iperbolico (o a sella)
7. Un paraboloide iperbolico e' una qualunque superficie che con rotazioni e traslazioni si puo' portare nella forma:
z = |x
2
a
2
] | y
2
/b
2
)
Le sezioni orizzontali sono tutte iperboli mentre quelle verticali sono tutte parabole (alcune rivolte verso l'alto e
altre rivolte verso il basso). Disegnamolo usando tutte le opzioni viste in precedenza.
In[262]:= a = 2; b = 3; ParaboloideIperbolico = Plot3D[ [x
2
a
2
] - [y
2
b
2
], {x, -20, 20}, {y, -20, 20},
PlotRange -> {-20, 20}, ClippingStyle -> None, AspectRatio -> 1, PlotPoints -> {100, 100}]
Out[262]=
Una superficie e' detta rigata se e' l'unione di una famiglia di rette. Il paraboloide a sella e' una quadrica rigata. Si
puo' costruire intrecciando aste rigide, come vedremo nell'ultima sezione dedicata alle quadriche.
Linee parametriche nel piano: circonferenza e ellisse. Come disegnare linee parametriche nel piano.
Molte linee nel piano definite da un'equazione P(x,y)=0, incluse molte coniche (circonferenza, ellisse, iperbole
nella forma 1 = |x
2
a
2
] | y
2
/b
2
) ) non si possono porre nella forma y=f(x). In questo caso si cerca di trasformarle
in un sistema equivalente di equazioni x=f(t), y=g(t), quindi si disegna l'insieme dei punti (x,y) che soddisfano le
equazioni x=f(t), y=g(t) per qualche u. Il parametro t si interpreta come la coordinata di un punto sulla linea
P(x,y)=0. Il modello e' la descrizione della circonferenza 1 = x
2
+ y
2
mediante un parametro t che viene interpre-
tato come l'angolo (in radianti) tra la retta congiungente l'origine e (x,y), e l'asse delle x. L'equazione parametrica
e': x = cos(t), y = sin(t).
Una equazione parametrica nel piano viene disegnata tramite il comando ParametricPlot[.]
In[263]:= Circonferenza = ParametricPlot|{Cos|t], Sin|t]}, {t, 0, 2 Pi}]
Out[263]=
1.0 0.5 0.5 1.0
1.0
0.5
0.5
1.0
Possiamo ottenere una equazione parametrica per l'ellisse 1 = |x
2
a
2
] + | y
2
/b
2
) dall'equazione parametrica della
circonferenza, cambiando l'unita' di misura sull'asse x da 1 ad a, e l'unita' di misura sull'asse y da 1 a b. L'equazione
parametrica e': x = cos(t), y = sin(t).
In[264]:= a = 2; b = 3;
ParametricPlot|{a=Cos|t], b=Sin|t]}, {t, 0, 2 Pi}]
Out[265]=
2 1 1 2
3
2
1
1
2
3
Quadriche parametriche: Cilindro, Doppio Cono. Come disegnare superfici parametriche nello spazio.
Molte superfici definite da un'equazione P(x,y,z)=0, incluso molte quadriche (sfera, ellisse, cilindro, ...), non si
possono porre nella forma z=f(x,y). In questo caso si cerca di trasformarle in un sistema equivalente di equazioni
x=f(t,u), y=g(t,u), z=h(t,u), quindi si disegna l'insieme dei punti (x,y,z) che soddisfano le equazioni x=f(t,u),
y=g(t,u), z=h(t,u), per qualche t,u nel dominio dei parametri. I parametri t,u si interpretano come una griglia tu di
coordinate (non necessariamente cartesiane, ne' ortogonali) sulla superficie P(x,y,z)=0. Ci si ispira alla descrizione
parametrica della superficie terrestre, che vedremo tra poco: in questo caso la griglia di coordinate tu e' la griglia
dei meridiani e paralleli che descrivono ogni punto della terra con due numeri reali, la longitudine t e la latitudine u.
9. Quadriche parametriche: Cilindro. Un cilindro e' una qualunque conica che si possa porre, mediante rotazioni
e translazioni, nella forma
1 = |x
2
a
2
] | y
2
/b
2
) (l'equazione e' nelle variabili x,y,z, ma la variabile z manca)
Vogliamo disegnare la superficie 1 = |x
2
a
2
] | y
2
/b
2
) nello spazio xyz. Riutilizziamo la soluzione di 1 =
|x
2
a
2
] | y
2
/b
2
) nel piano, aggiungendo un parametro u per descrivere z:
x = a*cos(t), y = b*sin(t), z = u (te[0,2r], ueR)
Le coordinate (x,y,z) di un punto del cilindro sono espresse in funzione dei parametri t,u. Se t e' fisso, il
parametro u descrive una retta verticale, se u e' fisso il parametro t descrive una circonferenza orizzontale. Rette e
circonferenze insieme descrivono una griglia di coordinate sul cilindro. Il comando ParametricPlot3D permette di
disegnare curve espresse in forma parametrica. Gli argomenti di ParametricPlot3D[...] sono la lista delle 3
equazioni per x,y,z, e i due domini di t e di u.
In[266]:= a = 2; b = 3;
ParametricPlot3D|{a=Cos|t], b=Sin|t], u}, {t, 0, 2 Pi}, {u, -2, 2}]
Out[267]=
9. Superfici parametriche: quadriche. Doppio Cono. Un doppio cono e' una qualunque conica che si possa porre,
mediante rotazioni e translazioni, nella forma
z
2
= |x
2
a
2
] | y
2
/b
2
)
Vogliamo disegnare la superficie z
2
= |x
2
a
2
] | y
2
/b
2
) nello spazio xyz. Ispirandoci alla soluzione per il cilindro
1 = |x
2
a
2
] | y
2
/b
2
) , scriviamo:
x = u * a* cos(t), y = u * b * sin(t), z = u (te[0,2r], ueR)
La superficie e' espressa in funzione dei parametri t,u. La sezione per z=u e' una ellisse di braccia a*u, b*u. Se t e'
fisso, il parametro u descrive una retta obliqua per il vertice del cono, se u e' fisso il parametro t descrive una
ellisse orizzontale (una circonferenza se a=b). Rette e ellissi insieme descrivono una griglia di coordinate sul
cilindro.
In[268]:= a = 1; b = 1;
ParametricPlot3D|{u=a= Cos|t], u=b= Sin|t], u}, {t, 0, 2 Pi}, {u, -2, 2}]
Out[269]=
Quadriche parametriche: Ellissoide e Sfera.
10. Sfera. Una sfera e' una e' una qualunque conica che si possa porre, mediante rotazioni e translazioni, nella
forma
R
2
= x
2
+ y
2
+ z
2

Disegnare la sfera R
2
= x
2
+ y
2
+ z
2
come superficie parametrica, usando la coordinata t per la longitudine e la
coordinata u per la latitudine. Studiando le coordinate usate per la superficie terrestre, arriviamo alla conclusione
che il parallelo u e' una circonferenza di raggio R*cos(u) e altezza rispetto all'equatore R*sin(u). Da questa
osservazione otteniamo la seguente equazione parametrica:
x = R*cos(u)*cos(t), y = R*cos(u)*sin(t), z = R*sin(u) (te[0,2r], ue[-r/2,r/2])
In[270]:= R = 1;
ParametricPlot3D|{R=Cos|u] =Cos|t], R=Cos|u] =Sin|t], R=Sin|u]}, {t, 0, 2 n}, {u, -n[ 2, n[ 2}]
Out[271]=
11. Ellissoide. Un ellissoide di braccia ab,c, e' una e' una qualunque conica che si possa porre, mediante rotazioni e
translazioni, nella forma
1 = |x
2
a
2
] + | y
2
/b
2
) +|z
2
/c
2
)
Otteniamo l'equazione parametrica dell'ellissoide da quella della sfera di raggio 1, modificando le unita' di misura
su x,y,z da R ad a,b,c.
x = R*cos(u)*cos(t), y = R*cos(u)*sin(t), z = R*sin(u) (te[0,2r], ue[-r/2,r/2])
In[272]:= a = 1; b = 2; c = 3;
ParametricPlot3D|{a=Cos|u] =Cos|t], b=Cos|u] =Sin|t], c=Sin|u]},
{t, 0, 2 n}, {u, -n[ 2, n[ 2}, PlotPoints -> {50, 50}, ViewPoint -> {4, 9, 1}]
Out[273]=
Superifici parametriche: Iperboloide a una falda.
12. Iperboloide a una falda. Un iperboloide a una falda e' una e' una qualunque conica che si possa porre, medi-
ante rotazioni e translazioni, nella forma
1 = |x
2
a
2
] + | y
2
/b
2
) |z
2
/c
2
)
Supponiamo a=b=c=1 per semplicita', e disegnamo la superficie 1 = x
2
+ y
2
z
2
. Una sezione z=u dell'iperboloide
e' una circonferenza (1+u
2
) = x
2
+ y
2
di raggio 1 + u
2
. Questo suggerisce di scrivere le equazioni parametriche
di una circonferenza di raggio 1 + u
2
:
x = cos(t) 1 + u
2
, y = sin(t) 1 + u
2
, z = u (te[0,2r])
Cambiando le unita' di misura sui tre assi da 1 ad a, b, c,
otteniamo la forma generale dell ' equazione parametrica dell ' iperboloide a una falda.
x = a+cos (t) 1 + u
2
, y = b+sin (t) 1 + u
2
, z = c+u (te[0, 2 r], ueR)
In[274]:= a = 1; b = 1; c = 1;
ParametricPlot3D_[a=Cos|t] 1 + u
2
, b=Sin|t] 1 + u
2
, c=u_, {t, 0, 2 n}, {u, -3, 3}, PlotPoints -> {50, 50}_
Out[275]=
Superfici parametriche: iperboloidi a due falde. Unione (Show[.]) di due o piu' grafici.
Iperboloide a due falde (come superficie parametrica). Un iperboloide a una falda e' una e' una qualunque conica
che si possa porre, mediante rotazioni e translazioni, nella forma
1 = |x
2
a
2
] | y
2
/b
2
) |z
2
/c
2
)
La sezione lungo x= a*u (un piano parallelo a yz) 1 = u
2
| y
2
/b
2
) |z
2
/c
2
), ovvero | y
2
b
2
] + |z
2
/c
2
) = u
2
-1,
ovvero:
| y
2
b
2
] + |z
2
/c
2
) = R
2
dove R = |x
2
a
2
] 1 . Riscriviamo ancora l'equazione come | y
2
R
2
b
2
] + |z
2
/R
2
c
2
) = 1. Questa e' l'equazione
di una ellisse di braccia Rb, Rc. La sezione lungo un piano orizzontale ha quindi equazione parametrica:
x = a*u
y = R*b*cos(t) = u
2
1 * b * cos(t)
z = R*c*sin(t) = u
2
1 * b * sin(t)
con te[0,2r] e u1 oppure us-1. Disegniamo separatamente i due casi, ottenendo le falde sinistra ip1 e destra ip2
dell'iperbole, quindi uniamole (comando Show).
In[276]:= a = 3; b = 2; c = 1;
ip1 = ParametricPlot3D_
[a=u, b=Cos|t] u
2
- 1 , c= Sin|t] = u
2
- 1 _,
{t, 0, 2 n}, {u, 1, 2},
PlotPoints -> {50, 50}, BoxRatios -> {1, 1, 1},
ImageSize -300, PlotRange -All_
Out[277]=
In[278]:= ip2 = ParametricPlot3D_
[a=u, b=Cos|t] u
2
- 1 , c= Sin|t] = u
2
- 1 _,
{t, 0, 2 n}, {u, -2, -1},
PlotPoints -> {50, 50}, BoxRatios -> {1, 1, 1},
ImageSize -300, PlotRange -All_
Out[278]=
In[279]:= Show|ip1, ip2, PlotRange -All]
Out[279]=
Lezione 6: Definizione di funzioni
La sintassi f[x_]:= ... delle funzioni.
Partiamo dal concetto di funzione di una variabile y=f(x) e vediamo come e' possibile definirla usando la sintassi
del software Mathematica. Vogliamo creare una funzione f(x)=x
2
+a che calcola il quadrato di x, piu' a. Innanzi-
tutto vediamo un esempio di cose da non fare.
1. Non definite la funzione f scrivendo semplicemente f =x
2
+a. Ecco perche'.
In[280]:= Clear|f, x, a]
f = x
2
a;
x = -1
f
Out[282]= -1
Out[283]= 1 + a
Con il primo comando abbiamo creato il simbolo f che vale x
2
+a. Al variare del valore x cambia il valore di f
come desiderato e quindi abbiamo apparentemente ottenuto il nostro obiettivo.
In[284]:= x = 3;
f
Out[285]= 9 + a
Tuttavia, per usare f dobbiamo ricordarci che il valore di ingresso di f va inserito in x. Se per sbaglio usiamo x
come una costante (per es. x=100), ogni volta che valutiamo f per esempio in x=3 perdiamo il valore x=100
assegnato a x.
In[286]:= x = 100;
In[287]:= x = 3;
f
x
Out[288]= 9 + a
Out[289]= 3
1-bis. Non definite f scrivendo f(x)=x
2
a, se usate le parentesi tonde moltiplicate f per x. Non definite f
scrivendo semplicemente f[x] = x
2
+a, in questo caso la funzione trasforma x in x
2
a, ma ignora cosa fare di
qualunque altro valore:
In[290]:= Clear|f, x, a]
f|x] = x
2
+ a;
{f|x], f|3], f|y]}
Out[292]= a + x
2
, f[3], f[y]
Vogliamo invece definire la funzione f(x) per un valore generico di x, senza che x sia una variabile globale a cui
possiamo assegnare un valore. Questo si ottiene facendo seguire la variabile indipendente x dal simbolo _ nella
definizione di funzione: f[x_].
1-ter. Non definite f scrivendo f[x_]=x
2
a, usando l'assegnazione statica =. In questo caso, la definizione viene
eseguita per il valore corrente del parametro a, se ne esiste uno. Se in seguito il valore di a cambia la funzione non
cambia.
In[293]:= Clear|f, x, a];
a = 7;
f|x_] = x
2
a;
? f
f |100]
a 13
f |100] il risultato dovrebbe essere 10010013, invece e' 1001007
Global`f
f[x_] = 7 + x
2
Out[297]= 10007
Out[298]= 13
Out[299]= 10007
2. La definizione corretta. Vogliamo invece definire la funzione f(x) per un valore generico di x, senza che x sia
una variabile globale a cui possiamo assegnare un valore. Questo risultato si ottiene usando l'operatore :=
(definizione o assegnazione dinamica) e una particolare sintassi per specificare la variabile indipendente della
funzione. La variabile indipendente x va seguita dal simbolo _ nella definizione di funzione: scriviamo
f[x_]:= espressione in x
In[300]:= Clear|f, x];
f|x_] := x
2
;
f|3]
(= applicato g a una lista g viene applicata ad ogni elemento della lista =)
f|{-2, 2}]
f|x]
(= x e' una variabile globale, se assegno la x globale non assegno il parametro x di f=)
x = 100;
f|100]
Out[302]= 9
Out[303]= {4, 4]
Out[304]= x
2
Out[306]= 10000
In[307]:=
La funzione cosi' creata si puo' utilizzare nella maniera desiderata. La variabile x e' usata come variabile indipen-
dente nella definizione e non entra in conflitto il valore x=100 della variabile globale x. Si noti inoltre che invo-
cando f[.] e' possibile sostituire x con una qualsiasi espressione. L'applicazione della funzione va a buon fine se
l'operazione di elevamento al quadrato e' definita per quell'espressione (come nel caso di un numero o di una lista).
3. Funzioni di piu' parametri. La sintassi vista al punto 2 puo' essere utilizzata anche per funzioni di piu
parametri. Scriviamo ad esempio una funzione di-piu' parametri. Ad esempio definiamo la funzione
h(x, t) = 1 :
tx
. Usiamo quindi la funzione appena definita per farne il grafico di h(.,t) per x compresi tra 0 e 5 e
due valori di t=0.1 e t=0.9, rispettivamente.
In[308]:= h|x_, t_] := 1 - Exp|-t =x];
?h
Needs|"PlotLegends`"]
Plot|{h|x, 0.1], h|x, 0.9]}, {x, 0, 5}, PlotStyle -{Directive|Red, Dotted], Directive|Blue, Dashed]},
PlotLegend -{"t=0.1", "t=0.9"}, AxesLabel -{x}, PlotLabel -h|x, t]]
Global`h
h[x_, t_] := 1 - Exp[-t x]
Out[311]=
1 2 3 4 5
100
0.2
0.4
0.6
0.8
1.0
1 :
100 t
t=0.9
t=0.1
Esempi di creazione di comandi personalizzati: punto3D, vettore3D.
4. Creazione di comandi personalizzati. Il concetto di funzione in Mathematica assume un significato del tutto
generale. Le funzioni possono coinvolgere non solo l'insieme dei numeri reali, complessi, ecc ma possono operare
su qualisiasi tipo di argomento; possono quindi essere usate per creare nuovi comandi. In genere e' buona regola
creare un nuovo comando per funzioni che verrano utilizzate frequentemente, in modo da poter scrivere i nostri
comandi in modo piu' breve e quindi piu' leggibile. Lo scopo non e' soltanto una maggiore chiarezza: piu' una lista
di comandi e' chiara, piu' e' facile scoprire gli errori che abbiamo fatto.
Esempio di comandi di grafica: punti e frecce.
5. Funzioni grafiche. Introduciamo ora alcuni comandi grafici per disegnare punti e frecce corredate di etichette;
in seguito vedremo come abbreviarli usando funzioni. Disegnamo nel piano un punto P di coordinate {x,y}={-1,1}
e un freccia che va dal punto P al punto Q={1,2}.
In[312]:= p = {-1, 1};
q = {1, 2};
Graphics|Point|p]]
Graphics|Arrow|{p, q}]]
Out[314]=
Out[315]=
6. Per sovrappore piu' disegni e piu' comandi basta creare una lista di tali disegni e comandi da usare come argo-
mento di Graphics. I comandi vengono eseguiti e i disegni vengono fatti nell'ordine con cui compaiono nella lista.
In[316]:= Graphics|{Red, Arrow|{p, q}], Blue, Point|p]}]
Out[316]=
7. Con il comando Text[etichetta, {x,y} ] e Style e' possibile creare etichette di testo formattato nelle coordinate
{x,y}.
In[317]:= Graphics|Text|"A", {0, 0}]]
Style|"ciao", Italic, 32]
Graphics|Text|Style|"ciao", Bold, 24], {0, 0}]]
Out[317]=
A
Out[318]= ciao
Out[319]=
ciao
8. Vediamo infine un esempio che coinvolge un gran numero di oggetti grafici e comandi. "Disk" disegna un
cerchio dati centro e raggio, "Dashed" rende una linea tratteggiata, "Thick" la rende spessa. "Circle" disegna una
circonferenza (cioe' il bordo di un cerchio) dati centro e raggio.
In[320]:= Graphics|{Green, Rectangle|{0, -1}, {2, 1}], Blue, Disk|{0, 0}, 1], Red, Disk|{0, 0}, 0.5],
Dashed, Thick, Black, Circle|{1, 0}, 1], Text|Style|"Centro", White, Bold, 28], {1, 0}]}]
Out[320]=
Centro
9. Lo stesso tipo di procedura si applica al caso a 3 dimensioni utilizzando il comando Graphics3D. "Arrow"
disegna una freccia tra due punti p, q (dati attraverso le loro coordinate). PointSize[r] rende i punti di dimensione
una percentuale r del disegno totale: r=0.01 gia' disegna punti grandi.
In[321]:= p = {0, 0, 1}
q = {1, 1, 1}
Graphics3D|
{Red, Arrow|{p, q}], Text|Style|"Q", 24], q + 0.05], Blue, PointSize|0.05], Point|p], Text|Style|"P", 24], p + 0.05]}]
Out[321]= {0, 0, 1]
Out[322]= {1, 1, 1]
Out[323]=
Q
P
Funzioni per disegnare punti e frecce.
10.Tutti gli esempi precedenti dimostrano come l'uso delle primitive grafiche per costruire oggetti piu' complessi
possa portare a comandi complessi e lunghi da leggere e da controllare. Nell'arco di questo corso il disegno di
punti e vettori nello spazio sara' usato molto frequentemente. A questo proposito e' utile definire nuovi comandi per
svolgere velocemente tali operazioni.
In[324]:= punto3D|p_, label_, colore_] := Graphics3D|{Thickness|0.01], PointSize|0.01],
colore, Point|p], Text|Style|label, Bold, 24], p + 0.02]}];
vettore3D|p_, label_, colore_] := Graphics3D|{Thickness|0.01], PointSize|0.01],
colore, Arrow|{{0, 0, 0}, p}], Text|Style|label, Bold, 24], p + 0.02]}];
vettore3D|p1_, p2_, label_, colore_] := Graphics3D|{Thickness|0.01], PointSize|0.01],
colore, Arrow|{p1, p2}], Text|Style|label, Bold, 24], (p1 + p2) [ 2]}];
In[327]:= Show|punto3D|p, "P", Red], vettore3D|q, "Q", Blue], vettore3D|p, q, "PQ", Green]]
Out[327]=
P
Q
PQ
Comandi composti (CompoundExpression, Module), variabili locali e cicli.
11. Funzioni con sequenze di comandi. E' possibile creare una funzione costituita da un sequenza di piu' comandi
utilizzando CompoundExpression[ comando1; comando2; ... ]. Il valore restituito dal comando definito e'
costituito dall'ultima espressione valutata. Creiamo ora il comando sommasqrt[a,b] che somma a e la radice
quadrata di b solo se b>=0. In caso contrario restituisce il valore di a.
In[328]:=
sommasqrt|a_, b_] := CompoundExpression|
z = If|b 0, Sqrt|b], 0];
a + z]
In[329]:= ?sommasqrt
Global`sommasqrt
sommasqrt[a_, b_] := CompoundExpressionz = Ifb ~ 0, b , 0; a + z
In[330]:= sommasqrt|1, 4]
sommasqrt|1, -2]
Out[330]= 3
Out[331]= 1
12. Variabili locali e variabili globali. Con il precedente comando abbiamo introdotto una variabile di appoggio z.
Se utilizziamo il comando appena definito in nu notebook dove z e' gia definito il suo valore viene sovrascritto e
puo' generare errori. Controlliamo infatti che valore a z dopo l'uso di sommasqrt
In[332]:= sommasqrt|1, 5]
?z
Out[332]= 1 + 5
Global`z
z = 5
La variabile z "sopravvive" al di fuori del comando perche' si tratta di una variabile globale. Nella maggiorparte dei
casi le variabili di appoggio definite all'interno di una funzione devono assumere valenza locale per evitare di
entrare in conflitto con altre variabili globali. Per ottenere questo risultato occorre usare il costrutto Module.
In[334]:= ?Module
Module[x, y, , expr] specif ies t hat occurrences of t he symbols x, y, in expr should be t reat ed as local.
Module[x = x
0
, , expr] def ines init ial values f or x, . >
Ridefiniamo il comando sommasqrtlocal[a,b] usando Module in modo che z sia trattata come variabile locale.
In[335]:= Clear|z];
sommasqrtlocal|a_, b_] := Module |{z},
z = If|b 0, Sqrt|b], 0];
a + z]
In[337]:= sommasqrtlocal|1, 4]
?z
Out[337]= 3
Global`z
13. Abbiamo gia' visto l'operatore condizionale If . Altri costrutti tipici della programmazione sono i comandi per
costruire algoritmi iterativi: Do, While, For
In[339]:= ?Do
?While
?For
Do[expr, i
max
] evaluat es expr i
max
t imes.
Do[expr, i, i
max
] evaluat es expr wit h t he variable i successively t aking on t he values 1 t hrough i
max
(in st eps of 1).
Do[expr, i, i
min
, i
max
] st art s wit h i = i
min
.
Do[expr, i, i
min
, i
max
, di] uses st eps di.
Do[expr, i, i
1
, i
2
, ] uses t he successive values i
1
, i
2
, .
Do[expr, i, i
min
, i
max
, j, j
min
, j
max
, ] evaluat es expr looping over dif f erent values of j, et c. f or each i. >
While[test, body] evaluat es test, t hen body, repet it ively, unt il test f irst f ails t o give True. >
For[start, test, incr, body] execut es start, t hen repeat edly evaluat es body and incr unt il test f ails t o give True. >
In[342]:= Do|Print|i], {i, 1, 10}]
For|i = 1, i 10, i = i + 1, Print|i]]
i = 1; While|i 10, Print|i]; i = i + 1;]
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
Compito a casa sulle funzioni
Lezione 7: Complementi di grafica 3D.
Questa sottosezione pu venir omessa in prima lettura.
Nell'ultima sezione di questo capitolo prendiamo spunto da una collezione di modelli di superfici, in legno dipinto,
che si puo' ammirare alla Biblioteca Peano (Dipartimento di Matematica dell'Universita' di Torino, via Carlo
Alberto 10, Torino). Di questi modelli disponibile in rete una versione virtuale, gratuita, dovuta al dott. Todesco
(con consulenza scientifica del Prof. Ferrarese), all'indirizzo:
"I Modelli del Dipartimento di Matematica" http://www.dm.unito.it/modelli/
Molte superfici notevoli si possono ammirare curiosando per il Web. Citiamo come esempio:
"Steiner Surfaces" http://www.ipfw.edu/math/Coffman/steinersur-
face.html
Maggiori dettagli si trovano nel libro della Biblioteca Peano:
La collezione dei modelli di superfici del Dipartimento di Matematica dell'Universit di Torino.
A. Cavagnero, G. Ferrarese Dipartimento di Matematica, Universit di Torino, Conferenze e Seminari 1997-1998,
Ass. Subalpina Mathesis, 219-234
Superfici rigate.
Superfici rigate: il paraboloide a sella. Come disegnare linee parametriche nello spazio.
Mostriamo come il paraboloide a sella
z = |x
2
a
2
] | y
2
/b
2
)
possa essere ottenuto come una unione di una famiglia di rette. Definiamo due famiglie R1 e R2: l'unione di R1 e' il
paraboloide a sella, e cosi' l'unione di R2. Descriviamo le rette in forma parametrica. Una generica retta dello
spazio xyz in forma parametrica e' una lista di 3 equazioni: x=f(t), y=g(t), z=h(t), dove f,g,h sono funzioni lineari in
t. Per esempio, la famiglia R1 di rette e' definita da:
x=a*(t + p1)
y=b*t
z=(2*t + p1)*p1
la famiglia R2 di rette e' definita da:
x=a*(t + p1)
y=-b*t
z=(2*t + p1)*p1
t e' il parametro di una singola retta (la coordinata di un punto sulla retta), mentre p1 e' il parametro della famiglia
di rette R1, e p2 e' il parametro della famiglia di rette R2. Al variare di p1 otteniamo le diverse rette di R1, e al
variare di p2 le diverse rette di R2. Se sostituiamo l'equazione di una retta di R1 nell'equazione z =
|x
2
a
2
] | y
2
/b
2
) otteniamo un'identita'. Ne segue che ogni retta di R1 e' inclusa nel paraboloide. Lo stesso vale per
R2. Disegnamo ora insieme paraboloide a sella P, e le famiglie di rette R1 e R2. Il comando per disegnare una
unione di figure e' Show[P,R1,R2].
In[345]:= a = 2; b = 3; P = Plot3D[ [x
2
a
2
] - [y
2
b
2
], {x, -20, 20}, {y, -20, 20}, PlotRange -> {-20, 20},
ClippingStyle -> None, AspectRatio -> 1, PlotPoints -> {100, 100}, PlotStyle - Opacity|0.2]]
Out[345]=
In[346]:= Nrette = 30;
In[347]:= R1 = Table|ParametricPlot3D|{a=(t + p1), b=t, (2=t + p1) =p1}, {t, -1, 1}, PlotStyle -{Red}], {p1, -1, 1, 2[ Nrette}];
(= R1 e' una lista di grafici,uno per retta =)
In[348]:= R2 = Table|ParametricPlot3D|{a=(t + p2), -b=t, (2=t + p2) =p2}, {t, -1, 1}, PlotStyle -{Blue}],
{p2, -1, 1, 2[ Nrette}];(= R2 e' una lista di grafici, uno per retta =)
In[349]:= Show|R1, R2, PlotRange -All]
Out[349]=
4
2
0
2
4
2
0
2
1
0
1
2
3
Superfici rigate: l'iperboloide a una falda. Come disegnare linee parametriche nello spazio.
Ridisegnamo l'iperboloide ad una falda insieme a delle famiglie di rette in esso contenute. Spieghiamo come
scomporre l'iperboloide ad una falda come unione di rette.
Definiamo un disegno "ip" contenente un iperboloide ad una falda di equazione
|x
2
a
2
] + | y
2
/b
2
) - |z
2
c
2
] = 1
| ] | | ]
per a=2, b=3, c=1, ze[-3,3]. Riutilizziamo la definizione parametrica vista nelle sezioni precedenti:
x = a sin(t) 1 + (uf c)
2
y = b cos(t) 1 + (uf c)
2
z = u
(te[0,2r], ue[-3,3]).
In[350]:= a = 2; b = 3; c = 2;
ip = ParametricPlot3D_[a Sin|t] 1 + (u[ c)
2
, b Cos|t] 1 + (u[ c)
2
, u_, {t, 0, 2 n}, {u, -3, 3},
BoxRatios - {1, 1, 1},
PlotRange - {{-5, 5}, {-5, 5}, {-5, 5}},
PlotStyle - Opacity|0.2]_
Out[351]=
Ora risolviamo le equazioni in x, y, z di due famiglie di rette che coprono la superficie. Prendiamo tali equazioni
dai corsi di teoria:
(x/a-z/c) - lambda (1-y/b) = 0
(1+y/b) - lambda (x/a+z/c) = 0
e
(y/b-z/c) - lambda (1-x/a) = 0
(1+x/a) - lambda (y/b+z/c) = 0
Utilizziamo tali soluzioni per scrivere una funzione
retta[lambda_]:= ...
nell'argomento lambda, che disegni in rosso e blu le due rette associate al parametro lambda.
Consigliamo di usare l'opzione DisplayFunction->Identity per impedire che la funzione faccia un disegno ogni
volta che viene chiamata (questo ci servir pi avanti).
In[352]:= Clear|retta];
red = RGBColor|1, 0, 0];
retta|l_] :=
ParametricPlot3D_
[[
4 l
1 + l
2
-
(-1 + l
2
) z
1 + l
2
,
3 (-1 + l
2
)
1 + l
2
+
3 l z
1 + l
2
, z_,
[
2 (-1 + l
2
)
1 + l
2
+
2 l z
1 + l
2
,
6 l
1 + l
2
-
3 (-1 + l
2
) z
2 (1 + l
2
)
, z__,
{z, -3, 3}, PlotRange -> {{-5, 5}, {-5, 5}, {-5, 5}},
PlotStyle - {red, blue}_;
Creiamo, senza renderla visibile, una lista L1 di coppie di tali rette.
In[356]:= Nrette = 70;
L1 = Table|retta|Tan|alpha]],
{alpha,
-Pi [ 2 + Pi [ (2 Nrette), +Pi [ 2 - Pi [ (2 Nrette),
Pi [ Nrette}];
Disegnamo inifine l'unione di tale lista L1 di rette con l'iperboide (comando Show[...]). Vediamo ciascuna delle
due famiglie di rette copre l'iperboloide. Insieme, le due famiglie formano un intreccio di rette che disegna l'iper-
boloide ip.
In[358]:= Show|L1]
Out[358]=
5
0
5
5
0
5
5
0
5
Superfici di rotazione
12. Superfici di rotazione. Una superficie di rotazione e' ottenuta facendo ruotare intorno a un asse una linea del
piano oppure dello spazio. Il comando in Mathematica e' RevolutionPlot3D. Il primo argomento di Revolution-
Plot3D e' la linea da far ruotare, espressa come funzione f(x) nel piano, oppure come linea parametrica {x(t),y(t)}
nel piano, oppure come linea parametrica {x(t),y(t),z(t)} nello spazio. La rotazione avviene intorno all'asse z.
Come esempio, disegnamo il cono, il cilindro, la sfera come superfici di rotazione.
Per vedere come avviene la rotazione, nei disegni scegliamo una opacita' bassa (opzione nel PlotStyle->Opacity[r],
con r tra 0 e 1), che ci consente di vedere in trasparenza anche le parti della figura poste sul retro. Scegliamo una
proporzione a:b:c per le unita' di misura dei 3 assi con BoxRatios->{a,b,c}.
Il cono. Disegnamo la diagonale principale z=x del piano xz
In[359]:= Plot|x, {x, -1, 1}, AxesLabel - {x, z}]
Out[359]=
1.0 0.5 0.5 1.0
100
1.0
0.5
0.5
1.0
z
In[360]:= ?BoxRatios
BoxRat ios is an opt ion f or Graphics3D which gives
t he rat ios of side lengt hs f or t he bounding box of t he t hree-dimensional pict ure. >
In[361]:= RevolutionPlot3D|x, {x, -1, 1}, PlotStyle - Opacity|0.2], BoxRatios -{1, 1, 1}, AxesLabel - {x, y, z}]
(= BoxRatio -{1,1,1} forza le 3 dimensioni della scatola ad essere
uguali: la scatola diventa un cubo. Non sempre le unita' di misura sui tre assi sono le stesse, ma in questo caso si'. =)
(= notiamo l'asse x viene traslato nel piano yz per comodita' di disegno, e cosi' per y e z=)
Out[361]=
Il cilindro. Disegnamo, in forma parametrica, una retta verticale del piano xz che non passa per l'origine.
In[362]:= ParametricPlot|{1, t}, {t, -1, 1}]
Out[362]=
0.5 1.0 1.5 2.0
1.0
0.5
0.5
1.0
In[363]:= RevolutionPlot3D|{1, t}, {t, -1, 1}, PlotStyle - Opacity|0.2], AxesLabel - {x, y, z}]
Out[363]=
La sfera. Disegnamo, in forma parametrica, una semicirconferenza verticale, poi la facciamo ruotare di 2Pi nello
spazio xyz.
In[364]:= ParametricPlot|{Cos|t], Sin|t]}, {t, -Pi [ 2, Pi [ 2}]
Out[364]=
0.2 0.4 0.6 0.8 1.0
1.0
0.5
0.5
1.0
In[365]:= RevolutionPlot3D|{Cos|t], Sin|t]}, {t, -Pi [ 2, Pi [ 2}, PlotStyle - Opacity|0.2]]
Out[365]=
Rotazioni di linee nello spazio: il cilindro ottenuto facendo ruotare una elicoide. Una elicoide e' una linea a
forma di scala a chiocciola, o della filettatura di una vite. Si ottiene come somma di un moto circolare uniforme
orizzontale e un moto rettilineo uniforme verticale. Usiamo "Thickness[r]" per decidere lo spessore dell'elicoide, e
"Directive" per combinare la direttiva "spessore" con la direttiva "colora di rosso". r varia da 0 a 1, con 0.008 si
ottengono gia' linee spesse.
In[366]:= ?Thickness
Thickness[r] is a graphics direct ive which specif ies t hat lines which f ollow are t o be
drawn wit h t hickness r. The t hickness r is given as a f ract ion of t he horizont al plot range. >
In[367]:= ?Directive
Direct ive[g
1
, g
2
, ] represent s a single graphics direct ive composed of t he direct ives g
1
, g
2
, .>
In[368]:= ParametricPlot3D|{Cos|t], Sin|t], t [ (4 Pi)}, {t, 0, 4 Pi},
BoxRatios -{1, 1, 1}, PlotStyle - Directive|Thickness|0.008], Red]]
Out[368]=
1.0
0.5
0.0
0.5
1.0
1.0
0.5
0.0
0.5
1.0
0.0
0.5
1.0
Definiamo una funzione che disegna una elicoide con il punto di partenza ruotato di un angolo a.
In[369]:= Elicoide|a_] := ParametricPlot3D|{Cos|t + a], Sin|t + a], (t + a)}, {t, 0, 6 Pi}, BoxRatios -{1, 1, 1},
PlotStyle - Directive|Thickness|0.008], Red], PlotRange - {{-1, 1}, {-1, 1}, {0, 8 Pi}}]
Animiamo l'elicoide facendo variare l'angolo di rotazione a.
In[370]:= Animate|Elicoide|a], {a, 0, 2 Pi}]
Out[370]=
a
Elicoide[5.32107]
Disegnamo l'unione di tutte le rotazioni dell'elicoide al variare dell'angolo di rotazione a da 0 a 2Pi.
In[371]:= RevolutionPlot3D|{Cos|t], Sin|t], t}, {t, 0, Pi}, BoxRatios -{1, 1, 1}, PlotStyle - Opacity|0.2]]
Out[371]=
Grafici altimetrici e di densita'.
13. Grafici altimetrici e di densit. Riprendiamo l'equazione del Paraboloide ellittico:
z = |x
2
4] + | y
2
/9)
La disegneremo, usando ContourPlot e DensityPlot, come un grafico "altimetrico".
Nei grafici "altimetrici", l'altezza della superfice, cio il valore della z, viene rappresentata con una sfumatura di
colore. In ContourPlot, punti della stessa altezza vengono congiunti da linee; in DensityPlot, viene usata solo la
sfumatura di colore.
In[372]:= ContourPlot[[x
2
4] + [y
2
9], {x, -10, 10}, {y, -10, 10}]
DensityPlot[[x
2
4] + [y
2
9], {x, -10, 10}, {y, -10, 10}]
Out[372]=
Out[373]=
Per maggiori esempi vi invitiamo a leggere l' Help di ContourPlot e di DensityPlot. Soprattutto usando DensityPlot,
disegnando semplici funzioni e' possibile creare immagini di grande bellezza. Per scegliere i colori, cercate
l'opzione ColorFunction-> ... .
In[374]:= ?ContourPlot
?DensityPlot
?ColorFunction
Cont ourPlot [ f , x, x
min
, x
max
, y, y
min
, y
max
] generat es a cont our plot of f as a f unct ion of x and y.
Cont ourPlot [ f == g, x, x
min
, x
max
, y, y
min
, y
max
] plot s cont our lines f or which f = g.
Cont ourPlot [ f
1
== g
1
, f
2
== g
2
, , x, x
min
, x
max
, y, y
min
, y
max
] plot s several cont our lines. >
Densit yPlot [ f , x, x
min
, x
max
, y, y
min
, y
max
] makes a densit y plot of f as a f unct ion of x and y. >
ColorFunct ion is an opt ion f or graphics f unct ions which specif ies a f unct ion t o apply t o det ermine colors of element s. >
14. I comandi visti di grafica tridimensionale hanno analoghi per il disegno di matrici di punti: ListPlot3D,
ListContourPlot, ListDensityPlot. Omettiamo i (facili) esempi.
15. Input e Output: salvataggio di grafici. Assegnare il grafico precedente a una variabile g, e salvarlo su un file
X.GIF (in formato grafico GIF), usando il comando:
Display["X.GIF",g]
In[377]:= g = ContourPlot[[x
2
4] + [y
2
9], {x, -10, 10}, {y, -10, 10}];
In[378]:= Export|"X.GIF", g]
Out[378]= X.GIF
Superfici in forma implicita.
In questa sezione dprendiamo spunto dai modelli di superfici del dipartimento di matematica di Torino :
"I Modelli del Dipartimento di Matematica" http : // www.dm.unito.it/modelli/
16. Superfici in forma implicita f(x,y,z)=0. E' anche possibile disegnare una funzioni espresse in forma implicita. I
comandi sono: ContourPlot3D (per disegnare superfici nello spazio), RegionPlot (per disegnare aree nel piano) e
RegionPlot3D (per disegnare volumi nello spazio).
Ad esempio possiamo disegnare la superficie di Clesbsch data in forma implicita usando ContourPlot3D. Il primo
argomento di CountourPlot3D deve essere una equazione E[x,y,z] = = 0 che decida quali punti appartengono alla
superficie e quali no.
In[379]:= Clebsch|x_, y_, z_] := 16 x^3 + 16 y^3 - 31 z^3 + 24 x^2=z - 48 x^2=y -
48 x=y^2 + 24 y^2=z - 54=Sqrt|3] =z^2 - 72=z;(= Equazione della superficie di Clebsch =)
In[380]:= ContourPlot3D|Clebsch|x, y, z] =0, {x, -2.5, 2.5}, {y, -2.5, 2.5}, {z, -2.5, 2.5}]
Out[380]=
Possiamo disegnare il volume incluso nella superficie di Cayley data in forma implicita. La superficie di Cayley e'
una cubica con quattro punti doppi conici (=con uno "spigolo" a forma di doppio cono). E' difficile rendere i punti
conici: senza una griglia di coordinate molto fitta, tendiamo a non vederli, e la superficie ci appare composta di
parti separate, mentre non e' cosi'.
Usiamo RegionPlot3D. Il primo argomento di RegionPlot3D deve essere una disequazione (E[x, y, z] <= 0 oppure
E[x, y, z] >= 0 oppure E[x, y, z] < 0 ...) che decida quali punti appartengono al volume da disegnare e quali no.
In[381]:= Cayley|x_, y_, z_] := 9 x^3 - 4 z^3 - 27 x=y^2 + 3 (x^2 + y^2) z - 36 (x^2 + y^2) + 16 z^2
In[382]:= RegionPlot3D|Cayley|x, y, z] 0, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}]
Out[382]=
Superficie di Kummer. Concludiamo con un esempio di superficie difficile da disegnare con precisione: superficie
di Kummer. Si tratta di una Quartica (una superficie della forma P(x,y,z)=0, con P polinomio in x,y,z di grado 4).
Ha ben 16 punti doppi conici (=a forma di doppio cono), che pero', se la griglia di coordinate non e' abbastanza
fitta, ci appariranno come punti di sconnessione. La sua equazione e':
x^4 + y^4 + z^4 - 4x^2 - 4y^2*z^2 - 4y^2 - 4z^2*x^2 - 4z^2 - 4x^2*y^2 + 12*Sqrt[3]*x*y*z + 1
In[383]:= Kummer|x_, y_, z_] := x^4 + y^4 + z^4 - 4 x^2 -
4 y^2=z^2 - 4 y^2 - 4 z^2=x^2 - 4 z^2 - 4 x^2=y^2 + 12=Sqrt|3] =x=y=z + 1 ;
Disegnamo la superficie di Cayley in un'area scelta. Di nuovo, e' difficile rendere i punti conici: il comando
ContourPlot3D tende a non vederli.
In[384]:= ContourPlot3D|Kummer|x, y, z] =0, {x, -4, 4}, {y, -4, 4}, {z, -4, 4}]
Out[384]=
Grafici interattivi e animazioni
1. Il comando Manipulate[espressione, {parametro, a, b}] permette di animare una famiglia di espressioni di
Mathematica dipendenti da un parametro, attraverso comandi simili a quelli di un videoregistratore. Se l'espres-
sione dipende da un parametro x, dobbiamo dichiarare un dominio per x, per esempio {x, -2, 2}.
In[385]:= Manipulate[
{"x=", N[x, 10], "x^2=", N[x^2, 10]},
{x, -2, 2}]
Out[385]=
x
{x=, -2.000000000, x^2=, 4.000000000]
2. Combinando Manipulate e comandi grafici (Plot, ListPlot, ecc) e' possibile animare dei grafici con una semplice
interfaccia che ne modifica i parametri di interesse.
Nell'esempio sotto il parametro e' f, mentre la funzione disegnata Sin[...] e' nella variabile x. Il dominio di x viene
dichiarato nel comando Plot[.] che disegna la funzione, mentre il parametro f viene dichiarato entro il comando
Manipulate.
Plot[Sin[2 + Pi + f + t], {t, 0, 2}, AxesLabel -> {x, Sin[2 Pi f t]},
PlotRange - {-1, 1}, ImageSize - 500], {f, 10, 40}]
Out[386]=
f
0.5 1.0 1.5 2.0
x
1.0
0.5
0.5
1.0
0
In[387]:= Manipulate[Plot[x + Sin[1 / x], {x, 0, r}, PlotPoints - 50], {r, .1, 2}]
Out[387]=
r
0.02 0.04 0.06 0.08 0.10
0.05
0.05
3. Al posto di una animazione possiamo creare un menu' contenente, per ogni parametro, una lista di possibili
valori: e' un modo alternativo, piu' statico ma anche piu' accurato, di rappresentare diversi valori di una espressione
o di un disegno.
Per esempio, se scriviamo {{f, 20, "frequenza"}, {10, 20, 40, 80, 100, 1000}}, intendiamo che il Menu' si chiama
"frequenza", il parametro f, il valore di default di f e' 20, mentre gli altri valori, quelli accessibili attraverso il
Menu', sono 10, 20, 40, 80, 100, 1000.
Plot[Sin[2 + Pi + f + t], {t, 0, 2}, AxesLabel -> {x, Sin[2 Pi f t]}],
{{f, 20, "frequenza"}, {10, 20, 40, 80, 100, 1000}}]
Out[388]=
f requenza 20
0.5 1.0 1.5 2.0
x
1.0
0.5
0.5
1.0
0
Nel prossimo esempio vediamo un Menu' con due pulsanti, il primo corrispondente a un parametro mr (massimo
della ricorsione usata nel disegno del grafico) e il secondo corrispondente alla scelta di indicare oppure no i punti
campione del grafico.
In[389]:= Manipulate[Plot[Sin[4 / x], {x, -2 Pi, 2 Pi},
PlotPoints - pp, MaxRecursion - mr, Mesh - m], {{pp, 16
, "PlotPoints"}, {2, 4, 16, 32, 64, 128}}, {{mr, 1, "MaxRecursion"}, {0, 1, 2, 4, 8}},
{{m, None, "Mesh"}, {Full, All, None}}]
(+ NOTA. "All" consente di vedere tutti i punti campione usati nel disegno,
compresi quelli aggiunti da Mathematica. "Full", invece,
salta i punti campione aggiunti da Mathematica. "None" li salta tutti. +)
Out[389]=
Plot Point s 16
MaxRecursion
0 1 2 4 8
Mesh
Full All None
6 4 2 2 4 6
1.0
0.5
0.5
1.0
Ora un esempio in cui il parametro corrisponde alla posizione di un punto nel piano, e viene modificato con
un'interfaccia bidimensionale, simile a quella di un videogioco.
In[390]:= Manipulate[Plot[Sin[x] / x, {x, -20, 20}, AxesOrigin - orig, PlotRange - 1],
{{orig, {0, 0}, "Origine degl'assi" }, {-20, -1}, {20, 1}}]
Out[390]=
Origine degl'assi
20 10 10 20
1.0
0.5
0.5
1.0
Nell'ultimo sempio, una interfaccia che usa contemporaneamente tutti i metodi gia' visti: animazioni e Menu'.
In[391]:= Manipulate[Plot[a + c + (x - V[[1]])^2 + V[[2]], {x, -10, 10}, AxesOrigin - {0, 0},
PlotRange - {-10, 10}], {{V, {0, 0}, "Vertice" }, {-5, -5}, {5, 5}},
{{c, 1, "Concavita'"}, {1, -1}}, {a, 0.1, 5}]
Out[391]=
Vert ice
Concavit a'
1 1
a
10 5 5 10
10
5
5
10
2. Animazioni. Il comando Animate permette di costruire delle semplici animazioni grafiche. La sintassi e' una
semplificazione di quella di Manipulate.
Come esempio, scrivere una funzione iper[k] che prenda un numero reale k, e restituisca il disegno dell'iperbole
equilatera y=k/x. Per poter fornire come risultato un disegno, l'equazione di definizione di iper[k_] dovr quindi
essere della forma iper[k_] := Plot[...].
In[392]:=
In[393]:= iper[k_] := Plot[(k / x), {x, -5, 5},
PlotStyle - Red,
Background - Gray,
PlotRange -> {-5, 5},
ImageSize -> 500,
PlotLabel -> "k=" <> ToString[k]];
In[394]:= iper[1]
Out[394]=
4 2 2 4
4
2
2
4
k=1
3.Usare il comando Animate per animare il disegno di iper[k] per valori di k da -2 a 2, a passi di 0.2
In[395]:= Animate[iper[k], {k, -2, 2, 0.2}]
Out[395]=
k
iper[1.8]
5. Animazione: un'onda. Scrivere una funzione Onda[t_], che prenda un valore t di una variabile "tempo", e
restituisca il disegno di un'onda concentrica che viaggi con velocit costante. L'equazione di tale onda, scritta in
funzione di t, :
z = sin( |x
2
+ y
2
] t (2 rf 10))
Ricordatevi tutti gli accorgimenti gi visti per la grafica 3D! In particolare, il PlotRange delle diverse immagini
deve essere lo stesso, altrimenti il sistema di riferimento cambia nel corso della animazione, creando un fastidioso
effetto caotico.
In[396]:= Onda[t_] :=
Plot3D]Sin ] Sqrt]x
2
+ y
2
- t (2 r / 10), {x, -10, 10}, {y, -10, 10}, Mesh -> False,
PlotPoints -> 40, PlotRange -> {-10, 10}, ImageSize - 300, ClippingStyle -> None;
6. Generare la tabella T dei valori di Onda[t], per t=0,1,2, ...,10. Animare (con ShowAnimation) la famiglia T di
onde cos ottenuta.
In[397]:= Animate[Onda[t], {t, 0, 10}]
Out[397]=
t
Onda[9.0625]
Esercitazione 2: Fitting e Quadriche
Lezione 8: Rette e Piani nello spazio.
Prima di iniziare, eseguite le seguenti definizioni. Si tratta di funzioni punto3D, vettore3D che disegnano punti e
vettori, dato un punto o un vettore, e una etichetta e un colore. Attenzione: questi comandi richiedono una etichetta
e un colore per ogni punto o vettore, altrimenti non funzionano: non si puo' scrivere soltanto punto3D[{0,0,0}],
bisogna scrivere punto3D[{0,0,0},Red,"Origine"].
In[398]:= offset = 0.05; (= si dice offset la distanza tra una etichetta e l'oggetto a cui l'etichetta fa riferimento =)
punto3D|P_, label_, colore_] := Graphics3D|{Thickness|0.01], PointSize|0.01],
colore, Point|P], Text|Style|label, Bold, 24], P + offset]}];
(= Vettore V =)
vettore3D|V_, label_, colore_] := Graphics3D|{Thickness|0.01], PointSize|0.01],
colore, Arrow|{{0, 0, 0}, V}], Text|Style|label, Bold, 24], V+ offset]}];
(= Vettore da P a Q =)
vettore3D|P_, Q_, label_, colore_] := Graphics3D|{Thickness|0.01], PointSize|0.01],
colore, Arrow|{P, Q}], Text|Style|label, Bold, 24], (P + Q) [ 2 + offset]}];
Punti e vettori non sono la stessa cosa: leggete attentamente quanto segue.
Punti e vettori nello spazio tridimensionale si rappresentano allo stesso modo, come terne di numeri reali, ma vi
chiediamo ugualmente di usare notazioni distinte per i punti e per i vettori, perch fa molta differenza inserire in
una formula le coordinate di un punto oppure quelle di un vettore.
I vettori si possono sommare o moltiplicare per scalare. Non esistono invece somme o prodotto per scalare di punti
nello spazio. Esistono invece due operazioni miste:
1. la somma di un punto e di un vettore (inteso come uno spostamento), che da' il punto risultato di questo
spostamento. Per esempio se P={1,2,3} e' un punto e V={1,1,1} e' un vettore, allora Q=P+V={2,3,4} e' un nuovo
punto.
2. La differenza di due punti Q e P, che da' il vettore (inteso come uno spostamento) Q-P che occorre applicare
a P per raggiungere il punto Q. Per esempio, se se P={1,2,3} e Q={2,3,4}, allora V=Q-P={1,1,1} e' lo sposta-
mento che occorre applicare a P per raggiungere il punto Q: in altre parole, Q=P+V.
3. Di solito non hanno senso, ripetiamo: la somma di due punti, di due rette, di una retta e di un punto oppure di
un piano, il prodotto per scalare di punti, rette, piani, e cosi' via.
Notazioni per punti e vettori. Indichiamo i punti dello spazio con le lettere maiuscole da P ad U: P,Q,R,S,T,U.
Indichiamo i vettori nello spazio con le lettere dell'alfabeto da V a Z: V,W,Z. Sia i punti che i vettori sono codifi-
cati in Mathematica con terne {a,b,c} di numeri reali. Se P, Q sono punti, il vettore direzione da P a Q e' V=Q-P.
Indichiamo con V.W il prodotto scalare e con Cross[V,W] il prodotto vettoriale.
Indichiamo le rette con le lettere minuscole r,s, ... e i piani con le doppie lettere minuscole pp, qq, ... . Una retta
per due punti P, Q distinti si indica anche con PQ, e un piano per tre punti P,Q,R non allineati anche con PQR.
Nelle sezioni seguenti, quando un grafico e' composto di piu' parti, spesso terminiamo il comando con un ";" per
saltare la stampa delle singole parti.
Punti, rette e vettori
Una retta r e' determinata dati due punti distinti P,Q, oppure dato un punto P e un vettore direzione V non nullo.
Due vettori direzioni paralleli individuano la stessa retta. Due vettori V1, V2 sono ortogonali se V1.V2=0. Due
vettori V1, V2 sono paralleli se Cross[V1,V2]={0,0,0} (se il loro prodotto vettoriale e' nullo).
Problema. Calcolare l'equazione parametrica di una retta r per due punti P,Q e disegnarla.
Soluzione. Supponiamo che P, Q siano distinti. Il vettore da P a Q e' (Q-P). La retta r=PQ di vettore direzione
V=(Q-P) si ottiene aggiungendo ad P tutti il possibili multipli di (Q-P), dunque ha la seguente equazione in t:
P+t*(Q-P)
Un esempio di retta PQ
In[402]:= P = {0, 0, 1}
Q = {1, 1, 1}
(Q - P)
(=retta PQ =)
P + (Q- P) =t
Out[402]= {0, 0, 1]
Out[403]= {1, 1, 1]
Out[404]= {1, 1, 0]
Out[405]= {t, t, 1]
Controlliamo che P, Q siano distinti. Per decidere se due punti sono uguali, abbiamo la funzione booleana ==. Per
decidere se due punti sono diversi, neghiamo il risultato della funzione == (funzione Not[.]).
In[406]:= Not|P =Q]
Out[406]= True
Disegnamo i punti P e Q e il vettore Q-P dall'origine.
In[407]:= G0 = Show|punto3D|P, "P", Red], punto3D|Q, "Q", Blue], vettore3D|Q - P, "Q-P", Black], PlotRange -All]
Out[407]=
P
Q
Q-P
Disegnamola retta PQ.
In[408]:= G1 = ParametricPlot3D|P + t =(Q- P), {t, -2, 2}]
Out[408]=
2
1
0
1
2
2
1
0
1
2
0.0
0.5
1.0
1.5
2.0
Disegnamo complessivo. Notiamo che P, Q fanno parte di r.
In[409]:= Show|G0, G1, ImageSize - 300]
Out[409]=
P
Q
Q-P
Problema. Calcolare l'equazione parametrica di una retta r per un punto P di vettore direzione V (non
nullo) e disegnarla.
Soluzione. Supponiamo che V non sia nullo. La retta r di vettore direzione V si ottiene aggiungendo ad P tutti il
possibili multipli di V, dunque ha la seguente equazione in t:
P+t*V
Un esempio di retta r
In[410]:= P = {0, 0, 1}
V = {1, 1, 1}
Out[410]= {0, 0, 1]
Out[411]= {1, 1, 1]
Controlliamo che V non sia nullo:
In[412]:= Not|V == {0, 0, 0}]
Out[412]= True
Calcoliamo la retta da P di vettore direzione V:
In[413]:= P + V=t
Out[413]= {t, t, 1 + t]
Disegnamo il punto P e il vettore V. L'opzione PlotRangeAll puo' essere necessaria per evitare che P sia tagliato
via dal grafico.
In[414]:= G0 = Show|punto3D|P, "P", Red], vettore3D|V, "V", Black], PlotRange -All]
Out[414]=
P
V
Disegnamola retta r.
In[415]:= G1 = ParametricPlot3D|P + t =V, {t, -2, 2}]
Out[415]=
2
1
0
1
2
2
1
0
1
2
1
0
1
2
3
Disegnamo complessivo. L'unione si indica con il comando Show[...]. Notiamo che V e' parallelo ad r.
In[416]:= Show|G0, G1]
Out[416]=
P
V
Dato un punto P e un vettore direzione V non nullo, disegnare due rette r1, r2 ortogonali a V per P.
Disegnare due rette s1, s2 ortogonali a V e tra di loro per P.
Soluzione. Due vettori V1, V2 ortogonali a V (ma non necessariamente tra di loro) si ottengono con il comando
NullSpace[{V}] (attenzione a scrivere {V} e non V: NullSpace richiede una lista di vettori (ovvero una matrice)
NullSpace[{V}] (attenzione a scrivere {V} e non V: NullSpace richiede una lista di vettori (ovvero una matrice)
in argomento). Il comando NullSpace[.] prende la base B={v_1,...,v_k} di un sottospazio vettoriale di R
n
e
restituisce una base B' = {v'_1,...,v'_(n-k)} dello spazio vettoriale ortogonale.
Due vettori W1, W2 ortogonali V e ortogonali tra di loro si ottengono applicando a {V1,V2} il comando Orthogo-
nalize[.].
Un esempio di punto P e vettore direzione V non nullo:
In[417]:= P = {0, 0, 1}
V = {1, 1, 1}
Out[417]= {0, 0, 1]
Out[418]= {1, 1, 1]
Calcoliamo V1,V2,W1,W2:
In[419]:= ?NullSpace
NullSpace[m] gives a list of vect ors t hat f orms a basis f or t he null space of t he mat rix m. >
In[420]:= {V1, V2} = NullSpace|{V}]
{W1, W2} = Orthogonalize|{V1, V2}]
Out[420]= {{-1, 0, 1], {-1, 1, 0]]
Out[421]= -
1
2
, 0,
1
2
, -
1
6
,
2
3
, -
1
6
Notiamo che V1, W1 sono paralleli. V1, V2 sono ortogonali a V ma non tra di loro. W1, W2 sono ortogonali a V e
tra di loro. Possiamo verificare tutto questo usando il prodotto vettoriale, il prodotto scalare, il test di eguaglianza
==, e le operazioni logiche And, Not.
V1, W1 sono paralleli:
In[422]:= Cross|V1, W1] ={0, 0, 0}
Out[422]= True
V1, V2 sono ortogonali a V ma non sono ortogonali tra di loro:
In[423]:= And|V1.V =0, V2.V=0, Not|V1.V2 =0]]
Out[423]= True
W1, W2 sono ortogonali a V e tra di loro:
In[424]:= And|W1.V =0, W2.V=0, W1.W2 =0]
Out[424]= True
Disegnamo il punto P, i vettori V, V1, V2, W1, W2. Notiamo che V1 e W1 sono paralleli. L'unione si indica con il
comando Show[...].
In[425]:= G0 = Show|punto3D|P, "P", Red], vettore3D|V, "V", Orange], vettore3D|V1, "V1", Magenta],
vettore3D|V2, "V2", Pink], vettore3D|W1, "W1", Gray], vettore3D|W2, "W2", Black], ImageSize -300]
Out[425]=
P
V
V1
V2
W1
W2
Disegnamo le rette r1,r2, s1, s2 rispettivamente per P e V1,V2,W1,W2. Poi disegnamo tutto. Notiamo che r1 e s2
sono sovrapposte, perche' V1, W1 sono paralleli. Notiamo che ogni retta e' parallela al vettore che la genera.
L'unione si indica con il comando Show[...].
In[426]:= r1 = ParametricPlot3D|P + V1=t, {t, -2, 2}];
r2 = ParametricPlot3D|P + V2=t, {t, -2, 2}];
s1 = ParametricPlot3D|P + W1=t, {t, -2, 2}];
s2 = ParametricPlot3D|P + W2=t, {t, -3, 3}];
Show|G0, r1, r2, s1, s2]
Out[430]=
P
V
V1
V2 W1
W2
Piani
Un piano e' determinato quando sono dati tre punti P, Q, R non allineati (tali che la matrice A={P,Q,R} abbia
determinante non nullo), oppure due punti distinti P, Q e un vettore V non parallelo a Q-P, oppure, infine, un piano
P e due vettori V1, V2 non paralleli (tali che Cross[V1,V2] sia diverso dal vettore nullo {0,0,0}).
Dati tre punti P,Q,R non allineati, calcolare l'equazione parametrica del piano PQR.
Soluzione. Per verificare che P,Q,R non sono allineati, calcoliamo il loro determinante e controlliamo che non sia
0. Supponiamo che P,Q,R non siano allineati. la retta per P, Q ha vettore direzione (Q-P) ed equazione in t: P+
t*(Q-P). Se aggiungiamo un terzo punto R, il vettore da P verso R e' R-P. Il piano che comprende sia la retta PQ
che il punto R si ottiene aggiungendo a P tutte le combinazioni lineari di (Q-P) e di (R-P), dunque ha equazione in
t, u:
P+ t*(Q-P) + u*(R-P)
Un esempio di PQR.
In[431]:= P = {0, 0, 1}
Q = {1, 1, 1}
R = {1, 2, 3}
Out[431]= {0, 0, 1]
Out[432]= {1, 1, 1]
Out[433]= {1, 2, 3]
Controlliamo che P,Q,R non siano allineati controllando che i vettori Q-P, R-Q non siano paralleli. Questo equiv-
ale a controllare che il prodotto vettoriale di Q-P e R-Q non sia nullo:
In[434]:= Not|Cross|Q- P, R - Q] =0]
Out[434]= {2, -2, 1] = 0
Calcoliamo il vettore direzione V=(Q-P), la retta r=PQ, il piano PQR.
In[435]:= (Q - P)
(= retta PQ =)
P + (Q- P) =t
R = {0, -1, 0}
(R - P)
(= piano PQR =)
P + t =(Q - P) + u=(R - P)
Out[435]= {1, 1, 0]
Out[436]= {t, t, 1]
Out[437]= {0, -1, 0]
Out[438]= {0, -1, -1]
Out[439]= {t, t - u, 1 - u]
Disegnamo i punti P,Q,R, poi la retta PQ, il piano PQR, poi tutto insieme.
In[440]:= G0 = Show|punto3D|P, "P", Red], punto3D|Q, "Q", Blue], punto3D|R, "R", Green]];
G1 = ParametricPlot3D|P + (Q- P) =t, {t, -2, 2}];
G2 = ParametricPlot3D|P + t =(Q - P) + u=(R - P), {t, -1, 1}, {u, -1, 1}];
Show|G0, G1, G2, ImageSize -300]
Out[443]=
Dati due punti P, Q distinti e un vettore V non parallelo a PQ, calcolare l'equazione parametrica del piano
pp per PQ parallelo a V.
Soluzione. Supponiamo che P,Q siano distinti e V non sia parallelo a Q-P. Il piano pp che contiene P ed e' paral-
lelo a Q-P, V si ottiene aggiungendo a P tutte le combinazioni lineari di (Q-P) e di V, dunque ha equazione in t, u:
P+ t*(Q-P) + u*V
Un esempio di P, Q, V.
In[444]:= P = {0, 0, -1}
Q = {1, 1, -1}
V = {1, 2, 3}
Out[444]= {0, 0, -1]
Out[445]= {1, 1, -1]
Out[446]= {1, 2, 3]
Controlliamo che P,Q siano distinti e che Q-P non sia parallelo a V. Usiamo il test di eguaglianza, il prodotto
vettoriale e le operazioni logiche And, Not:
In[447]:= And|Not|P =Q], Not|Cross|Q- P, V] ={0, 0, 0}]]
Out[447]= True
Calcoliamo il vettore direzione V2=(Q-P) e il piano pp per P parallelo a V, V2:
In[448]:= (Q - P)
(= retta PQ =)
P + (Q- P) =t
(= piano pp =)
P + t =(Q - P) + u=V
Out[448]= {1, 1, 0]
Out[449]= {t, t, -1]
Out[450]= {t + u, t + 2 u, -1 + 3 u]
Disegnamo i punti P,Q, il vettore V, poi la retta PQ, il piano pp, poi tutto insieme. L'opzione PlotRange->All e'
necessaria per evitare che restino tagliati via dei punti:
In[451]:= G1 = ParametricPlot3D|P + (Q- P) =t, {t, -2, 2}];
G2 = ParametricPlot3D|P + t =(Q- P) + u=V, {t, -1, 1}, {u, -1, 1}];
Show|punto3D|P, "P", Red], punto3D|Q, "Q", Blue], vettore3D|V, "V", Black], G1, G2, ImageSize -300]
Out[453]=
Dato un punto e due vettori V1, V2 non paralleli tra di loro, calcolare l'equazione parametrica del piano
pp per P parallelo a V1,V2.
Soluzione. Supponiamo che V1, V2 non siano paralleli. Il piano pp che contiene P ed e' parallelo a V1, V2 si
ottiene aggiungendo a P tutte le combinazioni lineari di V1 e di V2, dunque ha equazione in t, u:
P+ t*V1 + u*V2
Un esempio di P, V1,V2.
In[454]:= P = {0, 0, -1}
V1 = {1, 1, -1}
V2 = {1, 2, 3}
Out[454]= {0, 0, -1]
Out[455]= {1, 1, -1]
Out[456]= {1, 2, 3]
Controlliamo che V1, V2 non siano paralleli. Usiamo il test di eguaglianza, il prodotto vettoriale e l'operazione
logica Not:
In[457]:= Not|Cross|V1, V2] ={0, 0, 0}]
Out[457]= True
Calcoliamo il piano pp per P parallelo a V1, V2:
In[458]:= P + t =V1 + u=V2
Out[458]= {t + u, t + 2 u, -1 - t + 3 u]
Disegnamo il punto P, i vettori V1,V2, poi il piano pp, poi tutto insieme. L'opzione PlotRange->All e' necessaria
per evitare che restino tagliati via dei punti:
In[459]:= G0 = Show|punto3D|P, "P", Red], vettore3D|V1, "V1", Magenta], vettore3D|V, "V", Black], PlotRange -All];
G1 = ParametricPlot3D|P + t =V1 + u=V2, {t, -1, 1}, {u, -1, 1}];
Show|G0, G1, ImageSize -300]
Out[461]=
Due piani per la stessa retta.
Problema. Data una retta PQ, disegnare piu' piani per quella retta. La retta per P,Q ha equazione in t: P+ t*(Q-P).
Se aggiungiamo dei punti R, S tali che Q-P, R-P, S-P non siano complanari. In tal caso, i piani che comprendono
sia la retta PQ che il punto R, o sia la retta PQ che il punto S non sono identici. Essi hanno equazione in t, u:
P+ t*(Q-P) + u*(R-P) e P+ t*(Q-P) + u*(S-P)
Un esempio di P,Q,R,S.
In[462]:= P = {0, 0, 1}
Q = {1, 1, 1}
R = {0, -1, 0}
S = {3, 1, -3}
Out[462]= {0, 0, 1]
Out[463]= {1, 1, 1]
Out[464]= {0, -1, 0]
Out[465]= {3, 1, -3]
Controlliamo che Q-P, R-P, S-P non siano complanari: il determinante della matrice M={Q-P,R-P,S-P} da essi
formata non deve essere nullo:
In[466]:= Not|Det|{Q- P, R - P, S - P}] =0]
Out[466]= True
Calcoliamo la retta PQ e i piani PQR e PQS:
In[467]:= (= retta PQ =)
P + (Q- P) =t
(= piano PQR =)
P + t =(Q - P) + u=(R - P)
(= piano PQS =) P + t =(Q- P) + u=(S - P)
Out[467]= {t, t, 1]
Out[468]= {t, t - u, 1 - u]
Out[469]= {t + 3 u, t + u, 1 - 4 u]
Disegnamo P,Q,R,S, poi la retta PQ, poi il piano PQR, il piano PQS, poi tutto insieme.
In[470]:= G0 = Show|punto3D|P, "P", Red], punto3D|Q, "Q", Blue],
punto3D|R, "R", Green], punto3D|S, "S", Yellow], DisplayFunction -Identity];
(= la retta PQ =)
G1 = ParametricPlot3D|P + (Q- P) =t, {t, -2, 2}, PlotStyle - Thickness|0.005]];
(= il piano PQR =)
G2 = ParametricPlot3D|P + t =(Q - P) + u=(R - P), {t, -1, 1}, {u, -1, 1}];
(= il piano PQS =)
G3 = ParametricPlot3D|P + t =(Q - P) + u=(S - P) , {t, -1, 1}, {u, -1, 1}];
Show|G0, G1, G2, G3, ImageSize -300]
Out[474]=
Due piani ortogonali per la stessa retta.
Problema. Data una retta PQ, disegnare due piani ortogonali tra di loro per quella retta. La retta per P,Q ha
equazione in t: P+ t*(Q-P). Soluzione. Due vettori ortogonali V1, V2 a (Q-P) si ottengono usando NullSpace[.].
Applicando un procedimento di ortonormalizzazione otteniamo due vettori W1, W2 ortogonali a (Q-P) e tra di
loro. Sia pp il piano per P parallelo a (Q-P), W1. Sia qq il piano per P parallelo a (Q-P) e a W2. Allora pp, qq
sono ortogonali tra di loro e contengono la retta PQ.
P+ t*(Q-P) + u*W1 e P+ t*(Q-P) + u*W2
Un esempio di P,Q.
In[475]:= P = {1, 2, 3}
Q = {1, 1, 1}
Out[475]= {1, 2, 3]
Out[476]= {1, 1, 1]
Controlliamo che P, Q siano distinti:
In[477]:= Not|P =Q]
Out[477]= True
Calcoliamo due vettori V1, V2 non paralleli e ortogonali a Q-P, e due vettori W1, W2 ortogonali a Q-P e tra di
loro. Si riveda la sezione dedicata alle rette per una spiegazione del procedimento usato:
In[478]:= {V1, V2} = NullSpace|{Q- P}]
{W1, W2} = Orthogonalize|{V1, V2}]
Out[478]= {{0, -2, 1], {1, 0, 0]]
Out[479]= 0, -
2
5
,
1
5
, {1, 0, 0]
Calcoliamo la retta PQ, il piano pp per PQ e per W1, il piano qq per PQ e per W2:
In[480]:= (= retta PQ =)
P + (Q- P) =t
(= piano pp =)
P + t =(Q - P) + u=W1
(= piano qq =)
P + t =(Q - P) + u=W2
Out[480]= {1, 2 - t, 3 - 2 t]
Out[481]= 1, 2 - t -
2 u
5
, 3 - 2 t +
u
5
Out[482]= {1 + u, 2 - t, 3 - 2 t]
Disegnamo P,Q,R,S, poi la retta PQ, poi il piano PQR, il piano PQS, poi tutto insieme.
1 0 0 Mat hemat ica- Dispense- 2011. nb
In[483]:= G0 = Show|punto3D|P, "P", Red], punto3D|Q, "Q", Blue],
vettore3D|W1, "W1", Pink], vettore3D|W2, "W2", Gray]];
(= la retta PQ =)
G1 = ParametricPlot3D|P + (Q- P) =t, {t, -2, 2}];
(= il piano pp =) G2 = ParametricPlot3D|P + t =(Q - P) + u=W1, {t, -1, 1}, {u, -1, 1}];
(= il piano qq =)
G3 = ParametricPlot3D|P + t =(Q - P) + u=W2, {t, -1, 1}, {u, -1, 1}];
Show|G0, G1, G2, G3, ImageSize -300]
Out[487]=
Piano tangente a una sfera
Disegnare una sfera di origine X e passante per un punto A. Disegnare il piano tangente alla sfera per A.
Soluzione. La sfera di raggio 1 e centro l'origine ha equazioni parametriche P(t,u) =
{Cos[t]Cos[u],Sin[t]Cos[u],Sin[u]}, dove t e' la longitudine e u e' la latitudine. La sfera di centro X e raggio R ha
equazioni parametriche X + R*P(t,u). Il raggio R e' la norma di X-A. Il piano tangente passa per A ed e' ortogonale
a A-X, dunque e' determinato dal punto A e da due vettori qualunque V1, V2 ortogonali a A-X. E' sufficiente
cercare due soluzioni V1, V2 linearmente indipendenti dell'equazione (A-X).V = 0, dove V=(v1,v2,v3) oppure
usare il comando NullSpace[{A-X}] per avere una base di tale spazio. Il piano ottenuto sara':
Mat hemat ica- Dispense- 2011. nb 1 0 1
A + t*V1 + u*V2
Scegliamo X, A, e calcoliamo il raggio R
In[488]:= X = {1, 3, 1}
A = {0, 7, 1}
(= calcolo del raggio come norma di X-A =)
R = Sqrt|(X - A).(X - A)]
Out[488]= {1, 3, 1]
Out[489]= {0, 7, 1]
Out[490]= 17
Dobbiamo trovare una base per le soluzioni dell'equazione (A-X).V = 0, dove V={v1,v2,v3} e' una terna di
variabili. Se definiamo una matrice-riga M={(A-X)}, allora dobbiamo trovare una base per le soluzioni di M.X=0.
Questo puo' essere ottenuto con il comando NullSpace.
In[491]:= {V1, V2} = 3=Orthogonalize|NullSpace|{(A- X)}]]
(= scelgo due vettori ortogonali tra loro e di lunghezza 3: ma non sarebbe necessario =)
Out[491]= {0, 0, 3],
12
17
,
3
17
, 0
Disegnamo il piano determinato da A e dai due vettori V1, V2. Poi disegnamo la sfera, quindi la sfera e il piano
insieme, per controllare che siano tangenti.
In[492]:= G1 = ParametricPlot3D|A + V1=t + V2=u, {t, -1, 1}, {u, -1, 1}];
G2 = ParametricPlot3D|X + R= {Cos|t] Cos|u], Sin|t] Cos|u], Sin|u]}, {t, 0, 2 Pi}, {u, -Pi [ 2, Pi [ 2} ];
Show|G1, G2, vettore3D|A, A+ V1, "A+V1", Blue], vettore3D|A, A+ V2, "A+V2", Red],
PlotRange -All, ViewPoint -> {0.038, 0.024, 3.383}, ImageSize -300]
Out[494]=
Disegnare una sfera di origine X e passante per un punto A. Disegnare due rette distinte tangenti alla sfera
in A.
Soluzione. La sfera di raggio 1 e centro l'origine ha equazioni parametriche P(t,u) =
{Cos[t]Cos[u],Sin[t]Cos[u],Sin[u]}, dove t e' la longitudine e u e' la latitudine. La sfera di centro X e raggio R ha
equazioni parametriche X + R*P(t,u). Il raggio R e' la norma di X-A. Il piano tangente passa per A ed e' ortogonale
a A-X, dunque e' determinato dal punto A e da due vettori qualunque V1, V2 ortogonali a A-X. E' sufficiente
cercare due soluzioni V1, V2 linearmente indipendenti dell'equazione (A-X).V = 0, dove V=(v1,v2,v3) oppure
usare il comando NullSpace[{A-X}] per avere una base di tale spazio. Le rette per A e di vettore direzione,
rispettivamente, V1 e V2 appartengono al piano tangente e sono quindi tangenti:
A + t*V1 A + t*V2
Scegliamo X, A, e calcoliamo il raggio R
In[495]:= X = {1, 3, 1}
A = {0, 7, 1}
(= calcolo del raggio come norma di X-A =)
R = Sqrt|(X - A).(X - A)]
Out[495]= {1, 3, 1]
Out[496]= {0, 7, 1]
Out[497]= 17
Dobbiamo trovare una base per le soluzioni dell'equazione (A-X).V = 0, dove V={v1,v2,v3} e' una terna di
variabili. Se definiamo una matrice-riga M={(A-X)}, allora dobbiamo trovare una base per le soluzioni di M.X=0.
Questo puo' essere ottenuto con il comando NullSpace.
In[498]:= {V1, V2} = NullSpace|{(A- X)}]
Out[498]= {{0, 0, 1], {4, 1, 0]]
Disegnamo le rette determinato da A e dai due vettori V1, V2. Poi disegnamo la sfera, quindi la sfera e il piano
insieme, per controllare che siano tangenti.
In[499]:= G0 = punto3D|A, "A", Green];
G1 = ParametricPlot3D|A + V1=t , {t, -4, 4}, PlotStyle - {Red, Thickness|0.005]}];
G2 = ParametricPlot3D|A + V2=t , {t, -2, 2}, PlotStyle - {Blue, Thickness|0.005]}];
G3 = ParametricPlot3D|X + R= {Cos|t] Cos|u], Sin|t] Cos|u], Sin|u]}, {t, 0, 2 Pi}, {u, -Pi [ 2, Pi [ 2}];
Show|G0, G1, G2, G3, PlotRange -All, ViewPoint -> {-1.497, 2.586, 0.506}]
Out[503]=
Lezione 9: Cilindri e Coni generalizzati. Intersezione Sfera-Piano.
(= Vettore V =)
Disegno di un Cilindro Generalizzato.
Problema. Disegnare un cilindro data la linea direttrice d e il vettore direzione comune V delle generatrici (non
nullo). Per cilindro, intendiamo l'unione di tutte le rette che passano da qualche punto della linea d e hanno vettore
direzione parallelo a (Q-P) (pag. 29 quaderno Abbena-Gianella). Queste rette sono dette generatrici.
Soluzione. Consideriamo solo il caso in cui la direttrice d descritta da una equazione d(t)=(x(t),y(t),z(t)) (pag. 31
quaderno Abbena-Gianella). In questo caso ogni retta da d(t) di vettore direzione V ha equazione
d(t)+V*u
con parametro u. Al variare anche di t otteniamo tutte le rette possibili che passano per qualche punto di d e di
vettore direzione V. Dunque, per definizione, otteniamo il cilindro.
Scegliamo una qualsiasi linea d nello spazio come direttrice.
In[508]:= d|t_] := {Cos|t] ^2, Sin|t] + Cos|t], t [ 3 - Sin|t]};
In[509]:= ?d
Global`d
d[t_] := Cos[t]
2
, Sin[t] + Cos[t],
t
3
- Sin[t]
Disegnamo il grafico della direttrice d.
In[510]:= G1 = ParametricPlot3D|d|t], {t, 0, 2 Pi}, ImageSize -300, PlotStyle -{Blue, Thickness|0.005]}]
Out[510]=
0.0
0.5
1.0
1
0
1
0
1
2
Scegliamo un vettore direzione V non nullo, un numero reale r, e disegnamo come esempio la generatrice per d[r]
(cioe' la retta per d[r] di vettore direzione V).
In[511]:= V = {1, 1, 1}
Out[511]= {1, 1, 1]
In[512]:= G2 = ParametricPlot3D|d|Pi] + V=u, {u, -2, 2}, ImageSize -300, PlotStyle -{Red, Thickness|0.005]}];
Definiamo il cilindro di direttrice d e vettore direzione V, senza disegnarlo ancora.
In[513]:= G3 = ParametricPlot3D|d|t] + V=u, {t, 0, 2 Pi}, {u, -2, 2}, ImageSize -300, ViewPoint -> {2.778, 1.475, 1.247}];
Disegnamo tutto insieme: la direttrice, una generatrice del cilindro, e il cilindro.
In[514]:= Show|G1, G2, G3, PlotRange -All]
Out[514]=
Disegno di un Cono Generalizzato.
Problema. Disegnare un cono data la retta direttrice d e il vertice P. Per cono, intendiamo l'unione di tutte le rette
che uniscono P a qualche punto di d (pag. 8 quaderno Abbena-Gianella). Queste rette sono dette generatrici, e
passano tutte per il punto V nel caso del cono.
Soluzione. Consideriamo solo il caso in cui la direttrice d descritta da una equazione d(t)=(x(t),y(t),z(t)) (pag. 12
quaderno Abbena-Gianella). In questo caso ogni retta da P a d(t) ha equazione P+(d(t)-P)*u, con parametro u. Al
variare di t e di u otteniamo tutte le rette possibili che uniscono P a qualche punto di d. Dunque, per definizione,
otteniamo il cono.
Fissiamo un vertice P.
In[515]:= P = {0, 0, -1};
Fissiamo una direttrice d(t) qualunque.
In[516]:= d|t_] := {t, t =t, 0};
In[517]:= ?d
Global`d
d[t_] := {t, t t, 0]
Disegnamo d nello spazio.
In[518]:= G1 = ParametricPlot3D|d|t], {t, -1, 1}, ImageSize -300, PlotPoints -1000, PlotStyle -{Blue, Thickness|0.005]} ]
Out[518]=
1.0
0.5
0.0
0.5
1.0
0.0
0.5
1.0
1.0
0.5
0.0
0.5
1.0
Definiamo il cono come insieme di tutti i punti della forma P+(d(t)-P)*u, al variare dei parametri t e di u. Non lo
disegnamo ancora.
In[519]:= P + (d|t] - P) =u
Out[519]= t u, t
2
u, -1 + u
In[520]:= G2 = ParametricPlot3D|P + (d|t] - P) =u, {t, -1, 1}, {u, -1, 1}, ImageSize -300,
ViewPoint -> {2.778, 1.475, 1.247}, PlotPoints -{100, 50}, DisplayFunction -Identity]
Out[520]=
Disegnamo tutto insieme: il vertice V, la direttrice d, e il cono.
In[521]:= Show|punto3D|P, "P", Red], G1, G2, ImageSize -500]
Out[521]=
Intersezione Sfera-Piano.
Si consideri una sfera di raggio R e centro C={Ox,Oy,Oz} la cui equazione parametrica in coordinate sferiche e'
C + R*{Cos[t]*Cos[f],Sin[t]*Cos[f],Sin[f]}, con fe[0,r] latitudine te[0, 2r]
longitudine
Vogliamo calcolare l'equazione dell'intersezione fra la sfera e un piano che separi i poli Nord e Sud. Supponiamo
che l'intersezione esista e non sia banale: in questo caso l'intersezione e' una circonferenza posta sulla superficie
della sfera, e ogni meridiano taglia la circonferenza intersezione in al piu' un punto, dunque possiamo descrivere la
circonferenza intersezione come una linea parametrica, nel parametro t (longitudine).
Se il piano non separa i poli Nord e Sud, risoveremo l'equazione rispetto alla longitudine, e avremmo bisogno di
due equazioni per rappresentare la circonferenza intersezione nel parametro f (latitudine): ogni equazione
rappresenta una semicirconferenza. Questo e' caso del piano x+y-1=0. Per semplicita', tuttavia, non scendiamo
in dettagli riguardo a questo secondo caso, piu' difficile.
Come esempio utilizziamo il piano ]: x+y-z=0. Tuttavia, nei calcoli seguenti potremmo considerare qualsiasi
piano a*x+b*y+c*z+d=0, purche' non contienga l'asse Nord-Sud (purche' non sia c=d=0).
Le prossime righe calcolano l'equazione della circonferenza intersezione (o parte di essa) per ogni scelta della
funzione Piano[.,.,.]=a*x+b*y+c*z+d tale che non sia purche' c=d=0.
In[522]:= Clear|a, b, c, d, Ox, Oy, Oz, R, x, y, z, f, t, X, Y, Piano, Sfera];
In[523]:= {a, b, c, d} = {1, 1, 1, 2};
Piano|x_, y_, z_] := a=x + b=y + c=z + d;
(= x+y-z separa il polo Nord e il polo Sud. Provate anche con il piano x+
y-1 che invece non separa i due poli Nord e Sud =)
In[525]:= {Ox, Oy, Oz} = {0, 0, 0};
R = 1;
Sfera|f, t] := {Ox, Oy, Oz} + R= {Cos|t] =Cos|f], Sin|t] =Cos|f], Sin|f]} ;
Calcoliamo la distanza del piano dal centro della sfera, e decidiamo se l'intersezione Piano-Sfera e' vuota, e' un
punto, oppure e' una circonferenza.
In[528]:= dist = Abs|a=Ox + b=Oy + c=Oz + d] [ Sqrt|a^2 + b^2 + c ^2]
Out[528]=
2
3
In[529]:= If|dist > R,
"Piano e Sfera non si intersecano",
If|dist =R,
"Il Piano e' tangente alla Sfera",
(= altrimenti dist < R=)
"L'intersezione Piano-Sfera e' una circonferenza"]]
Out[529]= Piano e Sfera non si intersecano
Calcoliamo il grafico della sfera, del piano, e dei due poli.
In[530]:= GSfera = ParametricPlot3D|{Ox, Oy, Oz} + R= {Cos|t] =Cos|f], Sin|t] =Cos|f], Sin|f]},
{t, 0, 2=Pi}, {f, -Pi [ 2, Pi [ 2}, PlotStyle - Opacity|0.5]];
m = Max|dist, R];
GPiano = ContourPlot3D|Piano|x, y, z] =0,
{x, Ox - m, Ox + m}, {y, Oy - m, Oy + m}, {z, Oz - m, Oz + m}];
In[535]:= Nord = punto3D|{0, 0, 1}, "N", Brown]; Sud = punto3D|{0, 0, -1}, "S", Orange];
Supponiamo d'ora in poi che l'intersezione Piano-Sfera sia una circonferenza. Rappresentiamo graficamente la
circonferenza interserzione. Il nostro obbiettivo e' trovarne l'equazione parametrica {X[t],Y[t],Z[t]}.
In[536]:= Show|GSfera, GPiano, Nord, Sud, PlotRange - All]
Out[536]=
In[537]:= IlPianoSeparaIPoli = (Piano|0, 0, 1] =Piano|0, 0, -1] < 0);
In[538]:= If|IlPianoSeparaIPoli, "Il Piano separa i poli", "Il Piano NON separa i poli"]
Out[538]= Il Piano NON separa i poli
Rappresentiamo l'intersezione sfera-piano con il sistema di equazioni {x, y, z} == Sfera[f, t], z == Piano[x,y].
Risolviamo il sistema esprimendo la variabile t (longitudine) con il comando Solve. Abbiamo scelto di esprimere
x,y,z rispetto alla longitudine perche' l'insersezione non e' un meridiano, e quindi ogni meridiano taglia la circon-
ferenza intersezione in al piu' un punto. Ordiniamo le variabili in ordine alfabetico: f, x,y,z oppure: t,x,y,z.
In[539]:= sol = If|IlPianoSeparaIPoli,
Solve|{{x, y, z} == Sfera|f, t], Piano|x, y, z] =0}, {x, y, z, f}], (= risolvo rispetto alla latitudine f =)
Solve|{{x, y, z} == Sfera|f, t], Piano|x, y, z] =0}, {x, y, z, t}] (= risolvo rispetto alla longitudine t =)
];
Solve: : if un : I nverse f unct ions are being used by Solve,
so some solut ions may not be f ound; use Reduce f or complet e solut ion inf ormat ion. >
In[540]:= sol = Map|Sort, sol] ;
(= Map applica la funzione Sort all'interno di ogni riga della matrice sol. Adesso in ogni riga le variabili sono in
ordine alfabetico, dunque nella forma: f-...,x-...,y-...,z-..., oppure nella forma: t-... x-...y-... z-...=)
In[541]:= MatrixForm|sol = Sort|sol] ]
(= ordino le righe tra di loro, per essere certo che le diverse soluzioni siano presentate sempre
nello stesso ordine : in questo modo la soluzione da scegliere si trova sempre allo stesso posto. =)
t - -ArcCos
1
4
-4 Sec[f] - 2 Sec[f]
2
-7 Cos[f]
2
+ 3 Cos[f]
2
Cos[2 f] - 8 Cos[f]
2
Sin[f] - 2
t - ArcCos
1
4
2
-7 Cos[f]
2
+ 3 Cos[f]
2
Cos[2 f] - 8 Cos[f]
2
Sin[f] - 2
t - -ArcCos
1
4
-4 Sec[f] + 2 Sec[f]
2
-7 Cos[f]
2
+ 3 Cos[f]
2
Cos[2 f] - 8 Cos[f]
2
Sin[f] - 2
t - ArcCos
1
4
2
-7 Cos[f]
2
+ 3 Cos[f]
2
Cos[2 f] - 8 Cos[f]
2
Sin[f] - 2
In[542]:= (= Contiamo quante soluzioni abbiamo trovato =)
Length|sol]
Out[542]= 4
Se abbiamo risolto rispetto alla latitudine, le quattro soluzioni rappresentano la circonferenza intersezione, in modi
diversi.
Se abbiamo risolto rispetto alla longitudine, le quattro soluzioni rappresentano quattro semi-circonferenze. La
soluzione completa si ottiene come unione (per esempio) della prima e della terza soluzione.
Definiamo sol1 come la prima soluzione trovata. Nel caso abbiamo risolto rispetto alla longitudine, abbiamo
bisogno anche della terza soluzione: definiamo sol3 come terza soluzione trovata.
In[543]:= MatrixForm|sol1 = sol||1]]]
MatrixForm|sol3 = sol||3]]]
t - -ArcCos
1
4
2
-7 Cos[f]
2
+ 3 Cos[f]
2
Cos[2 f] - 8 Cos[f]
2
Sin[f] - 2
x -
1
4
-4 - 2 Sin[f] - 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
y -
1
4
-4 - 2 Sin[f] + 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
z - Sin[f]
t - -ArcCos
1
4
2
-7 Cos[f]
2
+ 3 Cos[f]
2
Cos[2 f] - 8 Cos[f]
2
Sin[f] - 2
x -
1
4
-4 - 2 Sin[f] + 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
y -
1
4
-4 - 2 Sin[f] - 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
z - Sin[f]
Definiamo solX la soluzione in X (la seconda), solY la soluzione in Y (la terza), solZ la soluzione in Y (la quarta).
Le soluzioni hanno la forma di sostituzioni temporanee: x->X[t], ... . Scegliendo la seconda componente di ogni
sostituzione possiamo definire X[t], ...
In[545]:= solX = sol1||2]]
solY = sol1||3]]
solZ = sol1||4]]
(= nel caso risolviamo rispetto alla longitudine abbiamo bisogno
anche della terza soluzione per rappresentare la circonferenza intersezione =)
solX3 = sol3||2]];
solY3 = sol3||3]];
solZ3 = sol3||4]];
Out[545]= x -
1
4
-4 - 2 Sin[f] - 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
Out[546]= y -
1
4
-4 - 2 Sin[f] + 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
Out[547]= z - Sin[f]
In[551]:= If|IlPianoSeparaIPoli,
X|t_] = solX||2]],
X|f_] = solX||2]]; X3|f_] = solX3||2]] ];
(= usiamo la sostituzione statica per rimpiazzare solX con X|t] o X|f] una volta per tutte =)
In[552]:= ?X
Global`X
X[f_] =
1
4
-4 - 2 Sin[f] - 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
Y|t_] = solY||2]],
Y|f_] = solY||2]]; Y3|f_] = solY3||2]]];
(= usiamo la sostituzione statica per rimpiazzare solY con Y|t] o Y|f] una volta per tutte =)
In[554]:= ?Y
Global`Y
Y[f_] =
1
4
-4 - 2 Sin[f] + 2 Sec[f] -Cos[f]
2
(7 - 3 Cos[2 f] + 8 Sin[f])
Z|t_] = solZ||2]],
Z|f_] = solZ||2]]; Z3|f_] = solZ3||2]]];
(= usiamo la sostituzione statica per rimpiazzare solZ con Z|t] o Z|f] una volta per tutte =)
?Z
Global`Z
Z[f_] = Sin[f]
Ora che conosciamo X[t], Y[t], Z[t] possiamo rappresentare la circonferenza intersezione come linea parametrica
nello spazio.
In[557]:= GIntersezione = If|IlPianoSeparaIPoli,
ParametricPlot3D|{X|t], Y|t], Z|t]}, {t, 0, 2 Pi}, PlotStyle - {Red, Thickness|0.008]}],
ParametricPlot3D|{{X|f], Y|f], Z|f]}, {X3|f], Y3|f], Z3|f]}}, {f, -Pi [ 2, +Pi [ 2},
PlotStyle - {Directive|Cyan, Thickness|0.01]], Directive|Blue, Thickness|0.008]]}]];
In[558]:= Show|GSfera, GPiano, GIntersezione, Nord, Sud]
(= Se il piano separa i poli : disegnamo la circonferenza in rosso. Se il piano non separa i poli :
disegnamo la semi-circonferenza generata dalla soluzione 1 in azzurro,
disegnamo la semi-circonferenza generata dalla soluzione 3 in blu =)
Out[558]=
Lezione 10: Geometria e Algebra Lineare I: discussione di sistemi lineari.
E. Abbena, G.M. Gianella (testo)
S. Berardi, M.Grangetto (soluzioni svolte con Mathematica)
(= Vettore V =)
Capitolo 1. Sistemi lineari.
In questo testo, i numeri degli esercizi fanno riferimento al testo:
Esercizi di Geometria e Albegra Lineare I
di E. Abbena, G.M. Gianella.
Esercizio 1 del Capitolo 1 (Abbena-Gianella).
Risolvere il sistema:
x1 x2 x3 1
2 x1 2 x2 x3 0
x1 x2 2 x3 1
Suggerimenti. Definire una matrice A dei coefficienti, due vettori X delle variabili e B dei coefficienti. Disegnare
per controllo (usare MatrixForm) A, X, AX, B. Indicare il prodotto di matrici con "A.X"). Risolvete A.X=B con
Solve[A.X == B, {x1,x2,x3}] (omettiamo i casi particolari) oppure con Reduce[A.X == B, {x1,x2,x3}] (d la
soluzione completa).
Per il sistema in esame, molto semplice, sia Solve che Reduce forniscono tutte le soluzioni. In generale, invece,
Reduce pi completo: per esempio trova anche le soluzioni nei casi in cui un coefficiente dipendente da parametri
sia zero.
Attenzione (1). Definite X, B o entrambe come i vettori {x1,x2,x3}, {b1,b2,b3} (in questo caso, A.X e B sono
vettori), oppure entrambe come matrici ridotte a un'unica colonna:
X =
x1
x2
, B =
b1
b2
Equivalentemente:
X={{x1},{x2},{x3}}, B={{b1},{b2},{b3}}
In questo caso, A.X e B sono matrici.
Non potete invece scegliere X come vettore e B come matrice, o viceversa. In Mathematica non possibile
eguagliare un vettore ad una matrice-colonna, anche se della stessa dimensione.
Attenzione (2).Evitate inoltre definizioni del tipo
A = MatrixForm[...]
MatrixForm infatti produce il disegno di una matrice, non una matrice vera e propria. Non possibile risolvere
una equazione A.X ==B quando A un disegno.
In[563]:= A = {
{1, 1, -1},
{2, 2, 1},
{1, 1, 2}
};
In[564]:= X = {x1, x2, x3}; (= definiamo il vettore delle variabili =)
In[565]:= B = {1, 0, -1}; (= definiamo il vettore delle variabili =)
In[566]:= MatrixForm|A]
MatrixForm|X]
MatrixForm|A.X]
MatrixForm|B]
1 1 -1
2 2 1
1 1 2
x1
x2
x3
x1 + x2 - x3
2 x1 + 2 x2 + x3
x1 + x2 + 2 x3
1
0
-1
Per discutere la soluzione, calcolare Det[A].
Se Det[A] risulter diverso da 0, la soluzione sar unica.
Se Det[A] risulter uguale a 0, le soluzioni potranno essere un insieme vuoto, oppure uno spazio vettoriale di
dimensione 1 o pi. La dimensione dello spazio delle soluzioni esprime il numero di parametri da cui la soluzione
dipende. Si pu calcolare calcolando la forma ridotta di A (comando RowReduce), e contando il numero delle
righe tutte uguali a 0 ottenute. Questo procedimento funziona solo con matrici quadrate.
In[570]:= Det|A]
Out[570]= 0
In[571]:= MatrixForm|RowReduce|A]]
1 1 0
0 0 1
0 0 0
Infine, risolvere l'equazione A.X=B. In questo caso, i comandi Solve e Reduce danno lo stesso insieme di
soluzioni. Controllare che la dimensione dello spazio delle soluzioni ottenuto sia quella prevista.
In[572]:= Solve|A.X == B, X]
Reduce|A.X == B, X]
Solve: : svars : Equat ions may not give solut ions f or all "solve" variables. >
Out[572]= x2 -
1
3
- x1, x3 - -
2
3
Out[573]= x2 =
1
3
- x1 && x3 = -
2
3
Esercizio 7 del Capitolo 1 (Abbena-Gianella).
Risolvere il sistema nel parametro a:
a x1 - x2 + x3 = 2
x1 - a x2 + x3 = 3 - a
2
x1 - x2 + a x3 = a + 1
Suggerimenti. Ripulire (col comando Clear) la variabile a. Quindi definire una matrice A dei coefficienti, due
vettori (cio due liste) X delle variabili e B dei coefficienti. Disegnare per controllo A, X, A.X, B (usare Matrix-
Form).
In[574]:= Clear|a]
In[575]:= A = {
{a, -1, 1},
{1, -a, 1},
{1, -1, a}
};
In[576]:= X = {x1, x2, x3};
In[577]:= B = {2, 3 - a^2, a + 1};
In[578]:= MatrixForm|A]
MatrixForm|X]
MatrixForm|A.X]
MatrixForm|B]
a -1 1
1 -a 1
1 -1 a
x1
x2
x3
a x1 - x2 + x3
x1 - a x2 + x3
x1 - x2 + a x3
2
3 - a
2
1 + a
Calcolare il determinante, e scoprire per quali valori di A risulta Det[A]=0. Per tali valori di a, le soluzioni
potranno essere pi di una.
In[582]:= Det|A]
Out[582]= -2 + 3 a - a
3
In[583]:= Solve[-2 + 3 a - a
3
== 0, a]
Out[583]= {{a - -2], {a - 1], {a - 1]]
Infine, calcolare la soluzione di A.X=B in generale, e per i valori di a per cui Det[A]=0. Solve fornisce la
soluzione generale vale solo quando Det[A] diverso da 0. Reduce fornisce anche le soluzioni per i particolari
valori di a che rendono il determinante nullo. Anzich usare Reduce, si pu risolvere l'equazione Det[A] == 0,
quindi ricalcolare le soluzioni di AX=B e la forma ridotta di A, per stabilire, in questi casi, la dimensione dello
spazio delle soluzioni.
In[584]:= Solve|A.X == B, X]
Reduce|A.X == B, X]
Out[584]= {{x1 - 1, x2 - a, x3 - 2]]
Out[585]= (a = 1 && x3 = 2 - x1 + x2) || (a = -2 && x2 = -1 - x1 && x3 = 2 + 2 x1 + x2) ||
-2 + a + a
2
= 0 && x1 = 1 && x2 = a && x3 = 2 - a + x2,
Ripetere gli stessi calcoli per quei valori di a per cui Det[A]=0.
In[586]:= a = -2;
MatrixForm|RowReduce|A]]
Solve|A.X == B, X]
1 0 -1
0 1 1
0 0 0
Out[588]= {{x2 - -1 - x1, x3 - 1 + x1]]
In[589]:= a = 1;
MatrixForm|RowReduce|A]]
Solve|A.X == B, X]
1 -1 1
0 0 0
0 0 0
Out[591]= {{x3 - 2 - x1 + x2]]
Capitolo 2. Matrici e Determinanti.
Esercizio 4, Capitolo 2 (Abbena-Gianella). Data la matrice A nel parametro h:

1 -3 1 2
h 0 0 0
1 -1 0 0
0 0 0 h
determinare per quali valori di h invertibile, e in questi casi scrivere l'inverso di A.
Suggerimenti. Ripulire (col comando Clear) la variabile h. Definire una matrice A e disegnarla per controllo
(usare MatrixForm). Risolvere l'equazione (in h) Det[A]=0.
In[592]:= Clear|h]
In[593]:= A = {
{1, -3, 1, 2},
{h, 0, 0, 0},
{1, -1, 0, 0},
{0, 0, 0, h}};
MatrixForm|A]
1 -3 1 2
h 0 0 0
1 -1 0 0
0 0 0 h
In[595]:= Det|A]
Out[595]= -h
2
In[596]:= Solve|Det|A] == 0, h]
Out[596]= {{h - 0], {h - 0]]
La matrice risulta invertibile per i valori di h diversi da quelli trovati sopra. Usando il comando Inverse possiamo
calcolare la formula per la matrice inversa (esistente, per, solo quando Det[A] diverso da 0).
In[597]:= A' = Inverse|A];
MatrixForm|A']
0
1
h
0 0
0
1
h
-1 0
1
2
h
-3 -
2
h
0 0 0
1
h
Esercizio 15, Capitolo 2 (Abbena-Gianella). Data la matrice rettangolare e i vettori:
A =
2 -3 -2 1
4 -6 1 -2
6 -9 -1 -1
, X =
x1
x2
x3
x4
B1 =
1
2
0
, B2 =
1
2
3
, B3 =
0
0
0
discutere e risolvere le equazioni AX=B1, AX=B2, AX=B3.
Suggerimenti. Ripulire x1, x2, x3, x4, e definire la matrice A e i vettori (liste) B, B1, B2, B3, controllando con
MatrixForm i dati inseriti.
In[599]:= Clear|x1, x2, x3, x4]
In[600]:= A = {
{2, -3, -2, 1},
{4, -6, 1, -2},
{6, -9, -1, -1}
};
X = {x1, x2, x3, x4};
B1 = {1, 2, 0};
B2 = {1, 2, 3};
B3 = {0, 0, 0};
MatrixForm|A]
MatrixForm|A.X]
MatrixForm|X]
MatrixForm|B1]
MatrixForm|B2]
MatrixForm|B3]
2 -3 -2 1
4 -6 1 -2
6 -9 -1 -1
2 x1 - 3 x2 - 2 x3 + x4
4 x1 - 6 x2 + x3 - 2 x4
6 x1 - 9 x2 - x3 - x4
x1
x2
x3
x4
1
2
0
1
2
3
0
0
0
Lo spazio delle soluzioni (qualora non sia vuoto), per matrici rettangolari ha dimensione pari al numero delle
variabili (4, in questo caso) meno il rango (il numero di righe non tutte nulle) della forma ridotta di A. Calcol-
iamolo usando il comando RowReduce, che ci d la forma ridotta di una matrice:
In[611]:= MatrixForm|RowReduce|A]]
1 -
3
2
0 -
3
10
0 0 1 -
4
5
0 0 0 0
La dimensione dello spazio delle soluzioni (sempre qualora non sia vuoto) si pu alternativamente calcolare come
la lunghezza di una base dello spazio delle soluzioni di AX=0. Una tale base si pu generare con il comando
NullSpace, applicato alla matrice A.
In[612]:= MatrixForm|NullSpace|A]]
Length|NullSpace|A]]
3 0 8 10
3 2 0 0

Out[613]= 2
Risolviamo ora le equazioni AX = B1, B2, B3, e notiamo che lo spazio delle soluzioni (quando non vuoto) ha
sempre la soluzione calcolata in precedenza. Non c' differenza, in questo caso, tra le risposte ottenute con Solve e
Reduce, tranne che nella forma. Per esempio, AX=B1 non ha soluzioni. Quindi Solve ci risponder {} (lista vuota
di condizioni), mentre Reduce ci risponder False (la costante logica che definisce appunto l'insieme vuoto).
In[614]:= Solve|A.X == B1]
Reduce|A.X == B1]
Out[614]= {]
Out[615]= False
In[616]:= Solve|A.X == B2]
Reduce|A.X == B2]
Out[616]= x1 -
1
2
+
3 x2
2
+
3 x4
10
, x3 -
4 x4
5
Out[617]= x3 =
4 x4
5
&& x1 =
1
2
+
3 x2
2
+
3 x4
10
In[618]:= Solve|A.X == B3]
Reduce|A.X == B3]
Out[618]= x1 -
3 x2
2
+
3 x4
10
, x3 -
4 x4
5
Out[619]= x3 =
4 x4
5
&& x1 =
3 x2
2
+
3 x4
10
Casalis Andre` - Anno 2004 - Corso A - Soluzione Esercizio 4, Capitolo 2.
Data la matrice Anel parametro h :
1 3 1 2
h 0 0 0
1 1 0 0
0 0 0 h
determinare per quali valori di h invertibile,
e in questi casi scrivere l ' inverso di A.
A titolo precauzionale, per evitare che variabili precedentemente utilizzate inficino il calcolo, ripuliamo tutte le
variabili finòra utilizzate.
Definisco una matrice A e la disegno per verifica.
In[621]:= A = {
{1, -3, 1, 2},
{h, 0, 0, 0},
{1, -1, 0, 0},
{0, 0, 0, h}
};
MatrixForm|A]
1 -3 1 2
h 0 0 0
1 -1 0 0
0 0 0 h
Calcolo il determinante di A...
In[623]:= Det|A]
Out[623]= -h
2
...e ne scopro i valori di h che lo redono nullo risolvendo (verificano cioe` lèquazione Det[A]=0).
In[624]:= Solve|Det|A] =0, h]
Out[624]= {{h - 0], {h - 0]]
Trovo dunque i valori per cui la matrice NON e` invertibile e definisco B lìnversa di A (esistente solo quando
Det[A] != 0 <==> h != 0) passando poi a disegnarla.
In[625]:= A' = Inverse|A];
MatrixForm|A']
0
1
h
0 0
0
1
h
-1 0
1
2
h
-3 -
2
h
0 0 0
1
h
Ho poi provato, giocando con le possibilia` messe a disposizione dal programma, a realizzare una funzione che in
modo automatico risolvesse questo tipo di esercizi.
Puliamo nuovamente tutte le matrici.
Dichiariamo nuovamente la matrice A.
In[628]:= A =
1 -3 1 2
h 0 0 0
1 -1 0 0
0 0 0 h
;
Carichiamo la funzione DrawInverses[].
In[629]:= DrawInverses|x_, y_, A_] :=
If |(Det|A] [. y -x) == 0,
Print|"La matrice NON e` invertibile per il valore dato al parametro ", y, "."],
Print|"La matrice e` invertibile."];
A' = Inverse|A];
MatrixForm|A' [. y - x]
];
Eseguiamo la funzione nella forma DrawInverses[scalare, parametro, matrice].
La funzione verifica se per lo specifico valore assegnato al parametro la funzione e` invertibile e, in caso afferma-
tivo, la inverte.
In[630]:= DrawInverses|2, h, A]
La matrice e` invertibile.
0
1
2
0 0
0
1
2
-1 0
1 1 -3 -1
0 0 0
1
2
Come funziona DrawInverses[]?
Scopo e sintassi.
DrawInverses[scalare, parametro, matrice] e` una semplice funzione di controllo dell'invertibilita` di una data
matrice. Il primo argomento della funzione e` il valore numerico da assegnare al parametro, il secondo e` il
parametro stesso ed il terzo e` la matrice. La funzione, nel caso in cui la matrice non sia invertibile per il valore
assegnato al parametro, restituisce un messaggio d'errore, in caso contrario provvede a disegnare l'inversa della
matrice sostituendo al parametro il valore scelto.
Codice commentato.
DrawInverses[x_,y_,A_] :=
If [(Det[A]/. yx)==0,
Print["La matrice NON e` invertibile per il valore dato al parametro ",
y,"."],
Print["La matrice e` invertibile."];
A'=Inverse[A];
MatrixForm[A' /. y x]
];
DrawInverses[x_,y_,A_] :=
Il nome da assegnare alla "funzione" (da intendersi come blocco di codice che, fornito di determinati parametri,
esegue alcune operazioni standard e restituisce un risultato) e` totalmente arbitrario: l'unico vincolo e` il non
utilizzo di un nome di funzione gia` esistente nel programma.
Tra le parentesi quadre vi e` la lista delle variabili impiegate nella funzione: l'underscore che segue il nome della
variabile indica il carattere generale della variabile stessa.
If[
[...]
];
Questa istruzione, una volta sostituito il parametro con lo scalare, eguaglia il determinante della matrice a zero: se
l'uguaglianza risulta vera (e la matrice _non_ e` invertibile), esegue il primo blocco di istruzioni, in caso contrario
(e la matrice e` quindi invertibile) il secondo.
NOTA: non e` possibile eguagliare il determinante senza sostituire al parametro un valore numerico; in questo
caso, infatti, il determinante risulterebbe essere il parametro e Mathematica non e` in grado di determinare la
veridicita` di un'uguaglianza tra un numeroed un parametro.
Print["La matrice NON e` invertibile per il valore dato al parametro ", y,"."]
Questa istruzione viene eseguita se l'argomento dell'ugugaglianza e` vero e la matrice risulta quindi non invertibile:
il messaggio d'errore viene stampato come testo e la variabile viene "tradotta" (ne viene cioe` visualizzato il
significato).
Print["La matrice e` invertibile."]
A'=Inverse[A];
MatrixForm[A' /. y x]
Questo insieme di istruzioni viene eseguito nel caso in cui il determinante differisca da zero e quindi la matrice sia
invertibile. In questo caso ci si limita a calcolare l'inversa della matrice e a disegnarla sostituendo al parametro lo
scalare.
Capitolo 3: Calcolo vettoriale.
Come definire un comando per disegnare Vettori nello spazio
Come gia` visto nelle precedenti lezioni avremo bisogno di definire comandi per disegnare vettori e punti nello
spazio. Riportiamo qui la definizione di alcuni comandi che useremo molto spesso nel seguito.
In[631]:= punto3D|p_] := Graphics3D|{PointSize|0.02], Point|p]}];
punto3D|p_, label_] := Graphics3D|{PointSize|0.02], Point|p], Text|Style|label, Bold, 24], p + 0.1]}];
punto3D|p_, label_, colore_] :=
Graphics3D|{PointSize|0.02], colore, Point|p], Text|Style|label, Bold, 24], p + 0.1]}];
vettore3D|p_, label_, colore_] :=
Graphics3D|{colore, Arrow|{{0, 0, 0}, p}], Text|Style|label, Bold, 24], p[ 2 + 0.1]}];
vettore3D|p1_, p2_, label_, colore_] :=
Graphics3D|{colore, Arrow|{p1, p2}], Text|Style|label, Bold, 24], (p1 + p2) [ 2 + 0.1]}];
Riportiamo ora alcuni esempi di uso.
In[636]:= P = {0, 1, -2};
Q = {-1, 0.5, 1};
Show|vettore3D|P, Q, "PQ", Blue], punto3D|P, "P", Red]]
Show|vettore3D|Q, "0Q", Green], punto3D|P, "P", Red]]
Out[638]=
PQ
P
Out[639]=
0Q
P
Esercizi di calcolo vettoriale
Esercizio 1, Capitolo 3 (Abbena-Gianella). Indichiamo con ax, a.b, i prodotti vettoriali e scalari di a, b (vettori
in 3D). Dati i vettori a = (h,-1,3), b=(1,-h,1), c= (-2,0,k), trovare due valori reali per h,k e un vettore X =
(x1,x2,x3) tale che:
ax + bx = c
Suggerimenti. Ripulire (comando Clear) le variabili h,k. Definire a,b,c,X (come liste), e=(ax+bx). Il prodotto
vettoriale di a, b si indica con Cross[a,b], il prodotto scalare con a.b. Infine, risolvere il sistema (e = c) rispetto alle
variabili:
x1,x2,x3,k,h
E' necessario introdurre i parametri k, h tra le variabili. Se si cerca una soluzione rispetto alle sole variabili
x1,x2,x3, si cerca una soluzione valida per tutti i k, h, che non esiste (il problema risolubile solo per particolari k,
h).
In[640]:= Clear|k, h]
In[641]:= a = {h, -1, 3}
b = {1, -h, 1}
c = {-2, 0, k}
X = {x1, x2, x3}
Out[641]= {h, -1, 3]
Out[642]= {1, -h, 1]
Out[643]= {-2, 0, k]
Out[644]= {x1, x2, x3]
In[645]:= e = Cross|a, X] + Cross|b, X];
MatrixForm|Simplify|e]] (= SImplify|.] semplifica una formula =)
-4 x2 - (1 + h) x3
4 x1 - (1 + h) x3
(1 + h) (x1 + x2)
In[647]:= Solve|e == c, {x1, x2, x3, h, k}]
Reduce|e == c, {x1, x2, x3, h, k}]
Out[647]= x1 -
1
4
(1 + h) x3, x2 -
1
4
(2 - x3 - h x3), k -
1 + h
2
Out[648]= x1 = 0 && x2 =
1
2
&& x3 = 0 && k =
1 + h
2
||
x2 =
1
2
(1 - 2 x1) && x3 = 0 && h =
4 x1 - x3
x3
&& k =
1 + h
2
Esercizio 4. (i) I vettori a = (1,2,0) e b = (0,1,1) possono determinare i lati di un rettangolo? (ii) Determinare un
vettore v che rappresenti l'altezza rispetto ad a del parallelogramma individuato da a, b.
In[649]:= a = {1, 2, 0};
b = {0, 1, 1};
a.b =0
Out[651]= False
In[652]:= Show|vettore3D|a, "a", Red], vettore3D|b, "b", Blue]]
Out[652]=
a
b
Osserviamo subito che a.b (=a scalare b) non nullo. a,b non sono dunque ortogonali e quindi non possono
formare un rettangolo. Determinaimo ora l'altezza del parallelogramma.
Metodo 1. Definire un vettore incognita V = {v1,v2,v3}. Un sistema nelle variabili v1,v2,v3 la cui unica soluzione
l'altezza, si pu ottenere esprimendo certe condizioni di ortogonalit e parallelismo in termini di prodotto scalare
e vettoriale. Le condizioni da usare sono:
(1) a ortogonale a V (Spiegazione: l'altezza V di a ortogonale ad a);
(2) (bV) ortogonale ad a (Spiegazione: (bV) ortogonale al piano di b e di V, quindi ad a, che si trova nello
stesso piano).
(3) (b-V) parallelo ad a (Spiegazione: se percorriamo b, e poi dalla punta di b risaliamo all'indietro l'altezza V
relativa ad a, arriviamo in un punto del vettore a).
In[653]:= Clear|v1, v2, v3]
In[654]:= V = {v1, v2, v3}
Out[654]= {v1, v2, v3]
In[655]:= Solve|{
a.V== 0, (= a ortog. V =)
Cross|b, V].a == 0, (= bxV ortog. a =)
Cross|b - V, a] == 0 (= b-V parall. a =)
},
{v1, v2, v3}]
Out[655]= v1 - -
2
5
, v2 -
1
5
, v3 - 1
In[656]:= h = [-
2
5
,
1
5
, 1_
Out[656]= -
2
5
,
1
5
, 1
Controlliamo il risultato disegnando tutti i vettori.
In[657]:= Show|
vettore3D|a, "a", Red],
vettore3D|b, "b", Blue],
vettore3D|a, a + b, "a[a+b", Green],
vettore3D|b, a + b, "b[a+b", Cyan],
vettore3D|h, "h", Black]]
Out[657]=
a
b
a[a+b
b[a+b
h
Metodo 2. Riprendiamo il sistema precedente in v1,v2,v3, ma sostituiamo la condizione (3) con:
V.V = norma dell'altezza di b rispetto ad a.
Tale norma si ottiene con la formula:
b.b - (a.b)
2
(a.a)
In[658]:= NormaAltezza = b.b - (a.b)
2
(a.a)
Out[658]=
6
5
Il sistema ottenuto aggiungendo la condizione:
V.V=NormaAltezza
di secondo grado. Una soluzione l'altezza h, l'altra (-h) (infatti (-h) ha la stessa norma di h, e quindi soddisfa
anch'essa le condizioni del sistema).
In[659]:= Solve|{
a.V== 0,
Cross|b, V].a == 0,
V.V == NormaAltezza
},
{v1, v2, v3}]
Out[659]= v1 - -
2
5
, v2 -
1
5
, v3 - 1, v1 -
2
5
, v2 - -
1
5
, v3 - -1
Metodo 3. Dalla definizione di prodotto vettoriale possiamo dedurre che
k = (ab)a
parallelo all'altezza (per convincersene, utile disegnare ab e k).
In[660]:=
Show|
vettore3D|a, "a", Red],
vettore3D|b, "b", Blue],
vettore3D|a, a + b, "a+b", Cyan],
vettore3D|b, a + b, "a+b", Black],
vettore3D|Cross|a, b], "axb", Green],
vettore3D|Cross|Cross|a, b], a], "(axb)xa", Magenta],
Axes -> True,
PlotRange -> {-1, 5}]
Out[660]=
a
b
a+b
a+b
axb
(axb)xa
2
1
0
1
2
1
0
1
2
3
0
2
4
Basta calcolare ora il versore (vettore di lunghezza 1) associato a k (vettore di lunghezza qualunque), quindi
moltiplicare tale versore per la lunghezza del vettore-altezza. Quest'ultima uguale alla radice quadrata della
norma dell'altezza, gi calcolata.
In[661]:= LunghezzaAltezza = Sqrt|NormaAltezza]
Out[661]=
6
5
In[662]:= k = Cross|Cross|a, b], a]
Out[662]= {-2, 1, 5]
In[663]:= VersoreAltezza = k[ Sqrt|k.k]
Out[663]= -
2
15
,
1
30
,
5
6

In[664]:= h = VersoreAltezza=LunghezzaAltezza
Out[664]= -
2
5
,
1
5
, 1
Capitolo 4: Sottospazi vettoriali.
Un programma che applica il metodo degli scarti.
Esercizi sui sottospazi.
Esercizio 2, Cap.4 (Abbena-Gianella). Siano dati i vettori:
u1 = (1,-1,0,1)
u2 = (2,1,1,0)
u3 = (3,0,1,1)
u4 = (0,1,-1,0)
Trovare una base del sottospazio S da essi generato. Verificato che u1,u2,u4 sono linearmente indipendenti,
determinare per quali valori di un parametro t il vettore v=(1,-1,2t-8,t+1) appartiene ad S.
Suggerimenti. Non dimenticate di ripulire la variabile t, e di definire i vettori come liste.
In[665]:= Clear|t, l1, l2, l3]
In[666]:= u1 = {1, -1, 0, 1}
u2 = {2, 1, 1, 0}
u3 = {3, 0, 1, 1}
u4 = {0, 1, -1, 0}
v = {1, -1, 2 t - 8, t + 1}
Out[666]= {1, -1, 0, 1]
Out[667]= {2, 1, 1, 0]
Out[668]= {3, 0, 1, 1]
Out[669]= {0, 1, -1, 0]
Out[670]= {1, -1, -8 + 2 t, 1 + t]
Verifichiamo (calcolando la forma ridotta) che {u1,u2,u3,u4} sono linearmente dipendenti, mentre {u1,u2,u4} no.
In[671]:= RowReduce|{u1, u2, u3, u4}] [[ MatrixForm
1 0 0
1
2
0 1 0 -
1
2
0 0 1 -
1
2
0 0 0 0
In[672]:= RowReduce|{u1, u2, u4}] [[ MatrixForm
1 0 0
1
2
0 1 0 -
1
2
0 0 1 -
1
2
Troviamo un valore di t per cui v = l1*u1+l2*u2+l3*u4 per qualche l1,l2,l3.
In[673]:= Solve|v == l1=u1 + l2=u2 + l3=u4]
Out[673]= {{l1 - 3, l2 - -1, l3 - 3, t - 2]]
Casalis Andre` - Anno 2004 - Corso A- Soluzione Esercizio 2, Capitolo 4. Aggiornata nel 2009.
In[674]:= Clear|u1, u2, u3, u4, v, t]
Siano dati i vettori:
u1=(1,-1,0,1)
u2=(2,1,1,0)
u3=(3,0,1,1)
u4=(0,1,-1,0)
1) Trovare una base del sottospazio S da essi generato.
2) Verificato che u1,u2,u4 sono linearmente indipendenti,determinare per quali valori di un parametro t il vettore
v=(1,-1,2t-8,t+1) appartiene ad S.
Puliamo, per precauzione, tutte le variabili utilizzate.
Dichiaro i vettori che utilizzero` nei calcoli.
In[675]:= u1 = {1, -1, 0, 1};
u2 = {2, 1, 1, 0};
u3 = {3, 0, 1, 1};
u4 = {0, 1, -1, 0};
v = {1, -1, 2 t - 8, t + 1};
Con il comando Orthogonalize[{v1,v2,v3 ...}] si determinata una base ortonormale del sottospazio generato.
In[680]:= baseort = Orthogonalize|{u1, u2, u3, u4}]
Out[680]=
1
3
, -
1
3
, 0,
1
3
,
5
51
,
4
51
,
3
17
, -
1
51
,
{0, 0, 0, 0],
2
119
,
5
119
, -
9
119
,
3
119
Osserviamo che la base e' composta da 3 vettori non nulli. Questo significa che la dimensione del sottospazio e 3 e
quindi uno dei 4 vettori e' una combinazione lineare dei precedenti. Definiamo una funzione che decide se una lista
non e' tutta nulla, poi usiamo il comando Select per selezionare i vettori di baseort diversi dal vettore nullo.
In[681]:= (=Abs|L] e' la lista dei valori assoluti di L. Total|Abs|L]] e' la somma dei valori
assoluti di L. Una lista non e' tutta nulla se e solo se la somma dei suoi valori assoluti e' > 0 =)
NonNullVector|L_] := (Total|Abs|L]] > 0) ;
(= Il comando Select|L,proprieta] costruisce la lista degli elementi di L che soddisfano "proprieta". Se proprieta =
NonNullVector, Select costruisce la lista degli elementi di L diversi dal vettore nullo =)
baseort = Select |baseort, NonNullVector]
Out[682]=
1
3
, -
1
3
, 0,
1
3
,
5
51
,
4
51
,
3
17
, -
1
51
,
2
119
,
5
119
, -
9
119
,
3
119
Verifichiamo che si tratta di vettori ortonormali: la matrice di tutti i possibili prodotti scalari degli elementi di
baseort e' fatta di zeri, tranne quando moltiplichiamo un elemento per se stesso e otteniamo 1.
In[683]:= n = Length|baseort];
MatrixForm|Table|baseort||i]].baseort||j]], {i, 1, n}, {j, 1, n}]]
1 0 0
0 1 0
0 0 1
Possiamo determinare una base del sottospazio anche con RowReduce (in questo caso non sara ortonormale)
In[685]:= baseS = RowReduce|{u1, u2, u3, u4}]
Out[685]= 1, 0, 0,
1
2
, 0, 1, 0, -
1
2
, 0, 0, 1, -
1
2
, {0, 0, 0, 0]
In[686]:= Select |baseS, NonNullVector]
Out[686]= 1, 0, 0,
1
2
, 0, 1, 0, -
1
2
, 0, 0, 1, -
1
2
Verifichiamo come richiesto che u1,u2,u4 sono linearmente indipendenti (e quindi anche questi vettori formano
una base del sottospazio)
In[687]:= RowReduce|{u1, u2, u4}]
Out[687]= 1, 0, 0,
1
2
, 0, 1, 0, -
1
2
, 0, 0, 1, -
1
2
Trovata la base del sottospazio S, passo ad esaminare per quali valori del parametro t il vettore v = (1,-1,2t-8,t+1)
appartiene ad S.
Cerco quindi i valori di t per cui v sia combinazione lineare dei vettori della base per qualche coeff. l1, l2 ed l3;
memorizzato il risultato in una lista CC, utilizzo una funzione Parse per stampare il risultato in un formato piu'
simile a quello a cui siamo abituati.
In[688]:= v == l1=u1 + l2=u2 + l3=u4
Out[688]= {1, -1, -8 + 2 t, 1 + t] = {l1 + 2 l2, -l1 + l2 + l3, l2 - l3, l1]
In[689]:= CC = Sort|Solve|v == l1=u1 + l2=u2 + l3=u4]]
(= ordino le soluzioni in ordine alfabetico: esse formano una matrice di 1 riga =)
Out[689]= {{l1 - 3, l2 - -1, l3 - 3, t - 2]]
In[690]:= Parse|d_] :=
CompoundExpression|
Print|"Valori dei coefficienti:"]; (= stampo ogni li-ai nella forma li=ai =)
riga = d||1]]; (= riga e' l'unica riga della matrice d=)
col = Length|riga]; (= col e' il numero di colonne della matrice =)
For|i = 1,
i < col,
i++,
Print|riga||i]]||1]], " = ", riga||i]]||2]] ]; (= riga||i]] e' li-ai, dunque riga||i]]||1]] e' li, riga||i]]||2]] e' ai=)
]
Print|"Parametro:"]; (= stampo l'ultimo parametro t-a nella forma t=a =)
Print|riga||col]]||1]], " = ", riga||col]]||2]]]
];
In[691]:= Parse|CC]
Valori dei coefficienti:
l1 = 3
l2 = -1
l3 = 3
Parametro:
t = 2
Come funziona ParseResult[]? Scopo e sintassi.
La funzione ParseResult[Base, Lista_di_Vettori] e` una semplicissima funzione di: per ogni vettore della Base
opera un confronto con ognuno dei vettori della Lista_di_Vettori evidenziando in modo esplicito le corrispondenza
trovate.
La sintassi, molto intuitiva, prevede come primo argomento la Base su cui operare il confronto e la Lista_di_Vet-
tori da cui prendere gli elementi di confronto.
NOTA: la funzione confronta due liste di vettori e non effettua alcun controllo sull'effettiva natura di base del primo
argomento.
Come funziona ParseResult[]? Il codice commentato.
ParseResult[B_,L_]:=
For[
i=1,
i<=Length[B],
i++,
For[
c=1,
c<=Length[L],
c++,
If[
B[[i]]== L[[c]],
Print["u",c," = ", B[[i]]]
]
]
];
ParseResult[B_,L_]:=
For[
i=1,
i<=Length[B],
i++,
[..]
];
Questa istruzione istituisce un ciclo: dato ad una variabile un valore iniziale (in questo caso, assegnato il valore 1
alla variabile i), stabilito un controllo (in questo caso, che il valore di i sia minore o uguale alla lunghezza della
lista) e stabilito un tasso di incremento (in questo caso, i++ causa l'aumento di un'unita` ed e` del tutto equivalente
a i+1), l'istruzione eseguira` il blocco di codice inserito come quarto argomento (che sara` esaminato piu` avanti)
fino a quando il controllo dara` esito positivo.
Adoperiamo questa funzione perche` ci consente, grazie al valore della variabile, di prendere in esame, di volta in
volta, i vari elementi di una lista.
NOTA: per maggiori specifiche tecniche riguardo all'uso ed alla sintassi dei cicli di For[], rimando alla documen-
tazione di Mathematica.
For[
c=1,
c<=Length[L],
c++,
[..]
];
Analogamente al caso precedente, istituiamo un secondo ciclo di For, questa volta basato sulla lunghezza della
Lista_di_Vettori.
Perche`?
Un secondo ciclo di For nidificato nel primo ci consente di prendere in esame tutti i vettori della seconda lista. In
parole semplici, il primo ciclo ci fornisce un puntatore sulla prima lista: per ogni valore del puntatore (e quindi
per ogni elemento della lista di vettori che costituisce la base) effettuiamo un confronto con ogni elemento della
seconda lista (a questo scopo ecco spiegata la necessita` di un secondo puntatore, focalizzato questo sulla seconda
lista). NOTA: per maggiori specifiche tecniche riguardo all'uso ed alla sintassi dei cicli di For[], rimando alla
documentazione di Mathematica.
If[
B[[i]]== L[[c]],
[...]
]
Questa istruzione, se l'uguaglianza risulta verificata, esegue un blocco di codice specificato dall'utente. Con questo
metodo possiamo verificare, di volta in volta l'i-esimo elemento della prima lista (la Base) con il c-esimo elemento
della seconda lista (la Lista_di_Vettori)
Print["u",c," = ", B[[i]]]
Questa istruzione genera l'out-put visibile all'utente. Viene eseguita solo se l'uguaglianza precedente e` verificata e
stampa a video il nome del vettore della Lista_di_Vettori ed il suo corrispondente nella Base. Le variabili inserite
vengono "tradotte" (viene cioe` visualizzato il loro valore) ed il risultato finale e`:
u(+ valore del puntatore della prima lista) = (componenti del vettore della Base che verifica l'uguaglianza)
Come funziona Parse[]? Scopo e sintassi.
Parse[Lista] e` una funzione di puro parsing di una lista, che costituisce l'argomento stesso della funzione. La
funzione scompone la lista che costituisce il risultato indicando in modo esplicito i valori dei coefficienti e del
parametro in modo indipendente dalla lettera scelta per rappresentarli.
Come funziona Parse[]? Il codice commentato.
Parse[d_]:=
CompoundExpression[
Print["Valori dei coefficienti:"];
For[z=1,
z<Length[d[[1]]],
z++,
Print[d[[1]][[z]][[1]]," = ",d[[1]][[z]][[2]] ];
];
Print["Parametro:"];
Print[d[[1]][[Length[d[[1]]]]][[1]]," = ", d[[1]][[Length[d[[1]]]]][[2]]];
];
Parse[d_]:=
CompoundExpression[
[...]
];
Questa istruzione identifica un blocco di operazioni che Mathematica eseguira` in sequenza per poi restituire solo
il risultato finale.
NOTA: in questo utilizziamo questa istruzione perche` abbiamo piu` di un'istruzione da elaborare; nei casi
precedenti tutto si riduceva, infatti, ad una singola macro-istruzione (un ciclo di For).
NOTA 2: per ulteriori informazioni e specifiche tecniche su questa istruzione, rimando alla documentazione di
Mathematica.
Print["Valori dei coefficienti:"];
Scrivo che cosa sto per ottenere. Inserisco questa istruzione fuori dal ciclo di For per evitare che sia processata ad
ogni ripetizione del ciclo.
For[z=1,
z<Length[d[[1]]],
z++,
[..]
];
Analogamente ai cicli di For gia` visti, utilizzo questo strumento come puntatore per esaminare di volta in volta i
vari elementi della lista.
Si noti che:
a) Il controllo avverra` fino a quando la variabile z sara` minore della lunghezza della lista e non minore o uguale,
in questo modo l'ultimo elemento (esaminato per z = alla lunghezza della lista) non viene trattato.
Perche`?
L'ultimo elemento della lista non e` un coefficiente, ma il parametro e desidero quindi porlo in evidenza.
b) Tecnicamente, prendo in esame non la lista nella sua interezza, ma il primo elemento di essa: questo perche` la
lista con i risultati e` a sua volta una lista nidificata nella lista principale.
Print[d[[1]][[z]][[1]]," = ",d[[1]][[z]][[2]] ];
Questa istruzione, eseguita ad ogni ripetizione del ciclo, utilizza il puntatore per esaminare ogni soluzione. Le
soluzioni sono a loro volta una lista dove il primo elemento e` il nome del coefficiente, il secondo e` il suo valore.
Print["Parametro:"];
Analogamente a quanto fatto prima, stampo a video cio` che sto per ottenere e metto in evidenza il valore del
parametro.
Print[d[[1]][[Length[d[[1]]]]][[1]]," = ", d[[1]][[Length[d[[1]]]]][[2]]];
Stampo a video il parametro: prendo quindi il primo elemento della lista generale (la lista delle soluzioni) per poi
selezionarne l'ultimo valore (che esprimo come la lunghezza stessa della lista delle soluzioni). Il primo elemento di
questa sotto-sotto-lista e` il parametro, il secondo e` il valore del parametro.
Esercizio 3, Cap.4 (Abbena-Gianella). Siano dati i vettori:
u = (1,3,2)
v = (-2,1,1)
Trovare una base del sottospazio S da essi generato. Verificato che u, v sono linearmente indipendenti, determinare
per quali valori di un parametro t il vettore w=(t,0,-1) appartiene ad S.
Disegnate u, v, w ed il sottospazio S.
Suggerimenti. Non dimenticate di ripulire la variabile t, e di definire i vettori come liste.
In[692]:= Clear|t, l1, l2]
In[693]:= u = {1, 3, 2}
v = {-2, 1, 1}
w = {t, 0, -1}
Out[693]= {1, 3, 2]
Out[694]= {-2, 1, 1]
Out[695]= {t, 0, -1]
Verifichiamo (calcolando la forma ridotta) che {u,v} sono linearmente indipendenti.
In[696]:= RowReduce|{u, v}] [[ MatrixForm
1 0 -
1
7
0 1
5
7
Troviamo un valore di t per cui w = l1*u+l2*v per qualche l1,l2.
In[697]:= Solve|w == l1=u + l2=v]
Out[697]= {{l1 - 1, l2 - -3, t - 7]]
In[698]:= t = 7;
w
Out[699]= {7, 0, -1]
In[700]:=
Disegnamo ora u,v, w con un grafico (di nome g).
In[701]:=
g = Show|
vettore3D|u, "u", Black],
vettore3D|v, "v", Red],
vettore3D|w, "w", Blue],
ImageSize -> 300]
Out[701]=
u
v
w
Disegnamo S, lo spazio vettoriale generato da u, v. Per definizione, S = {l1*v+l2*u|l,meR}. E' quindi sufficiente
disegnare S come grafico 3D parametrico di (l1*v+l2*u), dipendente dai parametri l1, l2 (comando Parametric-
Plot3D[...]).
Ripulite prima l1,l2. Date ad l1, l2 un intervallo di valori che comprenda sia 0, 1, sia le soluzioni di w = l1*u +
l2*v viste in precedenza.
In[702]:= Clear|l1, l2]
In[703]:= g' = ParametricPlot3D|l1=u + l2=v, {l1, 0, 1}, {l2, -3, 1}, PlotStyle -Opacity|0.6]]
Out[703]=
Sovrapponiamo ora il disegno g di u,v,w con il disegno g' di S (comando Show[g,g']).
In[704]:= Show|g, g']
Out[704]=
Estrazione di una base da una lista di vettori usando il metodo degli scarti
(lezione Prof. Elsa Abbena).
Costruiamo ora un programma Base[L], che prende una lista L={b1,...,bn} di vettori di ugual dimensione, e ne
estrae un sottoinsieme linearmente indipendente che li generi tutti, stampando ogni passo intermedio di calcolo.
Non richiesto compredere il funzionamento di questo programma, ma solo di saperlo usare. Per curiosit, qui
sotto, ma non nel file di testo, solo in quello delle soluzioni, includiamo il testo del programma. Per comprenderlo,
necessario sapere che:
- If[test,a,b] esegue il test, nel caso che il test sia vero esegue a, altrimenti esegue b. If[test,a] esegue il test, nel
caso che il test sia vero esegue a, altrimenti non fa nulla.
- Do[body[i],{i,n}] esegue nell'ordine i comandi body[1], body[2], ..., body[n].
In[705]:= Base|L_] :=
(= controlliamo che L sia una lista di vettori di dimensione uguale: in altre parole, una matrice rettangolare =)
If|Not|MatrixQ|L]],
Print|"L'argomento non una lista di vettori di uguale dimensione"],
(= costruiamo una base per L: all'inizio vuota =)
base = {};
{l, dim} = Dimensions|L];
zeros = Table|0, {dim}];
Print|"Vett.Base"];
(= per un numero di passi pari al numero di vettori di L,
aggiungiamo un nuovo vettore alla base, ma confermiamo l'aggiunta solo se non produce
dipendenze lineari (se la forma ridotta della nuova base non ha tutti zeri nell'ultimissima riga) =)
Do| {nuovabase = Append|base, L||i]]],
If|Last|RowReduce|nuovabase]] = zeros,
base = nuovabase],
Print|i, " ", base]
},
{i, l}];
(= Stampiamo il risultato ad ogni passo ed alla fine =)
Print|"Risultato"];
base]
Sperimentiamo ora il programma Base[...] su alcuni esempi, presi in uno spazio 3D. L'argomento deve essere una
lista L = {b1,...,bn} di vettori di ugual lunghezza. Come esempio, scegliamo:
b1 = {1,1,0}; b2 = 2*b1; b3 = {3,-1,1}; b4 = b1+b3; b5 = {3,0,2}; L = {b1,b2,b3,b4,b5};
In[706]:= B = Base|{{1}, {2, 3}}]
L'argomento non una lista di vettori di uguale dimensione
In[707]:= b1 = {1, 1, 0};
b2 = 2=b1;
b3 = {3, -1, 1};
b4 = b1 + b3;
b5 = {3, 0, 2};
L = {b1, b2, b3, b4, b5};
In[713]:= B = Base|L]
Vett.Base
1 {{1, 1, 0]]
2 {{1, 1, 0]]
3 {{1, 1, 0], {3, -1, 1]]
4 {{1, 1, 0], {3, -1, 1]]
5 {{1, 1, 0], {3, -1, 1], {3, 0, 2]]
Risultato
Out[713]= {{1, 1, 0], {3, -1, 1], {3, 0, 2]]
Il risultato consiste dei vettori non scartati, ed stato immagazzinato in B:
In[714]:= B
Out[714]= {{1, 1, 0], {3, -1, 1], {3, 0, 2]]
In[715]:=
In[716]:=
Disegnamo ora b1, b3, b5.
In[717]:= a = vettore3D|B||1]], "b1", Black];
b = vettore3D|B||2]], "b3", Red];
c = vettore3D|B||3]], "b5", Blue];
Show|a, b, c, ImageSize -> 300 ]
Out[720]=
b1
b3
b5
Sottraiamo ora gli elementi di B da L (comando Complement[L,B]), ottenendo i vettori "scartati" nella
costruzione della base, e disegnamo un grafico g che contenga anch'essi.
In[721]:= L2 = Complement|L, B]
Out[721]= {{2, 2, 0], {4, 0, 1]]
In[722]:= d = vettore3D|L2||1]], "2=b1 (scartato)", Green];
e = vettore3D|L2||2]], "b1+b3(scartato)", Cyan];
g = Show|a, b, c , d, e, ImageSize -> 300]
Out[724]=
b1
b3
b5
2=b1 (scartato)
b1+b3(scartato)
Alcuni dei vettori scartati di L appartengono al piano S generato da primi due vettori di B, siano essi b1, b3.
Verifichiamolo disegnando tale piano come un grafico di nome g'.
Per definizione, S = {l1*b1+l2*b3|l,meR}. E' quindi sufficiente disegnare S come grafico 3D parametrico di
(l1*b1+l2*b3), dipendente dai parametri l1, l2 (comando ParametricPlot3D[...]).
Suggerimenti. Ripulite prima l1,l2. Date ad l1, l2 un intervallo di valori che comprenda sia 0, 1, sia le soluzioni di
b2 = l1*b1 + l2*b3 e di b4 = l1*b1 + l2*b3 (altrimenti questi vettori spariranno dal grafico).
In[725]:= Clear|l1, l2]
Solve|b2 == l1=b1 + l2=b3, {l1, l2}]
Solve|b4 == l1=b1 + l2=b3, {l1, l2}]
Out[726]= {{l1 - 2, l2 - 0]]
Out[727]= {{l1 - 1, l2 - 1]]
In[728]:= g' = ParametricPlot3D|l1=b1 + l2=b3, {l1, 0, 2}, {l2, 0, 1}, Boxed -> False]
Out[728]=
Per disegnarei vettori ed il piano insieme, baster infine sovrapporre il grafico g' di S al grafico g dei vettori b1,
b2, b3, b4, b5 (il comando Show[g,g']).
In[729]:= Show|g, g',
Boxed -> False, ImageSize -> 300]
Out[729]=
Capitolo 5: esercizi su vettori ortogonali.
Generazione di una base ortonormale (Gram-Schmidt).
Esercizio 5 del Novembre 2003.
Dato il sottospazio Hgenerato dal vettore (1, 1, 3, 1) dello spazio R
4
,
trovare una base ortonormale per il sottospazio ortogonale ad H.
In[730]:= u = {1, -1, 3, 1};
Definiamo una applicazione lineare A = {u}, tale che AX=0 se e solo se X ortogonale a u.
In[731]:= (A = {u}) [[ MatrixForm
( 1 -1 3 1 )
Una base dello spazio delle soluzioni di AX=0 si pu calcolare con il comando NullSpace, ed anche una base
dello spazio dei vettori ortogonali a u.
In[732]:= {u1, u2, u3} = NullSpace|{u}]
Out[732]= {{-1, 0, 0, 1], {-3, 0, 1, 0], {1, 1, 0, 0]]
La base trovata ha dimensione 3, e consiste di certi vettori u1, u2, u3. Verifichiamo che u1, u2, u3 sono ortogonali
ad u.
In[733]:= {u1.u, u2.u, u3.u}
Out[733]= {0, 0, 0]
Estraiamo, attraverso proiezioni e sottrazioni successive, una base ortonormale dalla base u1, u2, u3.
Siano dati
u = (1,-h,0)
v = (h,-1,0)
w = (h,2,-h)
(1) Trovare un h per cui u, v, w sono nello stesso piano S.
(2) Trovare un h per cui u, v sono paralleli.
(3) Trovare un h per cui il parallelogramma u, v ha area 6.
(4) Trovare un h per cui il tetraedro u, v, w ha volume 2.
Definisco i vettori u,v,w, e carico il pacchetto MathMacro.txt. Ricordatevi di ripulire h.
In[734]:= Clear|h];
u = {1, -h, 0};
v = {h, -1, 0};
w = {h, 2, -h};
(1) Trovare un h per cui u, v, w sono nello stesso piano S.
Se i tre vettori formano un piano uno dei tre puo' essere espresso come combinazione lineare degli altri due. Questa
condzione si puo' esprimere dicendo che il determinante della matrice {u,v,w} e' nullo.
In[738]:= s = Solve|Det|{u, v, w}] =0]
Out[738]= {{h - -1], {h - 0], {h - 1]]
In[739]:= Table|Show|
vettore3D| u [. s||n]], "u", Red],
vettore3D|v [. s||n]], "v", Blue],
vettore3D|w [. s||n]], "w", Green]], {n, 1, Length|s]}]
Out[739]=
u
v
w
,
u
v
w
, uv
w

In[740]:=
(1 )Soluzione alternativa
Risolviamo l'equazione av+bu+cw=0 nelle incognite a,b,c,h, scartando la soluzione a=b=c=0. Ricordatevi di
ripulire le variabili a,b,c.
In[741]:= Clear|a, b, c]
In[742]:= Solve|a u + b v + c w == 0, {a, b, c, h}]
Reduce|a u + b v + c w == 0, {a, b, c, h}]
Out[742]= {a - 0, b - 0, c - 0], {b - a, c - 0, h - -1], a - 0, c -
b
2
, h - 0, {b - -a, c - 0, h - 1]
Out[743]= (a = 0 && b = 0 && c = 0) || a = 0 && c =
b
2
&& h = 0 ||
(b = -a || b = a) && c = 0 && a = 0 && h = -
b
a
La soluzione quindi h=0. Disegnamo u, v, w ed il piano
S = {a u + b v| a, b in R}
in questo caso. S una curva parametrica (usare il comando ParametricPlot3D).
In[744]:= h = 0;
In[745]:= Show|
vettore3D|u, "u", Red],
vettore3D|v, "v", Blue],
vettore3D|w, "w", Black],
ParametricPlot3D|a u + b v,
{a, 0, 1}, {b, -2, 1}, DisplayFunction -> Identity],
ImageSize -> 300, Axes -> True]
Out[745]=
(2) Trovare un h per cui u, v sono paralleli. Risolviamo l'equazione u x v = (0,0,0) (u vettoriale v = (0,0,0)). Il
prodotto vettoriale si indica con Cross. Ricordatevi di ripulire la variabile h.
In[746]:= Clear|h]
In[747]:= Solve|Cross|u, v] == {0, 0, 0}, h]
Out[747]= {{h - -1], {h - 1]]
Le due soluzioni trovate corrispondono a u=v ed a u = -v.
In[748]:= h = -1;
Show|
ImageSize -> 300,
Axes -> True]
Out[749]=
u
v
w
1.0
0.5
0.0
0.5
1.0
1
0
1
2
0.0
0.5
1.0
In[750]:= h = +1;
Show|
ImageSize -> 300,
Axes -> True]
Out[751]=
uv
w
0.0
0.5
1.0
1
0
1
2
1.0
0.5
0.0
(3) Trovare un h per cui il parallelogramma u, v ha area 6. L'area del parallelogrammo pari al prodotto vettori-
ale di u, v. Impostiamo quindi l'equazione:
norma di uxv = 6*6
In[752]:= Clear|h]
In[753]:= Solve|Cross|u, v].Cross|u, v] == 6=6, h]
Out[753]= h - -f 5 , h - f 5 , h - - 7 , h - 7
In[754]:= h = 7 ;
{u, v}
Out[755]= 1, - 7 , 0, 7 , -1, 0
In[756]:=
In[757]:= Show|
vettore3D|v, "v", Black],
vettore3D|u + v, "u+v", Red],
vettore3D|u, u + v, "u[u+v", Blue],
vettore3D|v, u + v, "v,u+v", Green],
ImageSize -> 300,
Axes -> True]
Out[757]=
u
v
u+v
u[u+v
v,u+v
0
1
2
3
3
2
1
0
0.00
0.05
0.10
(4) Trovare un h per cui il tetraedro u, v, w ha volume 2.
Soluzione 1. Utilizziamo la formula:
(1/6)Det[{u,v,w}] = volume tetraedro compreso tra u, v w
In[758]:= Clear|h];
N|Reduce|(1[ 6) Det|{u, v, w}] == 2]]
Out[759]= h = -2.43484 || h = 1.21742 - 1.85643 f || h = 1.21742 + 1.85643 f
Soluzione 2. Anzich utilizzare una formula gi data, proviamo a ottenere il volume del tetraedro con un ragiona-
mento, quindi ad imporre che valga 2.
In[760]:= Clear|h];
In[761]:= (= Nel caso che il comando ?Norm risponda che Norm non e' definito, definire esplicitamente Norm|x_]:= x.x
Nelle versioni dalla 5 in poi non e' necessario =)
Calcoliamo il prodotto vettoriale di u, v.
In[762]:= uxv = Cross|u, v]
Out[762]= 0, 0, -1 + h
2
Tale prodotto pari all'area del parallelogrammo di lati u, v, dunque pari al doppio dell'area del triangolo di lati u,
v.
In[763]:= baseuv = Norm|uxv] [ 2
Out[763]=
1
2
Abs-1 + h
2
u x v ortogonale al piano di u, v. Dunque il versore versuxv associato ad uxv e' il versore ortogonale al piano di
u, v. Calcoliamolo:
In[764]:= versuxv = uxv[ Norm|uxv]
Out[764]= 0, 0,
-1 + h
2
Abs[-1 + h
2
]
L'altezza del tetraedro di lati u, v, w rispetto alla base u, v pari alla lunghezza della proiezione di w sul versore
versuxv ortogonale al piano di u, v. Dunque si calcola con un prodotto scalare dei due vettori:
In[765]:= altezzauv = w.versuxv
proiezuv = versuxv=altezzauv
Out[765]= -
h (-1 + h
2
)
Abs[-1 + h
2
]
Out[766]= 0, 0, -
h (-1 + h
2
)
2
Abs[-1 + h
2
]
2
Infine, il volume del tetraedro pari all'area di base per l'altezza diviso 3:
In[767]:= Volume = baseuv=altezzauv[ 3
Out[767]= -
1
6
h -1 + h
2
,
Risolviamo ora numericamente l'equazione Volume = 2.
In[768]:= NSolve|Volume == 2, h]
Out[768]= {{h - -2.43484], {h - 1.21742 - 1.85643 f], {h - 1.21742 + 1.85643 f]]
Una sola delle soluzioni trovate un numero reale, quindi accettabile:
In[769]:= h = -2.434841368216901`;
Disegnamo ora, per il valore di h che abbiamo trovato, tutti i vettori utilizzati: u, v, il piano di u, v, il prodotto uxv,
il suo versore, e la proiezione di w su tale versore (l'altezza del tetraedro).
In[770]:= Show|
vettore3D|v, "v", Black],
vettore3D|uxv, "uxv", Red],
vettore3D|versuxv, "versuxv", Green],
vettore3D|proiezuv, "proiezuv", Cyan],
ParametricPlot3D|a u + b v, {a, 0, 1}, {b, 0, 1}, DisplayFunction -> Identity],
ImageSize -> 300,
Axes -> True,
(=per una visione frontale=)
ViewPoint -Front ]
Out[770]=
Dato il sottospazio W degli (x,y,z) di R3 tali che x-2y+z=0, 2x-y-z=0, trovare una base di W e dello spazio
ortogonale a W.
Soluzione. Definiamo una applicazione lineare A tale che A.X=0 se e solo se X e' in W.
In[771]:= A = {{1, -2, 1}, {2, -1, -1}}
Out[771]= {{1, -2, 1], {2, -1, -1]]
Il Kernel o NullSpace di A W. Una base del Kernel di A, ottenibile con il comando NullSpace[], quindi una
base di W. Tale base un insieme {u}, che consiste di un solo vettore u:
In[772]:= {u} = NullSpace|A]
Out[772]= {{1, 1, 1]]
Definiamo una applicazione lineare B che si annulla sui vettori ortogonali a u. Il Kernel o NullSpace di B
l'ortogonale di W. Una base {u1,u2} del Kernel di B, ottenibile con il comando NullSpace[], quindi una base
dell'ortogonale di W.
In[773]:= B = {u}
{u1, u2} = NullSpace|B]
Out[773]= {{1, 1, 1]]
Out[774]= {{-1, 0, 1], {-1, 1, 0]]
Determinare una base ortonormale del piano ortogonale al vettore i+j-k.
Gram-Schmidt: un metodo per generare una base ortonormale data una lista di vettori.
Il metodo Gram-Schmidt consente di prendere un qualunque insieme L di vettori linearmente indipendenti,
e di generare una base ortonormale equivalente ad L. Il comando in Mathematica Orthogonalize, gia' visto in uno
dei precedenti esercizi.
Qui potete trovare la definizione di un comando BaseOrt[ListaVettori], che prende una lista L di vettori
qualunque, e genera una base ortonormale dello spazio vettoriale generato da L usando Gram-Schmidt, e stam-
pando i calcoli svolti ad ogni passo. A differenza di quanto fa il comando Orthogonalize di Mathematica, qui
vettori linearmente dipendenti dai vettori precedenti vengono scartati.

In[775]:= L = {{0, 1, 1}, {2, 3, 5}, {0, 1, 0}}
Dimensions|L]
Out[775]= {{0, 1, 1], {2, 3, 5], {0, 1, 0]]
Out[776]= {3, 3]
In[777]:= Orthogonalize|L]
Out[777]= 0,
1
2
,
1
2
,
2
3
, -
1
6
,
1
6
,
1
3
,
1
3
, -
1
3
Se la lista L linearmente dipende il comando Orthogonalize restituisce dei vettori nulli.

In[778]:= L = {{0, 1, 1}, {2, 3, 5}, {0, 1, 0}, {7, 3, 4}, {0, 1, 2}}
Dimensions|L]
Orthogonalize|L]
Out[778]= {{0, 1, 1], {2, 3, 5], {0, 1, 0], {7, 3, 4], {0, 1, 2]]
Out[779]= {5, 3]
Out[780]= 0,
1
2
,
1
2
,
2
3
, -
1
6
,
1
6
,
1
3
,
1
3
, -
1
3
, {0, 0, 0], {0, 0, 0]
BaseOrt. Per scaricare BaseOrt, usate SetDirectory["path"] per dare l'indirizzo del file MacroMath.txt di
macro del corso. Quindi scrivere MathMacro.txt.
In[781]:= (= Un comando che mette in grassetto un testo =)
BoldFace|s_] := StyleForm|s, FontWeight -> "Bold"];
In[782]:= BaseOrt|L_] := Block_
(= Lista variabili temporanee di BaseOrt=)
{n, m, zero, base, dim, i, v, w},
(= Blocchiamo l'esecuzione se i vettori non hanno la stessa lunghezza =)
If|MatrixQ|L] == False, Print|"L'argomento non una lista di vettori di uguale lunghezza"]; Abort|]];
(= Sia n il numero dei vettori, m la loro dimensione =)
{n, m} = Dimensions|L];
zero = Table|0, {m}];
(= A ogni passo sottraiamo al vettore L||i]] le sue proiezioni su gli elementi
base||1]], ..., base||dim]]
della base ortonormale in costruzione. Se ci che resta = zero,
lo normalizziamo e lo aggiungiamo alla base ortonormale. Altrimenti scartiamo L||i]]. =)
For_
base = {}; dim= 0; i = 1, (= Inizio FOR =)
i n, (=Test di uscita FOR =)
++i, (= Incremento FOR =)
(= Corpo FOR =)
Print|"Passo n." [[ BoldFace, i, ":"];
v = L||i]] - _
j=1
dim
(base||j]].L||i]]) =base||j]] ;
v = FullSimplify|v];
(= v = proiezione di L||i]] su base. FullSimplify semplifica il piu' possibile la notazione di v =)
If_v = zero,
(= Se v=zero, normalizziamo v e lo aggiungiamo a base =)
w = v] (v.v) ; (= w ha norma 1 =)
w = FullSimplify|w];
base = Append|base, w];
(= Aggiorniamo il contatore degli elementi di base =)
++dim;
Print|"Vettore L||", i, "]] = ", L||i]], " trasformato in: \n", w],
(= Se v=zero, scartiamo v =)
Print|"Vettore L||", i, "]] = ", L||i]], " scartato"]__;
Print|"Risultato:" [[ BoldFace, "si ottenuta la base ortonormale"];
base_
Sperimentiamo BaseOrt su una lista di vettori L linearmente dipendenti.
In[783]:= L = {{0, 1, 1}, {2, 3, 5}, {0, 1, 0}, {7, 3, 4}, {0, 1, 2}}
Dimensions|L]
Out[783]= {{0, 1, 1], {2, 3, 5], {0, 1, 0], {7, 3, 4], {0, 1, 2]]
Out[784]= {5, 3]
In[785]:= BaseOrt|L]
Passo n.1:
Vettore L[[1]] = {0, 1, 1] trasformato in:
0,
1
2
,
1
2
Passo n.2:
2
3
, -
1
6
,
1
6
Passo n.3:
1
3
,
1
3
, -
1
3
Passo n.4:
Vettore L[[4]] = {7, 3, 4] scartato
Passo n.5:
Vettore L[[5]] = {0, 1, 2] scartato
Risultato:si ottenuta la base ortonormale
Out[785]= 0,
1
2
,
1
2
,
2
3
, -
1
6
,
1
6
,
1
3
,
1
3
, -
1
3
Appendice 1. Autovalori e autovettori

I comandi Eigenvalues e Eigenvectors valutano autovalori e autovettori di una matrice quandrata. Vediamo alcuni
esempi.
In[786]:= m= {{2.3, 4.5, -1.0 }, {2.7, 3.1 , 4.5 }, {-1.4, 2.6, 1.1}}
lambda = Eigenvalues|m]
av = Eigenvectors|m]
Out[786]= {{2.3, 4.5, -1.], {2.7, 3.1, 4.5], {-1.4, 2.6, 1.1]]
Out[787]= {6.71366, -3.38661, 3.17295]
Out[788]= {{0.687405, 0.709103, 0.156992],
{0.579717, -0.613393, 0.536357], {-0.856699, -0.0521516, 0.513174]]
In[789]:= m.av||1]]
lambda||1]] =av||1]]
Out[789]= {4.615, 4.76068, 1.05399]
Out[790]= {4.615, 4.76068, 1.05399]
In[791]:= Clear|a, b]
m= {{a, 2=b}, {-a, b}}
Eigenvalues|m]
Out[792]= {{a, 2 b], {-a, b]]
Out[793]=
1
2
a + b - a
2
- 10 a b + b
2
,
1
2
a + b + a
2
- 10 a b + b
2
Appendice 2. Un programma che applica il Teorema di Cramer (a sistemi di 3

equazioni in 3 incognite). Da un'idea dello studente del primo anno di Fisica
Tommaso Demarie - Torino, 23 Ottobre 2003
Questa appendice contiene un esempio di programma svolto da studenti del primo anno.
Il comando Cramer[]. Prima versione.
Supponiamo dato un sistema di 3 equazioni in 3 incognite, come segue:
ax+by+cz = b1
dx+ey+fz = b2
gx+hy+iz = b3
Scriveremo un programma Cramer[], per risolvere il sistema dato usando il metodo di Cramer.
Funzionamento di Cramer[]. Dopo aver scritto il comando "Cramer[]" e aver dato l'invio, il computer ci
chieder di scrivere, in una apposita finestra, ogni valore della matrice
A =
a b c
d e f
g h i
dei coefficenti e della matrice B
B =
b1
b2
b3
dei termini noti del sistema. Fatto ci, il comando provveder a fornirci i valori delle tre incognite x,y,z, nella
forma:
X =
x
y
z
Confronto tra Cramer[] e Reduce[]. Il comando "Reduce" ci permette di ottenere gli stessi risultati. Lo svantag-
gio di "Reduce,", tuttavia, che manca di spiegazioni: lo utilizziamo come se fosse una "scatola nera". Pu quindi
essere interessante scrivere noi stessi un comando, e capirne il funzionamento grazie al Teorema di Cramer.
Nota. Il comando Cramer[], proprio perch basato sul Teorema di Cramer, non pu essere applicato a matrici con
determinante uguale a zero.
Note sui comandi utilizzati.
1. Il comando a = Input[messaggio]. Questo comando apre una finestra di dialogo, scrive un messaggio di
spiegazione, e aspetta che noi inseriamo un v valore nella finestra. Quando noi chiudiamo la finestra, il valore v
viene assegnato alla variabile a.
Un messaggio viene detto "stringa" in Informatica. Si scrive tra virgolette. Un "a capo" si indica con "\n".
2. Uso di Variabili Locali. L'uso dell'istruzione Block[ {lista_variabili_locali} comando1; ...; comando_n] rende
temporanee le assegnazioni fatte dal programma Cramer[] alle variabili a, b, c, ..., x, y, z. Terminata l'esecuzione
del programma, queste variabili riprendono il valore che avevano prima dell'esecuzione. Quest'uso delle variabili e'
detto locale al comando, dato che non ha effetto sul valore della variabile al di fuori del comando. Ha il vantaggio
di non modificare precedenti assegnazioni ad a, b, c, ..., x, y, z, che possono ancora servirci.
3. La variabile detA. Si noti anche l'uso della variabile "detA", per evitare di calcolare piu' volte il determinante di
A. E' buona norma evitare di calcolare piu' volte la stessa espressione, per ridurre i tempi di calcolo. In questo
caso, tuttavia, dobbiamo aggiungere che il tempo guadagnato e' del tutto irrilevante.
Definizione di Cramer[].
In[794]:= Cramer|] := Block_
(= Lista delle variabili usate localmente al comando Cramer|] =)
{a, b, c, d, e, f, g, h, i, A, b1, b2, b3, B, x, y, z, detA},
(= Lettura dei 12 dati =)
a = Input|"Primo coefficente del vettore 1"];
b = Input|"Secondo coefficente del vettore 1"];
c = Input|"Terzo coefficente del vettore 1"];
d = Input|"Primo coefficente del vettore 2"];
e = Input|"Secondo coefficente del vettore 2"];
f = Input|"Terzo coefficente del vettore 2"];
g = Input|"Primo coefficente del vettore 3"];
h = Input|"Secondo coefficente del vettore 3"];
i = Input|"terzo coefficente del vettore 3"];
A=
a b c
d e f
g h i
;
Print|"A=", MatrixForm|A]];
detA = Det|A];
Print|"Det|A]=", detA];
b1 = Input|"Termine noto della prima equazione"];
b2 = Input|"Termine noto della seconda equazione"];
b3 = Input|"Termine noto della terza equazione"];
B = {b1, b2, b3};
Print|"B=", MatrixForm|B]];
(= Calcolo delle soluzioni se detA != 0 =)
If_detA= 0,
(= Caso Det|A]=0 =)
x =
Det_
b1 b c
b2 e f
b3 h i
_
detA
; y =
Det_
a b1 c
d b2 f
g b3 i
_
detA
; z =
Det_
a b b1
d e b2
g h b3
_
detA
;
X = {x, y, z}; Print|"\n Le soluzioni del sistema sono \n X =", MatrixForm|X ]],
(= Caso Det|A]==0 =)
Print|"\n Essendo il determinante uguale a zero,il teorema di Cramer non pu essere applicato"]__;
Esempio di uso del comando Cramer[].
Valutare la sezione precedente per insegnare a Mathematica il comando Cramer[]. Quindi valutare Cramer[] e
seguire le istruzioni che si presentano.
In[795]:= (= Cramer|] =)
Il Comando Cramer[]. Seconda Versione.
E' possibile ridurre il tempo di immissione dati inserendoli sotto forma di lista anziche' di elementi singoli. Dobbi-
amo solo scrivere un messaggio avvisando che i dati devono essere introdotti sotto forma di una lista di 12 ele-
menti. Dato che il messaggio e' lungo, scriveremo pi messaggi msg1, msg2, ... e dopo li concateneremo scrivendo
msg1 <> msg2 <> ... .
Dobbiamo anche introdurre degli IF per bloccare l'esecuzione quando il dato non una lista, oppure una lista ma
non di 12 elementi. L'esecuzione si blocca con il comando Abort[].
Definizione di Cramer2[].
In[796]:= Cramer2|] := Block_
(= Lista delle variabili usate localmente al comando Cramer|] =)
{forma1, forma2, messaggio, dati, l, a, b, c, d, e, f, g, h, i, A, b1, b2, b3, B, x, y, z, detA},
(= Chiediamo i 12 dati sotto forma di una lista di 12 elementi =)
forma1 = "\n ax + by +cz = b1 \n dx +ey + fz = b2 \n gx + hy + iz = b3 \n";
forma2 = "\n {a,b,c,b1, d,e,f,b2, g,h,i,b3} \n";
messaggio = "Introdurre il sistema" <> forma1 <> "nella forma di una lista di 12 elementi: " <> forma2;
dati = Input|messaggio];
(= Se il dato non e' una lista o non ha 12 elementici fermiamo =)
If|Not|ListQ|dati]], Print|"I dati non sono stati inseriti sotto forma di lista: \n", dati]; Abort|]];
l = Length|dati];
If |l = 12, Print|"Inseriti n. ", l, " dati anziche' 12 come richiesto: \n", dati]; Abort|]];
(= Se il dato una lista di 12 elementi proseguiamo =)
{a, b, c, b1, d, e, f, b2, g, h, i, b3} = dati;
A=
a b c
d e f
g h i
;
Print|"A=", MatrixForm|A]];
detA = Det|A];
Print|"Det|A]=", detA];
B = {b1, b2, b3};
Print|"B=", MatrixForm|B]];
(= Stampa dei risultati =)
If_detA= 0,
(= Caso Det|A]=0 =)
x =
Det_
b1 b c
b2 e f
b3 h i
_
detA
; y =
Det_
a b1 c
d b2 f
g b3 i
_
detA
; z =
Det_
a b b1
d e b2
g h b3
_
detA
;
X = {x, y, z}; Print|"\n Le soluzioni del sistema sono \n X =", MatrixForm|X ]],
(= Caso Det|A]==0 =)
Print|"\n Essendo il determinante uguale a zero,il teorema di Cramer non pu essere applicato"]__;
Esempio di uso del comando Cramer2[].
Valutare la sezione precedente per insegnare a Mathematica il comando Cramer2[]. Quindi valutare Cramer2[] e
seguire le istruzioni che si presentano.
In[797]:= (= Cramer|] =)
Esercitazione 3A: Rette, Piani, Sfere, Coni, Cilindri e Coniche
Esercitazione 3B: Rette e Piani, Algebra Lineare
Appendice: Algebra, Analisi e soluzioni di equazioni e sistemi (non fa parte del corso)
Matematica curiosa e divertente
(con esempi di utilizzo di Mathematica)
Non fa parte del corso

Mathematica Dispense 2011

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Mathematica Dispense 2011

Caricato da

Copyright:

Formati disponibili

Tecniche Informatiche per la Fisica

Out[129]= {{1, 0], {0, 1]]

1 2 6 Mat hemat ica- Dispense- 2011. nb

1 3 8 Mat hemat ica- Dispense- 2011. nb

Se la lista L linearmente dipende il comando Orthogonalize restituisce dei vettori nulli.

Appendice 1. Autovalori e autovettori

Appendice 2. Un programma che applica il Teorema di Cramer (a sistemi di 3

Potrebbero piacerti anche