F. Fasso`.    Universita` di Padova.    Laurea di I livello in Matematica.    Notebook per il MiniCorso su Mathematica, settembre 2007.

Fine argomenti lezione precedente

Grafica (primo sguardo)     (vale per Mathematica 3-5, non per Mathematica 6)

Grafici 3-dimensionali

1.Grafici di funzioni   f : (R^2) -> R

Plot3D[ f(x,y), {x,x1,x2}, {y,y1,y2} ]

Esercizio: grafico di   sin((x^2) + (y^2))  in  -π<x<π, -π < y < π

Plot3D[
        Sin[(x^2) +  (y^2)], {x, -Pi, Pi}, {y, -Pi, Pi}];

Per infittire la griglia:

Plot3D[Sin[(x^2) +  (y^2)],{x, -Pi, Pi},{y, -Pi, Pi},  PlotPoints -> 50];

Plot3D[Sin[(x^2) +  (y^2)],{x, -Pi, Pi},{y, -Pi, Pi},  PlotPoints -> 80];

Per togliere la griglia:

Plot3D[Sin[(x^2) +  (y^2)],{x, -Pi, Pi},{y, -Pi, Pi},  PlotPoints -> 80, Mesh -> False];

2. Grafici di curve parametrizzate:  t ->(x(t),y(t),z(t))

ParametricPlot3D[{x(t),y(t),z(t)}, {t,tmin,tmax}]

Esercizio :  
      Disegnare l' arco dell' elica
    t -> (Sin (t),  Cost (t), (t/3))   compreso fra t=0 e t = 15

3. Grafici di superfici parametrizzate:    (u,v) ->  {x(u,v),y(u,v),z(u,v)}

ParametricPlot3D[ {x(u,v),y(u,v),z(u,v)}, {u,u1,u2} , {v,v1,v2} ]

Esercizio: disegnare un toro  (ciambella) e una sfera

Suggerimento: il toro ha la parametrizzazione  
                 x(t,u) = (3+Cos(u)) Cos(t),       y(t,u) = (3+Cos(u)) Sin(t),          z(t,u)=Sin(u)  ,
                 0<t<2π ,     0<u<2π 
mentre la parametrizzazione della sfera con coordinate sferiche e` 
                    x(ϕ,θ) = sin θ cos ϕ  ,      y(ϕ,θ) = sin θ sin ϕ ,        z(ϕ,θ) = cos θ    ,   
                     0<ϕ<2π ,     0<θ<π

Animazioni

Mathematica non e` tanto efficiente nelle animazioni, ma le fa. 
• Bisogna creare una sequenza di immagini
• e poi animarle

Esempio: un'onda viaggiante

1. Creare tanti "fotogrammi" di un "bump" centrato nel punto  a , per esempio
                              Sech(x-a)
    al variare  di  a  in un intervallo  (x1,x2)
    Si puo` fare con un    
    Do[ crea figura centrata in a, {a, ain, afin, incremento}]

2. Selezionare tutte le figure, chiudere le celle, e premere   CTRL Y   (in Windows)
                                                                                                ALT Y     (in Linux)
     oppure "Animate Selected Graphics" dal menu` Cell .

Si puo` anche colorare, etc (ma nascondo i comandi - vedrete poi come fare)

<< Graphics`FilledPlot` ;
\(Do[\ \ \ \ \ \ \ FilledPlot[{1, Sech[x - n], 0}, {x, \(-2\) Pi, 
          2  Pi}, \ \ 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ AspectRatio ->  .2, ImageSize -> {600, 200}, 
        PlotRange -> {0, 1}], 
\ \ \ \ \ {n, \(-5\), 
        5,  .2}]\)

Algebra Lineare (e, con l'occasione, uno sguardo alle liste)

Liste

In Mathematica, vettori, matrici, etc sono liste
Si delimitano con (diversi livelli di) parentesi graffe

Questo e` un vettore con due componenti

