Laboratorio di Fisica Computazionale
Capitolo 6. Liste

6.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]

6.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[n]}
Array[a,{n1,n2,....}]		crea una lista  n1×n2×n3... , 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]			dà il numero di elementi in list
Dimensions[list]		dà la 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]

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

Dimensions[t]

Length[t]

TableForm[t]

Clear[c, t]

6.3 Estrazione di elementi da una lista

6.3.1 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'elemento 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,{n1,n2}]				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,{n1,n2}]				la sottolista ottenuta da list eliminando gli elementi n1,n1+1,....,n2 di list
Extract[list,{n1,n2,.....}]			l'elemento list[[n1,n2,...]]
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 6.3.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.3.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]

6.3.2 Le funzioni che abbiamo esaminato estraggono elementi in base alla loro posizione in list.Per ottenere la posizione di un elemento in list si può usare la fuzione:
Position[list,elem] 				dà 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 funzioni logiche. Una funzione logica è una funzione che dà 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 UpperCase	VectorQ	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]

6.4 Cambiamento di elementi di Liste e Sottoliste

6.4.1 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.

Esempio 6.4.1
Si consideri la lista {a, {a, b, a}, b, {{a, b},c},d}. In questa lista
(a) aggiungere 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]

6.5 Riorganizzazione di Liste

6.5.1 Alcune funzioni riorganizzano le liste
Sort[list]				Ordina gli elementi di list in modo canonico. 
Union[list]				Ordina gli 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}]

6.6 Ristrutturazione di Liste

6.6.1 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]			Genera 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 6.6.1

Considera 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 6.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}]

6.7 Combinazione di Liste

6.7.1 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,...]	Dà gli elementi in listall che non sono contenuti in list1,list2,...

Esempio 6.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]

6.8 Funzioni che operano su Liste

6.8.1 Molte delle funzioni incorporate in Mathematica operano separatamente su ciascun elemento di una lista. Tali funzioni hanno l'attributo Listable. Non tutte 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]}

6.8.2 Le funzioni definite dall'utente sono, in generale, non Listable a meno che non venga esplicitamente assegnato tale attributo con la funzione SetAttributes[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,level]		Applica f agli elementi del livello level di  list. (vedi Level Specification nell'Help)
MapAt[f,list,n]			Applica f all'elemento n di  list.
MapAt[f,list,{{n1},{n2},...}]	Applica f agli elementi di  list nelle posizioni {n1},{n2},...
MapAll[f,list]	( //@ )		Applica f a tutti i livelli di list.

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}}]

MapAll[f,  {a,  b,  c,  {d,  e}}]

6.8.3 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,..}	equivale a f[a,b,c,..]

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

Apply[f, {a, b, c, d}]

6.9 L'uso delle liste nei calcoli.

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

Esempio 6.9.1
La variazione di entropia fra due stati a e b di un sistema è data da

						(Subscript[S, b])- (Subscript[S, a])= (∫_a^b)d(Q/T)
