Problemi di Fisica con l'uso del PC

VIII Lezione

8 Liste

8.1 Definizione

Le Liste sono sequenze di  oggetti di Mathematica separate da virgole e racchiuse tra parentesi graffe. 
Diverse funzioni incorporate in  Mathematica danno come risultato delle liste:

Solve[{x^2  -  5 x  -  y  +  4  ==  0,  
        x  -  4 y  ==  1},  {x,  y}]

Options[Plot3D]

8.2 Generazione, Visualizzazione, e Dimensioni di Liste

Oltre alla funzione  Table , le  funzioni che generano liste sono:
Range[imax]			genera la lista {1,2,.....,imax}
Range[imin,imax]		genera la lista {imin,imin+1,.....,imax}
Range[imin,imax,di]		genera la lista {imin,imin+di,.....,imax}
Array[a,n]			crea la lista {a[1],a[2],.....,a[imax]}
Array[a,{n1,n2,....}]		crea una lista  n1xn2xn3... , con elementi a[i1,i2,.....]

Le funzioni per visualizzare le liste sono:
ColumnForm[list]		Mostra list per colonne
MatrixForm[list]		Mostra list in forma matriciale
TableForm[list]		Mostra list in forma di tabella
Le funzioni per determinare la dimensione delle liste sono:
Length[list]			da il numero di elementi in list
Dimension[list]		da una lista delle dimensioni di list

Range[10,  21,  2]

Length[%]

ColumnForm[%%]

Table[1  +  Sin[x]^n,  {n,  1,  7,  2}]

c[x_]  :=  x^3

Array[c,  10]

Table[x^i  +  y^j,  {i,  3},  {j,  4}]

Dimensions[%]

TableForm[%%]

Clear[c]

8.3 Estrazione di elementi da una lista