u={u1, u2};

e queste le sue componenti

u[[1]]

u[[2]]

(attenzione alle doppie parentesi quadre: u[1] e` il valore in x=1 della funzione u(x) )

Questa una matrice simmetrica 2x2

M={{3  x, x - 3  (x^2)},{x - 3  (x^2), 2  x}}

e le  sue componenti si ottengono cosi`:

M[[1, 1]]

M[[1]]

Per vederla in forma di tabella:

M2=M//MatrixForm

Una matrice e` una lista di vettori --- le sue righe. 
Anche un vettore e` una lista delle sue righe

u//MatrixForm

(Questo suggerisce che sia una lista di due elementi sia trattata da Mathematica come un `vettore colonna', laddove questo e` importnate, cioe` nel prodott o matriciale)

Se gli elementi di una lista sono, a loro volta, liste, si dice che essa ha diversi "livelli".
Esempio:

M

Level[M,{1}]

Level[M,{2}]

Level[u,{1}]

Liste si possono creare anche con il comando  Table[ espressione,  iteratori ]

M1=Table[ n , {n, 5}]

M2=Table[ n1 + n2 , {n1, 1, 3},{n2, -2, 0}]; 
M2 // MatrixForm

Dimensioni di una lista:
-  Length[lista] da` il numero degli elementi
- Dimensions[lista]  da il numero degli elementi della lista e delle sottoliste che la formano (ma funziona solo se, ad ogni livello, le sottoliste hanno la stessa dimensione)

M

Length[M]

Dimensions[M]

Dimensions[{{1, 2},{3}}]

Prodotto "righe per colonne" di matrici (e di liste)

Prodotto righe per colonne: si indica con un punto

{{a, b}, {c, d}} . {x, y}

Attenzione: i vettori
• sembrano scritti come  vettori riga, cioe` matrice 1 x n,
• ma nel prodotto riga per colonna sono in realta` considerati come vettori colonna, cioe` matrici n x 1.
Motivo: le componenti di primo livello di un vettore o matrice sono le sue righe (cioe`, indicizzate con il primo indice ed il prodotto "." contrae l'ultimo indice del primo fattore con il primo indice del secondo fattore)

Regola: α . β   contracts the last index in  α  with the first index in β

Esercizi:
1) fare il prodotto scalare di due vettori u1={x1,y1} ed u2={x2,y2}
2) Definire una matrice 2x2 diciamo M={{a,b},{c,d}}, calcolarne l'inversa con Inverse[matrix], e verificare che il prodotto della matrice e dell'inversa e` la matrice unita`

Esercizi:
1) Come si rappresenta un vettore riga?
2) Come si fa la moltiplicazione a destra di un vettore per una matrice?

Suggerimento:  Vettore colonna = matrice 2 x 1
                        Vettore riga = matrice 1 x 2

Esercizio: Disegnare 2 spirali di Archimede, ruotate di un angolo α l'una rispetto all'altra

Suggerimenti:
• la rotazione si fa con una matrice.
•  ParametricPlot[ {lista di curve}, .....]

Autovalori ed autovettori

Autovalori ed autovettori:  Eigenvalues[matrix],  Eigenvectors[matrix]

M = {{a, b}, {c, d}};

λ=Eigenvalues[M]

λ[[1]]

U=Eigenvectors[M]

U[[1]]

Attenzione: gli autovettori di M  sono le righe della matrice  U=Eigenvector[M]  .   Dunque, la matrice che diagonalizza M e` (U^T)=Tranpose[U].

Esercizio: Controllare che autovalori ed autovettori risolvono l'equazione agli autovalori e che nella base degli autovettori la matrice M e` diagonale 
(NB: il cambio di base si fa con la matrice U:   M -> (U^(-T)) M (U^T) )

M . U[[1]] - λ[[1]] U[[1]]

% // Simplify