dove T è la temperatura assoluta e dQ è la quantità di calore infinitesima che viene trasferita o rilasciata dal sistema. L'integrale è valutato su un qualsiasi cammino reversibileche connette i due stati. Per un processo a pressione costante mentre la temperatura varia da (Subscript[T, a])a (Subscript[T, b]), l'equazione può essere riscritta nella forma
						(Subscript[S, b])- (Subscript[S, a])= \(TraditionalForm\`∫\_\(T\_a\)\%\(T\_b\)\(\(\(C\_p\)(T)\) dT\)\/T\)
dove (Subscript[C, p])(T) è la capacità termica a pressione costante del sistema. 
I seguenti dati sono stati ottenuti dal sulfuro rombico:
					T(K)	        (Subscript[C, p])(cal/K)        T(K)	          (Subscript[C, p])(cal/K)
					
					({{15, 0.311`, 160, 4.123`}, {20, 0.605`, 170, 4.269`}, {25, 0.858`, 180, 4.404`}, {30, 1.075`, 190, 4.526`}, {40, 1.452`, 200, 4.639`}, {50, 1.772`, 210, 4.743`}, {60, 2.084`, 220, 4.841`}, {70, 2.352`, 230, 4.927`}, {80, 2.604`, 240, 5.01`}, {90, 2.838`, 250, 5.083`}, {100, 3.06`, 260, 5.154`}, {110, 3.254`, 270, 5.22`}, {120, 3.445`, 280, 5.286`}, {130, 3.624`, 290, 5.35`}, {140, 3.795`, 298.1`, 5.401`}, {150, 3.964`, " ", " "}})
					
 \(Determinare\ la\ variazione\ di\ entropia\ e\ riportare\ in\ un\ grafico\ C\_p\ in\ funzione\ di\ T\ usando\ la\ regola\ \(\(trapezoidale\)\(.\)\)\)

Clear[t, cp, n]
\(\(t\  = \ {15, \ 20, \ 25, \ 30, \ 40, \ 50, \ 60, \ 70, \ 80, \ 90, \ 
          100, \ 110, 
\ \ \ \ \ \ \ \ \ \ \ 120, \ 130, \ 140, \ 150, \ 
          160, \ 170, \ 180, \ 190, \ 200, \ 
          210, 
\ \ \ \ \ \ \ \ \ \ \ 220, \ 230, \ 240, \ 250, \ 260, \ 
          270, \ 280, \ 290, \ 298.1};\)\)
\(\ \(cp\  = \ {0.311, \ 0.605, \ 0.858, \ 1.075, \ 1.452, \ 
          1.772, 
\ \ \ \ \ 	\ \ \ \ \ \ 2.084, \ 2.352, \ 2.604, \ 
          2.838, \ 3.060, \ 3.254, 
\ \ \ \ \ 	\ \ \ \ \ \ 3.445, \ 
          3.624, \ 3.795, \ 3.964, \ 4.123, \ 
          4.269, 
\ \ \ \ \ 	\ \ \ \ \ \ 4.404, \ 4.526, \ 4.639, \ 
          4.743, \ 4.841, \ 4.927, 
\ \ \ \ \ 	\ \ \ \ \ \ 5.010, \ 
          5.083, \ 5.154, \ 5.220, \ 5.286, \ 
          5.350, 
\ \ \ \ \ 	\ \ \ \ \ \ 5.401};\)\)
  n = Length[t] - 1;
(∑_(i = 1)^n)(cp[[i + 1]]/t[[i + 1]] + 
            cp[[i]]/t[[i]]) ((t[[i + 1]] - t[[i]])/2)

Transpose[{t,  cp}];
\(\(ListPlot[%, \ 
        PlotStyle\  -> \ 
          PointSize[
            0.015], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ AxesLabel\  -> \ {" T (K)", \ " Cp (cal/K)"}];\)\)
Clear[t,  cp, n]

Esempio 6.9.2
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 6.9.3
Il Pendolo piano consiste in una particella di massa m costretta a muoversi, tramite un'asta rigida e senza massa, su una circonferenza verticale 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 per  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]

Esempio 6.9.4
Dimostrare che
(a)		[(Overscript[A,  ->]) ×((Overscript[B,  ->]) ×(Overscript[C,  ->]) )] + [(Overscript[B,  ->]) ×((Overscript[C,  ->]) ×(Overscript[A,  ->]) )] + [(Overscript[C,  ->]) ×((Overscript[A,  ->]) ×(Overscript[B,  ->]) )] =0
(b)		(Overscript[∇,  ->]) .(f (Overscript[A,  ->]) ) = f((Overscript[∇,  ->]) .(Overscript[A,  ->]) ) + (Overscript[A,  ->]) .((Overscript[∇,  ->]) f)
(c)		(Overscript[∇,  ->]) ×((Overscript[∇,  ->]) ×(Overscript[A,  ->]) ) = (Overscript[∇,  ->]) ((Overscript[∇,  ->]) .(Overscript[A,  ->]) ) +(Overscript[ (∇^2), ->])(Overscript[A,  ->])

Needs["Calculus`VectorAnalysis`"]

CoordinateSystem

Coordinates[ ]

SetCoordinates[Cartesian[x,  y,  z]]

Coordinates[ ]

a  =  {ax[x,  y,  z],  ay[x,  y,  z],  
          az[x,  y,  z]};
b  =  {bx[x,  y,  z],  by[x,  y,  z],  
          bz[x,  y,  z]};
c  =  {cx[x,  y,  z],  cy[x,  y,  z],  
          cz[x,  y,  z]};
f  =  func[x,  y,  z];

\(CrossProduct[a, \ CrossProduct[b, \ c]]\  + 

      CrossProduct[b, \ CrossProduct[c, \ a]]\  + 

      CrossProduct[c, \ CrossProduct[a, \ b]]\)

(Div[f a]  -  f Div[a]  -  DotProduct[a,  Grad[f]]) // 
      Simplify

Curl[Curl[a]]  -  Grad[Div[a]]  +  Laplacian  /@  a

Clear[a,  b,  c,  f]

Esempio 6.9.5
Una sfera conduttrice scarica di raggio a è posta in un campo elettrico inizialmente uniforme (Subscript[E, 0])allineato nella direzione z.
(a) Mostrare che il potenziale all'esterno della sfera è
							V(r,θ) = -(Subscript[E, 0])(r - ((a^3)/(r^2))) cos(θ)
     dove r è la distanza dall'origine posta al centro della sfera e θ è l'angolo polare, cioè l'angolo con l'asse z.  ((∇^2)V =0).
(b) Determinare il campo elettrico all'esterno della sfera.  ((Overscript[E,  ->]) =-(Overscript[∇,  ->]) V)
(c) Trovare la densità di carica indotta sulla superfice della sfera e verificare che la carica totale sulla sfera è nulla.
     (σ = (Subscript[ϵ, 0]) (Subscript[E, r])(a).

Needs["Calculus`VectorAnalysis`"]

SetCoordinates[Spherical];

Coordinates[]

SetCoordinates[Spherical[r,  theta,  phi]]

Clear[a, v,  E0, n, EE]

v[r_, theta_, 
        phi_]  =  - E0 (1  -  (a/r)^3) r Cos[
          theta]

Laplacian[v[r, theta, phi]]  // Simplify

v[a, theta, phi]

Normal[
      Series[v[r, theta, phi], {r, ∞, 1}]]

EE[r_, theta_, phi_] = -Grad[v[r, theta, phi]]  //  
        Simplify

n = {Sin[theta] Cos[phi], Sin[theta] Sin[phi], Cos[theta]}

a^2 Integrate[(Subscript[ϵ, 0]) EE[a, theta, phi] . 
            n ,  {theta,  0,  Pi}, {phi, 0, 2  Pi}]

Clear[v]

6.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 elementi (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)
     a) applica f agli elementi della lista {a,{b,c},a,{d,{e,{f,{a,c,g}}}}}
     b) applica f agli elementi a della lista {a,{b,c},a,{d,{e,{f,{a,c,g}}}}}

p = {a, {b, c}, a, {d, {e, {f, {a, c, g}}}}}
Sin[p]^2
Map[Sin, p]^2
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)

Appendice A : Operazioni tra vettori con Mathematica.

In Mathematica un vettore è rappresentato da una lista di elementi che non sono, a loro volta, delle liste.
      Le operazioni tra vettori sono già incorporate in Mathematica.
      Plus[vec1,vec2] o vec1+ vec2		esegue la somma di vec1 e vec2
      Plus[vec1,-vec2] o vec1- vec2		esegue la differenza tra vec1 e vec2
      Times[m,vec] o m vec			esegue il prodotto dello scalare m per il vettore vec
      Dot[vec1,vec2] o vec1.vec2			esegue il prodotto scalare tra vec1 e vec2
      Cross[vec1,vec2] o vec1×vec2		esegue il prodotto vettoriale tra vec1 e vec2
      VectorQ[expr]				restituisce True se expr è un vettore

Vediamo ora degli esempi:

Unprotect[O, C];
O = {0, 0, 0}; i = {1, 0, 0}; j = {0, 1, 0}; k = {0, 0, 1}; 
    A = {1, 2, 3}; B = {-1, 2, 5}; m = 2.5;

MatrixForm[{{i . i, i . j, i . k}, {j . i, j . j, j . k}, {k . i, 
          k . j, k . k}}]

\(MatrixForm[{{i\[Cross]i, i\[Cross]j, i\[Cross]k}, {j\[Cross]i, 
            j\[Cross]j, j\[Cross]k}, {k\[Cross]i, k\[Cross]j, 
            k\[Cross]k}}] /. {O -> \*""(Overscript[0,  ->]) "", 
        i -> \*""(Overscript[i,  ->]) "", 
        j -> \*""(Overscript[j,  ->]) "", 
        k -> \*""(Overscript[k,  ->]) "", \(-i\) -> \*""(Overscript[(-i),  ->]) "", \(-j\) -> \*""(Overscript[(-j),  ->]) "", \(-k\) -> \*""-(Overscript[k,  ->]) ""}\)

{A . i, A . j, A . k}

A + B

A - B

m A

A . B

C = A\[Cross]B

Show[
        Graphics3D[{Line[{O, 3  i}], Text["i", i, {+1, -1}], 
            Text["O", O, {+1, -1}], Line[{O, 3  j}], 
            Text["j", j, {+1, -1}], Line[{O, 3  k}], 
            Text["k", k, {+1, -1}], Line[{O, A}], 
            Text["A", A, {+1, -1}], Line[{O, {A . i, A . j, 0}}], 
            Line[{A, {A . i, A . j, 0}}]}], 
        Boxed -> False];

Show[
        Graphics3D[{Line[{O, A}], Text["A", A, {+1, -1}], 
            Text["O", O, {+1, -1}], Line[{O, B}], 
            Text["B", B, {-1, +1}], Line[{O, C}], 
            Text["C", C, {+1, -1}]}, 
          ViewPoint -> {-0.625,  -3.233,  0.779}], 
        Boxed -> False];

Clear[A, B, C, O, i, j, k, m];

A.1 Esercizi.

Esercizio 1

Provare che		[(Overscript[A,  ->]) ×((Overscript[B,  ->]) ×(Overscript[C,  ->]) )] + [(Overscript[B,  ->]) ×((Overscript[C,  ->]) ×(Overscript[A,  ->]) )] + [(Overscript[C,  ->]) ×((Overscript[A,  ->]) ×(Overscript[B,  ->]) )] =0

Unprotect[C];
A = {Ax, Ay, Az};
B = {Bx, By, Bz};
C = {Cx, Cy, Cz};
Zero = {0, 0, 0};
A\[Cross](B\[Cross]C) + B\[Cross](C\[Cross]A) + 
        C\[Cross](A\[Cross]B) == Zero
Clear[A, B, C];

Esercizio 2

\(Si\ studi\ il\ moto\ di\ un\ proiettile\  . 
\((n . b .  : \ 
                in\ tal\ caso\ la\ forza\ è\ verticale\ ed\ il\ moto\ avviene\ in\ un\ piano\ verticale . \ 
                    Se\ si\ assume\ un\ sistema\ cartesiano
con\ l' 
                  asse\ y\ verticale\ orientato\ verso\ l' alto\ e\ l' 
                  asse\ x\ orizzontale\ risulta\ \ 
					F\_x = \(0\ \ 

              					F\_y = \(-m\)\ g\), \ 

            dove\ g\  = 
              9.8\ m/s\^2  è\ l' 
                accelerazione\ di\ gravità)\)\)

Clear[x, y]
{x[t_, v0_, θ_], 
        y[t_, v0_, θ_]} = {x[t], 
          y[t]} /. DSolve[{x''[t] == 
                0, y''[t] == -g, x[0] == 0, 
              y[0] == 0, x'[0] == v0 Cos[θ], y'[0] == 
                v0 Sin[θ]}, {x[t], y[t]}, t][[1]]
tt = Solve[y[t, v0, θ] == 0, t]

xg = x[t, v0, θ] /. tt[[2]] // FullSimplify

g = 9.8; v0 = 1; θ = π/3;
ParametricPlot[{x[t, v0, θ], y[t, v0, θ]}, {t, 0, 
          t /. tt[[2]]}, PlotRange -> All, 
        PlotPoints -> 100];
Clear[g, v0, θ]