Le funzioni per ottenere elementi di una lista sono:
First[list]						il primo elemento di list
Last[list]						l'ultimo elemento di list
Part[list,n] or list[[n]]					l'elemeto n-simo di list
Part[list,{n1,n2,.....}] or list[[{n1,n2,....}]]		la sottolista formata dagli elementi n1,n2,...
Take[list,n]						la sottolista formata dagli elementi 1,2,...n di list
Take[list,{m,n}]					la sottolista formata dagli elementi n1,n1+1,....,n2 di list
Drop[list,n]						la sottolista ottenuta da list eliminando gli elementi 1,2,...n di list
Drop[list,{m,n}]					la sottolista ottenuta da list eliminando gli elementi n1,n1+1,....,n2 di list
Extract[list,{n1,n2,.....}]				l'elemento list[[i,j]]
Extract[list,{i1,i2,.....},{j1,j2,.....}]			la sottolista formata dagli elementi list[[i1,i2,..],list[[j1,j2,..]]...
Per illustrare l'uso di queste funzioni consideriamo degli esempi.

Esempio 8.1

(a)  Creare la lista {xCos(x), (x^2) Cos(2  x), (x^3) Cos(3  x), (x^4) Cos(4  x), (x^5) Cos(5  x), (x^6) Cos(6  x)}
(b)  Estrarre il quarto elemento
(c)  Ottenere la lista formata dal terzo e dal quinto elemento
(d)   Ottenere la lista formata dai primi tre elementi
(e)  Ottenere la lista senza gli elementi dal secondo al quarto

mylist  =  Table[x^n Cos[n x],  {n,  6}]

mylist[[4]]

mylist[[{3,  5}]]

Take[mylist,  3]

Drop[mylist,  {2,  4}]

Clear[mylist]

▲▲▲

Example 6.2
(a)  Creare una lista di liste 3×4 con elementi (Subscript[c, ij]).
(b)  Visualizzare la lista nella forma matriciale standard.
(c)  Selezionare il terzo elemento della lista.
(d)  Estrarre il secondo elemento della prima sottolista.

nestedlist  =  Array[c,  {3,  4}]

MatrixForm[nestedlist]

nestedlist[[3]]

nestedlist[[1, 2]]

Extract[nestedlist,  {1,  2}]

Clear[nestedlist]

Le funzioni che abbiamo esaminato estraggono  elementi in base alla loro posizione in list. Per avere laposizione di un elemento in list si può usare la fuzione:
Position[list,elem] 				da una lista di posizione in cui appare l'elemento elem. 

Gli elementi di una lista possono essere estratti anche in base ad una regola di selezione:
Select[list,criterion] 				Costruisce la lista degli elementi  ei per cui  criterion[ei] è True.
Select[list,criterion,n]				Costruisce la lista dei primi n elementi  ei per cui  criterion[ei] è True.
Le funzioni che possono essere utilizzate come criterio sono le funziona logiche. Una funzione logica è una funzione che da come risultato True o False.Alcune funzioni logiche sono
DigitQ		EvenQ		IntegerQ	LetterQ	ListQ		LowerCaseQ	MatrixQ	Negative
NonNegative	NumberQ	OddQ		OrderedQ	Positive	PrimeQ	StringQ	ValueQ UpperCaseVectorQ	NumericQ

Position[{a,  {a,  b,  a},  b,  {{a,  b},  c}},  a]

?EvenQ

Select[{1,  2,  3,  4,  5,  6},  EvenQ]

Select[{1,  2,  3,  4,  5,  6},  EvenQ,  2]

Select[{a,  4  +  I 5,  x^2,  -2,  3,  -5,  2/3},  
      Positive]

Select[{{a,  2  -  3 I,  7},  x,  {-2,  {1,  -5}},  
        2/3},  VectorQ]

8.4 Cambiamento di elementi di Liste e Sottoliste

Alcune funzioni usate per inserire, eliminare e sostituire elementi di liste e sottoliste sono:
Prepend[list,elem]					Inserisce elem al primo posto in list
Append[list,elem]					Appende elem a list
Insert[list, elem, i]					Inserisce elem in list nella posizione i. Se i<0, la posizione è calcolata dalla fine.
Insert[list, elem,{i, j, ... }]				Inserisce elem in list nella posizione {i,j,...}
Insert[list, elem,{{i1, j1, ... },{i2, j2, ... },..}]	Inserisce elem in list nelle posizioni {i1,j1,...},{i2,j2,...},...
Delete[list, i]						Elimina l'elemento nella posizione i. Se i<0, la posizione è calcolata dalla fine.
Delete[list,{i, j, ... }]					Elimina l'elemento nella posizione {i,j,...}
Delete[list,{i1,i2,.....},{j1,j2,.....}]			Elimina gli elementi nella posizioni {i1,j1,...},{i2,j2,...},...
ReplacePart[list, elem, i]				Sostitusce l'elemento nella posizione i con elem.
ReplacePart[list, elem,{i, j, ... }]			Sostitusce l'elemento nella posizione  {i,j,...} con elem.
ReplacePart[list, elem,{{i1, j1, ..},{i2, j2, .. },.}]	Sostitusce gli elementi nella posizioni  {i1,j1,...},{i2,j2,...},... con elem.
Illustriamo l'uso di queste funzioni con esempi.

Example 6.3
Si consideri la lista {a, {a, b, a}, b, {{a, b},c},d}. In questa lista
(a) aggingere x all'inizio
(b) cancellare d
(c) cancellare c
(d) inserire y nelle posizioni {2}, {2,2}, e {4,1,2}
(e) rimpiazzare a con z

ourlist  =  {a,  {a,  b,  a},  b,  {{a,  b},  c},  
        d}

Prepend[ourlist,  x]

Delete[ourlist,  5]

Delete[ourlist,  {4,  2}]

Insert[ourlist,  y,  {{2},  {2,  2},  {4,  1,  2}}]

ReplacePart[ourlist,  z,  Position[ourlist,  a]]

ourlist  /.  a  ->  z

Clear[ourlist]

▲▲▲

8.5 Riorganizzazione di Liste

Alcune funzioni riorganizzano le liste
Sort[list]					Ordina gli elementi di list in modo canonico. 
Union[list]					Ordina lgli elementi di list eliminando i duplicati.
Reverse[list]					Inverte l'ordine degli elementi di list.
RotateLeft[list]				Ruota ciascun elemento di un posto a sinistra .
RotateLeft[list,n]				Ruota ciascun elemento di n posti a sinistra .
RotateRight[list]				Ruota ciascun elemento di un posto a destra .
RotateRight[list,n]				Ruota ciascun elemento di n posti a destra 
Permutations[list]				Genera una lista di tutte le possibili permutazioni degli elementi in list.

Sort[{abd,  abc,  ab,  a,  d,  10,  a,  10,  5.5, 1/4,  
        23/2,  ada}]

Union[{abd,  abc,  ab,  a,  d,  10,  a,  10,  5.5, 1/4,  
        23/2,  ada}]

RotateLeft[Range[10]]

RotateRight[Range[10], 3]

Permutations[{a,  b,  c}]

8.6 Ristrutturazione di Liste

Alcune funzioni modificano la struttura delle liste:
Partition[list,n]				Divide list in sottoliste di lunghezza n che non hanno elementi in comune.
Partition[list, n, d]				Genara sottoliste di lunghezza n spostandosi di d posti.
Transpose[list]				Scambia i primi due livelli in list.
Flatten[list]					Appiattisce list (Elimina tutti i sottolivelli)
Flatten[list,n]					Appiattisce il livello n in list
FlattenAt[list, {i,j,....}]			Appiattisce il livello{i,j,..} in list
FlattenAt[list,{{i1,j1,...},{i2, j2,...},....}]	Appiattisce i livelli {i1,j1,..},{i2,j2,..}...  in list.

Esempio 8.6.1

Si consideri la lista {a, b, c, d, e}
(a) Dividi la lista in sottoliste di due elementi.
(b) Forma la sottolista di due elementi con un offset di uno.

Partition[{a,  b,  c,  d,  e},  2]

Partition[{a,  b,  c,  d,  e},  2,  1]

Esempio 8.6.2

(a) Dare alla lista {a, {b, c}, d, {a, {b, {c, {e, f}}}}} un nome.
(b) Appiattire la lista.
(c) Appiattire la lista 2.
(d) Appiattire la lista {4,2,2,2}.

demolist  =  {a,  {b,  c},  
        d,  {a,  {b,  {c,  {e,  f}}}}}

Flatten[demolist]

FlattenAt[demolist,  2]

FlattenAt[demolist,  {4,  2,  2,  2}]

▲▲▲

8.7 Combinazione di Liste

Funzioni incorporate in Mathematica che combinano liste :
Join[list1, list2,....]				La lista formata dall'unione list1 e e list2
Union[list1, list2,...]				Ordina la lista formata dall'unione di list1,list2,... eliminando i duplicati.
Intersection[list1, list2,...]			La lista ordinata degli elementi comuni a list1,list2,...
Complement[listall, list1, list2,...]		Da gli lementi in listall which che non sono comtenuti in list1,list2,...

Example 8.7.1

Nominare le liste {1,2,3}, {2,3,4,5} e {1,2,3,4,5,6,7,8} listA, listB e listC rispettivamente. Calcolare:
(a) Join[listA,listB]
(b) Union[ListA, listB]
(c) Intersection[listA, listB]
(d) Complement[listC, listA, listB]

listA  =  Range[3]

listB  =  Range[2,  5]

listC  =  Range[8]

Join[listA,  listB]

Union[listA,  listB]

Intersection[listA,  listB]

Complement[listC,  listA,  listB]

Clear[listA,  listB,  listC]

▲▲▲

8.8 Funzioni che operano su Liste

Molte delle funnzioni incorporate in Mathematica operano separatamente su ciascun elemento di una lista. Tali funzioni hanno l'attributo Listable.Non tulle le funzioni incorporate hanno questo attributo. Per esempio la funzione Print  non ha l'attributo Listable.

Table[x^n,  {n,  4}]

D[%,  x]

Sin[{a,  b,  c}]

Sqrt[{3,  4,  6,  8}]

Print[{a,  b,  c}]

{Print[a],  Print[b],  Print[c]}

Le funnzioni definite dall'utente sono, in generale, non Listable,a meno che non venga esplicitamente assegnato tale attributo con la funzione SetAttribtes[fun,attribute]. Per applicare una funzione non Listable a ciascuno elemento di una lista bisogna usare le seguenti  funzioni 
Map[f,list]				Applica f a ciascun  elemento di  list.
Map[f,list,n]				Applica f all'elemento n di  list.
Map[f,list,{{n1},{n2},...}]		Applica f agli elementi di  list nelle posizioni {n1},{n2},...

g[x_]  :=  2

g[{a,  b,  c}]

Clear[g]

Map[f,  {a,  b,  c}]

f  /@  {a,  b,  c}

MapAt[f,  {a,  b,  c,  {d,  e}},  {{1}, {4,  1}}]

Per passare gli elementi di una lista come argomenti di una funzione bisogna usare la funzione:
Apply[f,{a,b,c,... }] o f@@{a,b,c,..}		f[{a,b,c}]

Plus  @@  {a,  b,  c,  d}

8.9 L'uso delle liste nei calcoli.

Illustriamo ora, con qualche esempio, l'uso delle Liste nei calcoli

Esempio 8.9.1

Si consideri l'equazione differenziale
							((d x)/(d t))+ x = (e^(4 t))
con x(0)=1.
(a) Determinare x(t) numericamente per 0≤ t ≤ 0.5.
(b) Determinare x(t) analiticamente
(c) Confrontare la soluzione numerica e quella analitica per 0≤ t ≤ 0.5 incrementando t di 0.1

NDSolve[{x'[t]  +  x[t]  ==  Exp[4 t],  x[0]  ==  1},  
      x,  {t,  0,  0.5}]

numsol  =  x  /.  %[[1]]

DSolve[{x'[t]  +  x[t]  ==  Exp[4 t],  x[0]  ==  1},  
      x[t],  t]

ansol[t_]  =  x[t]  /.  %[[1]]

tt = 
      Table[{t,  numsol[t],  ansol[t]},  {t,  0,  0.5,  
          0.1}]

Print["t\t\tnumerical\tanalytical\n"];
Print[TableForm[tt]]

Clear[numsol,  ansol, tt]

Esempio 8.9.2

Il Pendolo piano consiste in una particella di massa m costretta a muoversi, tramite un'asta rigida e senza massa, su una circonferenza verticake di raggio L. L'equazione del moto è
						(((d^2)u)/(d (t^2))) + (ω^2)sin(θ) = 0          (ω^2) = \(TraditionalForm\`g\/\(\(L\)\(
\)
        \)\) 
dove θ è l'angolo che l'asta forma con la verticale e g è l'accelerazione di gravità. Se il tempo viene espresso in unità di  (1/ω), l'equazione del moto diventa
						(((d^2)u)/(d (t^2))) + sin(u) = 0
Sia θ(0)=π/15 and θ'(0)=0. Disegna le posizioni della particella ter  0 ≤ t ≤ π in incrementando t di π/8.

NDSolve[{u''[t] + Sin[u[t]] == 0, 
        u[0] == Pi/15,  u'[0]  ==  0},  
      u,  {t,  0,  Pi}]

u  =  u  /.  First[%]

aa = 
      N[Table[{Sin[u[t]],  -Cos[u[t]]},  {t,  0,  Pi,  Pi/8}],  
        3]

\(\(ListPlot[aa, \ 
        AspectRatio\  -> \ 
          1, 
\ \ \ \ \ \ \ \ \ \ 		\ \ \ \ \ \ \ \ \ \ \ \ \ PlotStyle\  -> \ PointSize[
            0.05], 
\ \ \ \ \ \ \ \ \ \ 		\ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange\  -> \ {{\(-0.5\), \ 
              0.5}, {0, \ \(-1.1\)}}, 
\ \ \ \ \ \ \ \ \ \ 		\ \ \ \ \ \ \ \ \ \ \ \ \ AxesLabel\  -> \ {" x (L)", \ " y (L)"}
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ];\)\)

Clear[u]

8.10 Esercizi

1. Creare la lista {x - 1, (x^3) - 1, (x^5) - 1, (x^7) - 1, (x^9) - 1, (x^11) - 1} con la funzione Table. Con la funzione Drop ottenere la lista senza il secondo ed il terzo elemento.

2. Determinare la lunghezza e le dimensioni della lista  {{{3,4,5},{4,5,6}},{{4,5,6},{5,6,7}}}

Clear[p]
p = {{{3, 4, 5}, {4, 5, 6}}, {{4, 5, 6}, {5, 6, 7}}};
Length[p]
Dimensions[p]

3. Data la lista  {r,{s,t},{w,{x,{y,z}}}} estrarre gli alementi (a) r, (b) {s,t}, (c) w, (d) {y,z} (e) z

p = {r, {s, t}, {w, {x, {y, z}}}};
p[[1]]
p[[2]]
p[[3, 1]]
p[[3, 2, 2]]
p[[3, 2, 2, 2]]

4. Data la lista  {a,{b,c},a,{d,{e,{f,{a,c,g}}}}} (a) flatten out la list (b) flatten out le sottoliste {b,c} e {a,c,g}

Clear[p]
p = {a, {b, c}, a, {d, {e, {f, {a, c, g}}}}};
FlattenAt[p, {{2}, {4, 2, 2, 2}}]

5. La funzione f è definita da
					f(x) = (sin^2)(x)
     applica f agli elementi della lista {a,{b,c},a,{d,{e,{f,{a,c,g}}}}}

\(\(\(MapAt[Sin[#]\^2 &, {a, {b, c}, a, {d, {e, {f, {a, c, g}}}}}, 
      Position[p, a]]\)\(
\)
    \)\)

6. Determinare il valor medio dei quadrati dei primi otto interi pari

<< Statistics`DescriptiveStatistics`

Mean[Table[(((2  k))^2), {k, 8}]]

7. (a)  Creare una lista dei cubi dei primi quattro interi.
    (b)  Ripetere per i successivi quattro interi.
    (c)  Unire le due liste e chiamare mylist la nuova lista.
    (d)  Trovare il valor medio degli elementi di mylist.
    (e)  Creare una nuova lista in cui ciascun elemento è il quadrato della differenza tra i corrispondenti elementi
           e la media degli elementi in mylist.

<< Statistics`DescriptiveStatistics`

Clear[mylist, fm]
Table[(k^3), {k, 4}]
Table[(k^3), {k, 5, 8}]
mylist = Join[%%, %]
fm = Mean[mylist]
(((mylist - fm))^2)