Transpose[U // Inverse] . M . Transpose[U]  // Simplify

Ancora sulle liste

Osservazione: Le operazioni con le liste sono onnipresenti in Mathematica.

Esempio:

pl = Plot[Erf[x], {x, 0, 3}];

Cos'e` l'oggetto grafico? Come e` rappresentato da Mathematica?

Per vedere la rappresentazione di un espressione o un oggetto fatta da Mathematica, si usa il comando FullForm[espressione]  
oppure anche InputForm[espressione]

pl // InputForm

pl // Dimensions

pl[[1]]

pl[[2]]

Show[Graphics[pl[[1]]]]

Si capisce che si possono manipolare gli oggetti (grafici, ...) ad un livello molto basso. Questo e` uno dei motivi della versatilita` di Mathematica: si puo` davvero far(gli) fare quel che si vuole.

Etcetera....

Si puo` fare un po' di tutto (fate il Tour di Mathematica, dall'Help)

Programmare

Mathematica e` un linguaggio di programmazione potentissimo e versatilissimo.
Vedremo.

Un esempio: il fattoriale. E` predefinito

Factorial[100]

ma potremmo ridefinirlo (in tanti modi). Per es:

mioFactorial[0] = 1;
mioFactorial[n_] := n  mioFactorial[n - 1]

mioFactorial[10] // Trace

Standard add-on packages

In una sessione di Mathematica si possono eseguire ed utilizzare programmi gia` scritti. 
• Per esempio, si puo` eseguire un altro Notebook : tutto il suo contenuto viene cosi` caricato nel Kernel
• Il modo buono di creare programmi da chiamare da altre sessioni e` quello di crearli come packages

Per importare un package in una sessione di Mathematica si usa il comando
    << package
oppure
    Needs["package"]

Esempio: abbiamo gia` incontrato alcuni packages, come 
<<Graphics`ImplicitPlot`

Mathematica viene distribuita con un certo numero di packages che sono chiamati Standard Add-on Packages e sono documentati (non bene, purtroppo) nella documentazione. 
• C'e` un manuale cartaceo a parte (fino alla versione 4)
• C'e` la sezione  "Add-ons" dell'help. Alcuni comandi dei packages sono anche citati nella sezione "Master Index" (ma non in quella "The Mathematica Book")

Attenzione:      non chiamare un comando del package prima di aver caricato il package 
Rimedio:          Remove[comando]

FilledPlot[Sin[x], {x, 0, 2 Pi}]

<< Graphics`FilledPlot`

FilledPlot[Sin[x], {x, 0, 2 Pi}]

Remove[FilledPlot]

FilledPlot[Sin[x], {x, 0, 2 Pi}]

Definizione di funzioni:      :=       o      =      ?

La possibilita` di definire funzioni e` importantissima.
Non solo perche` permette di definire funzioni matematiche (per esempio dare un nome ad una funzione complicata) ma anche e soprattutto perche` una funzione puo` eseguire una vasta tipologia di azioni e dunque e` utilissima per la programmazione.

Esempio: voglio fare il grafico di una funzione, variandone la risoluzione.
La risoluzione di un plot si determina con l'opzione        PlotPoints->....

f[ris_]:=Plot3D[Sin[(x^2) + (y^2)]/(x + 2  Pi),{x, -Pi, Pi},{y, -Pi, Pi},PlotPoints->ris]

f[20]

f[40]

f[80]

Ci sono due modi di definire una funzione:
•  =  "Set"
• :=  "Set Delayed"

Esempio

Clear[f, g, x, y, z]

x = 5;

f[x_, y_]  :=  x + y

g[x_, y_]  =  x + y

f[1, y]

g[1, y]

Clear[x]

f[x, y]

g[x, y]

Motivo: 
• se si usa "Set", l'espressione a dell'uguale destra viene calcolata subito, PRIMA dell'assegnazione del suo valore ad f[x] 
• se si usa "Set Delayed", l'espressione a destra dell'uguale non viene calcolata subito - sara` calcolata ogni volta che la funzione e` chiamata.
   (E` per questo che Set Delayed non produce Output)
Infatti:

?f

?g

Conclusione: Per definire una funzione  x -> f(x)  usare     :=    (a meno che sappiate quel che fate! Vedere un esempio, sotto)

Esercizio: voglio definire un numero casuale. La funzione che crea numeri casuali e`   Random[ ] .  Che differenza c'e` fra
  x = Random[]
  x := Random[]
?

x := Random[]

x + x // Trace

x1 = Random[]

x1

x1

x2 := Random[]

x2

x2

Domanda: di solito, per assegnare un valore ad un simbolo, si usa   =
E` giusto?

x = 1;
y = 2;

z = x + y

z2 := x + y

z2

Adesso cambio il valore di x ed y. Chi se ne accorge, z o z2?

x = xnew; y = ynew;

z

z2

(insomma: dipende da quel che si vuol fare)

Esercizio: Confrontare il tempo che Mathematica impiega a creare il grafico delle due seguenti funzioni:
•   test1[x_] :=  Expand[(((1 + Sin[x]))^100)]
•   test2[x_]  =  Expand[(((1 + Sin[x]))^100)]
Spiegare il risultato.

tt1[x_] := Expand[(((1 + Sin[x]))^100)]

Clear[x];         
tt2[x_] = 
        Expand[(((1 + Sin[x]))^100)];

Plot[tt1[x], {x, 0, 2  Pi}] // Timing

Plot[tt2[x], {x, 0, 2  Pi}] // Timing

Spiegazione:  la prima sostituisce ad x un valore numerico e poi fa somme e potenza, la seconda invece prima espande la potenza simbolica, poi sostituisce dentro a questa espressione il valore numerico: e` molto piu` lento.

2. Grafica
(Generalita` sulla grafica)

La grafica e` forse uno dei pochi aspetti di Mathematica che richieda una breve trattazione sistematica. 
Il motivo e` che esistono parecchi "tipi" di grafica, con molti comandi, e la cosa puo` apparire alquanto disorganica.
In realta`, e` sufficiente capire, almeno a grandi linee, alcuni concetti base.

Per questo, prima di imparare come si fa un grafico rosso invece che nero, bisogna capire alcune cose:
• Cos'e` un oggetto grafico?
• Cos'e` un "tipo" di grafica? 
• Come si produce un oggetto grafico?
• Come si mostra sullo schermo un oggetto grafico?

In Mathematica, ogni oggetto e` un'espressione (esaminabile con InputForm[])
Diversi oggetti hanno diversa Head

Head[ 5 ]

Head[ a ]

Head[ 1.21 ]

Head[  "ciao"  ]

Head[  Plot[x, {x, 0, 1}]  ]

Head[  Plot3D[(x^3) (y^3) Sin[y  + x],{x, -2, 1},{y, -1, 1},PlotRange -> All ]]

Il "tipo" della grafica e` indicato dalla sua Head.

Ci sono diversi "tipi" (cioe` Heads) di grafica, usati per diversi scopi, e prodotti da diversi programmi:
2-dimensionale:
     Graphics		      general two-dimensional graphics		(Plot, ListPlot, ImplicitPlot)
     ContourGraphics	      density plots				(ContourPlot)
     DensityGraphics	      density plots				(DensityPlot)
3-dimensionale:
     Graphics3D		      general three-dimensional graphics		(ParametricPlot3D)
     SurfaceGraphics	      three-dimensional surfaces			(Plot3D)
Altro:
     GraphicsArray	      tabella di oggetti grafici

Non serve conoscerli tutti a memoria, bisogna pero` sapere che comandi diversi producono grafici di tipi diversi - e dunque possono dover essere trattati in modi diversi. 
Tuttavia, tutti i tipi di grafica hanno delle proprieta` in comune.

Il comando  Show  "mostra" (displays) un oggetto grafico.
(E` del tutto analogo al comando  Print  )

gr1=Plot[Sin[x], {x, 0, 2  Pi}]

gr1 // InputForm

Show[gr1]

Attenzione: 
Tutti i comandi  Plot, Plot3D, ........, con la sola eccezione di GraphicsArray, 
	• producono l'oggetto grafico (come Output)
	• e lo mostrano sul display  (incorporano cioe` il comando Show)
Invece, per mostrare l'oggetto altre volte serve Show

Con Show si possono anche combinare diversi grafici

gr1bis = Plot[x Log[x], {x, 0, 2}]

Show[gr1, gr1bis]

Gli oggetti grafici sono liste che consistono di

• Graphics Primitives  (Point, Line, Circle, ....)

• Graphics Directives  (Thickness, RGBColour, .....)
Le direttive grafiche specificano le proprieta` delle singole primitive grafiche che formano l'oggetto grafico, quali il colore, lo spessore delle linee, la dimensione dei punti, etc.

• Graphics Options 	 (PlotRange, AspectRatio, AxesOrigin, ....)
Le opzioni grafiche specificano delle proprieta` globali dell'oggetto grafico, quali le sue dimensioni, se e` racchiuso in una cornice, il colore dello sfondo, etc.
Le opzioni grafiche sono come delle routine che creano delle primitive grafiche e che le inseriscono nell'oggetto

gr2 = Plot[(x^2), {x, 0, 1}]

Come e` fatto questo oggetto grafico?

gr2 // InputForm

C'e` una primitiva grafica ("Line") seguita da numerose opzioni: la struttura e`
                Graphics[   Lista di primitive e direttive grafiche,   Lista di opzioni  ]

Possiamo estrarre la primitiva grafica "linea", trasformarla in un oggetto grafico, e mostrarla:

gr2[[1]]

Show[Graphics[%]]

Le opzioni creano e determinano tutti gli altri elementi del grafico (assi, etc):

Options[gr2]

Approfondimento: Come funzionano le opzioni?
Volendo, si puo` anche trasformare l'oggetto grafico in una lista di sole primitive grafiche con certe direttive, incluse quelle create dalle opzioni.  Questo e` fatto dal comando Fullgraphics

FullGraphics[gr2] // InputForm

Show[ Graphics[%]]

NB: Non e` importante saper modificare in questo modo gli oggetti grafici. 
E` pero` importante capire
• come funzionano i comandi che creano e mostrano grafica (Plot, ....., Show)
• la differenza fra Opzioni e Direttive

Opzioni

Si possono specificare le opzioni al momento di creare il grafico:
      Plot[ funzione,   intervallo,    opzione1 -> valore1, opzione2 -> valore2, ...]

gr3=Plot[(x^2),{x, 0, 1},  AspectRatio -> 1,  Background -> GrayLevel[ .7]]

oppure anche senza ricreare il grafico, al momento di "mostrarlo" con Show[ ]

Show[gr2, AspectRatio ->  .4,  Background -> Hue[ .7]]

Show[gr3, AspectRatio ->  .4,  Background -> Hue[ .7]]

Approfondimento: Cosa fa il cambiamento di un'opzione?
Semplicemente, viene cambiato il comando corrispondente all'interno della lista che costituisce l'oggetto grafico:

Show[gr2, AspectRatio ->  .4,  Background -> Hue[ .7]]

l1 = Options[%]

l2 = Options[gr2]

Cosa e` cambiato in l1? 
Ci sono funzioni per il confronto di liste  (Union, Intersection, Complement, ...)

Complement[l1, l2]

Complement[l2, l1]

Primitive grafiche

Quando si crea un grafico con un comando tipo Plot, e` il comando stesso che crea tutte le primitive grafiche necessarie. 
Tuttavia, e` possibile anche crearle direttamente, se serve (per esempio, per aggiungere un elemento ad un grafico), col comando
             Graphics[ Lista di primitive grafiche ]
(per mostrarlo, bisogna poi usare Show)

?Circle

gr4=Graphics[Circle[{1, 1}, 1]]

Show[gr4]

Graphics[Circle[{1, 1}, 1],AspectRatio -> 1]//Show

?Rectangle

gr5=Graphics[  { Circle[{1, 1}, 1], Rectangle[{-1, -1}, {1, 1}]  }]

Show[gr5, AspectRatio -> 1]

Direttive grafiche

Permettono di cambiare proprieta` quali: spessore di curve,diametro di punti,colori, etc

Come si cambiano?
•  A mano, se si ci costruisce il proprio oggetto grafico
•  Con comandi dedicati

Regole generali:   le direttive grafiche
•  Vengono inserite nella lista delle Primitive grafiche
•  Ciascuna vale per tutte le primitive della (sotto)lista che la seguono
(Dunque, non si cambiano da Show)

Graphics[ 
 { Circle[{1, 1}, 1], Hue[ .4], Rectangle[{-1, -1}, {1, 1}]  }
] //Show

Graphics[ 
  { { Hue[ .4],Circle[{1, 1}, 1]}, 
     Rectangle[{-1, -1}, {1, 1}]  }
] //Show

Graphics[ 
 {   Thickness[ .05],Circle[{1, 1}, 1], Hue[ .4], Rectangle[{-1, -1}, {1, 1}]  }    
]  //  Show

Le direttive grafiche si possono anche applicare dai comandi Plot, Plot3D, ... usando opzioni tipo
	PlotStyle -> lista di direttive

Plot[{Sin[x], Cos[x]},{x, 0, 2  Pi}  ,   PlotStyle -> Thickness[ .015]   ]

Plot[{Sin[x], Cos[x]},{x, 0, 2  Pi}  ,  PlotStyle->{Thickness[ .015] , Hue[ .4]}  ]

Plot[{Sin[x], Cos[x]},{x, 0, 2  Pi}  ,   PlotStyle->{ {Thickness[ .01],  Hue[ .95]} , {Thickness[ .05], Hue[ .45]} }]

NB: Le direttive grafiche non si possono cambiare da Show: bisogna ricreare l'oggetto grafico.

Show[gr4]

Show[gr4,PlotStyle -> Hue[ .3]]

Table[{Hue[n/10], Point[n/10]}, {n, 10}]

Graphics[Table[{Hue[n/10], Circle[{n/10, 0},  .1]}, {n, 0, 20}]] // 
      Show

•  Avevamo fatto una lista (anche se non completa) di comandi che creano grafica nella seconda lezione

• Colori

Hue[x] cicla sui colori dell'arcobaleno per  x ∈ R/ mod(1)

col[n_]:=Graphics[{PointSize[ .04], Hue[n/10], Point[{0, n}]}]

Show[  Table[col[n], {n, 0, 19}]   ]

Ci sono altre direttive per specificare i colori, per esempio  RGBColor[r,g,b]

Scale di grigio:   GrayLevel[x]

•  Come combinare grafici?

Alcuni comandi (tipo Plot) possono disegnare piu` grafici allo stesso tempo

Plot[{(E^(-x)) Sin[x], Sinh[x]/x},{x, -Pi, Pi}]

Esercizio: riprodurre il grafico con
▪ diversi colori per le due curve         (PlotStyle -> ....)
▪ formato quadrato                             (AspectRatio -> ....)
▪ una cornice attorno                          (Frame -> True )
▪ un po' piu` piccolo                           (ImageSize-> 200)

Un altro modo di combinare grafici consiste nel
-- creare i diversi oggetti grafici
--  mostrarli insieme con Show

gr11 = Plot[Sin[x], {x, 0, Pi}]

pallino={PointSize[ .2], Hue[ .35], Point[{1.5,  .5}]}

gr12=Graphics[pallino]

Show[gr12]

Show[gr11, gr12]

Show[gr12, gr11]

E` un po' macchinoso, ma funziona

Modo piu` semplice
• Prolog
• Epilog

Plot[(x^2),{x, 0, 2},  Prolog -> pallino]

Plot[(x^2),{x, 0, 2},  Epilog -> pallino]

gr1 = Plot[(x^2), {x, 0, 1}]

gr2 = Plot[Sin[x], {x, 0, 2  Pi}]

GraphicsArray[{gr1, gr2}] // Show

GraphicsArray[{gr1,Plot[Sin[x], {x, 0, 2  Pi}]}]//Show

•  Come sopprimere il display di un grafico?

gr13=Plot[Sin[x],{x, 0, 1},   DisplayFunction -> Identity  ]

Show[gr13]

Show[gr13, DisplayFunction -> $DisplayFunction  ]

Show[gr13, ImageSize -> 100,DisplayFunction -> $DisplayFunction  ]

•  Avvertenza su Show

gr14 = Plot[Sin[x], {x, 0, 2  Pi}]

Show[gr14,Axes -> False]

gr14 // Show

Una parametrizzazione del nastro di Mobius e` la seguente
                    f (t, u) =  R[t] . {2 + u  cos  (t/2), 0, u  sin  (t/2)}
ove R(t) e` la matrice di rotazione di angolo t nel paino 1-2:
                 (({{cos t, -sin t, 0}, {sint, cos t, 0}, {0, 0, 1}})) 
e t varia fra 0 e 2π, u fra -1 e 1
Disegnarlo.

Come e` approssimata la funzione    sin(x)   dai troncamenti del suo sviluppo in serie di Taylor?

Sia     (Subscript[S, n])(x)    il troncamento all'ordine  n   dello sviluppo in serie di    sin(x) .  
Per diversi valori di   n, fare un grafico che mostra assieme  le due funzioni     sin(x)   e    (Subscript[S, n])(x).
Farlo, per esempio, per n = 5,10,....,75,\(\(80.\)\(\ \)\(Mostrare\)\(\ \)\(tutti\)\(\ \)\(i\)\(\ \)\(grafici\)\(\ \)\(in\)\(\ \)\(un'\) \(unica\)\(\ \)\(figura\)\(\ \ \)\)

Osservazioni:

Sviluppo in serie di Taylor all'ordine   n    di   f[x]  con punto iniziale  xin: 
      Series[ f[x] ,  {x,  xin, n} ]  //Normal
 NB: Il comando Series produce un oggetto con Head "SeriesData". Per trasformarlo in una funzione normale (un symbol) serve il comando Normal

Il comando Plot sembra non funzionare con            Series[ f[x] ,  {x,  xin, n} ]  //Normal     Questo non e` un errore, ma e` legato al modo in cui Mathematica valuta le funzioni delle quali deve fare un plot. Per informazioni, vedere il manuale. In pratica, si risolve cosi`: o si esegue (per n fissato)
        Plot[      Series[ Sin[x] ,  {x,  0, n} ]  //Normal  //Evaluate   ,{x,0,1}]       
oppure si definisce 
        f[x_,n_] := (Series[ Sin[y] ,  {y,  0, n} ]  //Normal )/.y->x

Disegnare il grafico del sin in un colore, del troncamento della serie in un altro, in modo che si veda bene la differenza.
NB: Se si usa Evaluate, qui va messo fuori dalla lista di funzioni da plottare: Plot[{Sin[x],Series[...]}//Evaluate, ...]

Per mostrare varii grafici in un'unica figura, in forma tabellare, si usa il comando 
      GraphicsArray[lista di oggetti grafici ]
La lista puo` essere 1-dim o 2-dim 
GraphicsArray produce un oggetto grafico, che deve essere poi mostrato

Scrivere una singola funzione che produce direttamente la tabella di grafici. Evitare che i grafici prodotti siano mostrati via: mostrarli solo alla fine (DisplayFunction->...)