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

1. Primo sguardo a Mathematica

Mathematica e` un linguaggio di programmazione
-- versatilissimo
-- potentissimo
-- con delle grosse limitazioni (per es: e` interpretato, non compilato)

La differenza principale dai linguaggi di programmazione tradizionali (Fortran, C, Pascal, Basic,..) e dai pacchetti sofware tipo Matlab e Octave e` che questi sono orientati al calcolo numerico.

Mathematica, come molti altri programmi di Calcolo Simbolico (Maple, MuPad, ...) no: e` capace di eseguire anche calcoli simbolici.

Programmi di questo tipo sono noti con varii nomi: Computer Mathematics Systems, Computer Algebra Systems, Symbolic Mathematics Software Packages, .....

Come far partire Mathematica

1. Login con vostra username

2. Comando:   mathematica

Vi appare un foglio elettronico bianco: un notebook

Attenzione: 
- Per evitare di perdere il lavoro, salvate spesso il notebook (dal menu` file.... La prima volta viene chiesto un nome)
- Mathematica non crea copia di backup dei files - prima di cambiamenti importanti, se necessario, create una copia di backup con nome diverso.

Raccomandazione: 
- cercate di tenere organizzati i notebooks. Per esempio:
     data.nb
     numeroprogressivo.nb
     argomento.nb

Input-Output

L'uso tipico di Mathematica
-- avviene attraverso un'interfaccia grafica
-- comporta la creazione di un file   *.nb   (chiamato notebook )  che puo` essere salvato, aggiornato, etc.

Un notebook e` organizzato in celle numerate progressivamente:
--l'input si inserisce in una cella IN
   (usare      ENTER DEL TASTIERINO NUMERICO      oppure     SHIFT ENTER)
--e il risultato viene scritto in una cella OUT. 
Esempi:

(a + b + c)^5 // Expand

Il risultato di un calcolo, cioe` quanto scritto in una cella OUT, e` memorizzato dal programma ed accessibile col comando 
%numero della cella
(Abbreviazioni:  % e` l'ultimo OUT  e  %%  il penultimo)

%1

Esecuzione di diversi comandi:
- Piu` comandi possono andare in una stessa cella di input, separati da " ;  " 
- In questo caso, viene assegnato un "numero di input/output" a ciascuna riga (non a ciascun comando) della cella. 
- Viene mostrato solo l'ultimo output di ogni riga (se non e` soppresso anche lui con ;)

Esempio: notare la differenza:

x = 3;  y = x + 1

%

%%

aa;

x = 3 ;
y = x + 1

%

%%%

Nota: non e` necessario separare linee diverse con   ";"    ma e` raccomandabile   (a volte si perde la formattazione).
Si puo` anche distribuire uno stesso comando su piu` linee, cosa comoda se per esempio si tratta di una lunga espressione algebrica, ma e` necessario lasciare `aperta' l'espressione delle righe precendenti l'ultima.

x = 2 + 
3

x = 2
+3

x = (2
 + 3)

`Aperta' = parentesi aperte, segno di operazione, etc. Ma fare attenzione, perche` possono succedere cose inaspettate. (E` una situazione in cui l'interpretazione del comando non e` univoca). 
Per sicurezza, lasciare delle parentesi non chiuse -- e controllare che tutto funzioni

x = 3

x = 2

x

Mathematica e` costituito da due diverse componenti software:
● Il Kernel, che esegue tutti i calcoli
● Il Front End, che costituisce l'interfaccia per l'utente
Il Kernel e` indipendente dalla piattaforma, e questo garantisce la portabilita` dei programmi scritti in Mathematica.
Il Front End e` invece adattato ai singoli sistemi operativi e questo spiega le piccole differenze fra le diverse versioni.

L'utente scambia i dati con il Front End, che a sua volta li scambia con il Kernel per l'esecuzione. 
(La comunicazione fra Front End e Kernel avviene per mezzo di un programma chiamato MathLink che puo` essere usato per far comunicare il Kernel anche con altri programmi estrerni, quali per esempio un compilatore o un browser o quel che si vuole -  ma e` difficile)

Importante:

Un Notebook non e` altro che un'interfaccia grafica del Front End. 
Bisogna tenere presente che ogni comando dato in un Notebook viene eseguito altrove (dal Kernel) e per questo
• Non ha alcuna importanza in quale punto del Notebook il comando viene inserito
• E` solo l'ordine di esecuzione dei comandi che conta: il Kernel li numera in ordine progressivo
• Tutti gli outputs sono ricordati dal Kernel anche se la cella corrispondente viene cancellata.
   Bisogna stare molto attenti con assegnazioni tipo x=3, perche` il Kernel se le ricorda! 
• Quando si termina Mathematica si termina il Kernel - e tutto va perso. Un notebook invece puo` essere salvato
    come file e poi ri-eseguito in una nuova sessione di Mathematica.
•  Notebooks aperti durante una sessione di Mathematica usano (per default) lo stesso Kernel.

Per dare un primo sguardo a cosa, e come, fa  Mathematica, cominciamo dai calcoli simbolici

Calcoli algebrici

Calcoli simbolici su polinomi:

(a + b + c)^3  // Expand

oppure anche

Expand[ (a + b + c)^3]

NB: 1. Gli argomenti delle funzioni si mettono sempre fra     [ ]    e NON   fra      (  )
            Esempi: Sin[x],  Log[3x+1], .....
       2.  f[x]    e` lo stesso che    x//f

Questo era facile. Adesso:

Factor[%]

% // Factor

Il risultato e` troppo lungo: 
-- Per cancellare solo la visualizzazione dell'output selezionare la cella di output e cancellarla. (Il risultato resta memorizzato)
-- Per mostrare solo una riga dell'output:  Short[...]   oppure   ....//Short

(((a + b + c))^115) // Expand   // Short

Short[(((a + b + c))^115) // Expand  ]

Short[Expand[(((a + b + c))^115)]  ]

%

Per eliminare la VISUALIZZAZIONE dell'output aggiungere un  ;

(((a + b + c))^114) // Expand;

%

NB: Se la macchina e` lenta e/o ha poca RAM, il tempo lo perde tutto a inviare il risultato allo schermo.

"Semplificazione" di polinomi ed espressioni
- Simplify[expression]
- FullSimplify[expression]

(((a + b + c))^5) - 1  // Factor

% // Simplify

% // FullSimplify

Soluzioni di equazioni

Le radici dei polinomi si determinano con  Solve[eq,var]

Solve[a (x^3) - 2  x + 1==0,x]

Cosa succede? Avevamo assegnato un valore alla variabile x...

x

Clear[x]

x

Solve[a (x^3) - 2  (x^2) + 1 == 0, x]

che ritorna una lista di regole di sostituzione. 
Avremo modo di vedere meglio, ma la lista delle radici si ottiene con

x /. %

Naturalmente, le soluzioni possono essere complicate (Mathematica e` utile!)

Solve[(x^4) - (x^3) + 1 == 0, x]

oppure Solve puo` non trovarle:

Solve[(x^5) - (x^3) + 1 == 0, x]

Pero`, per equazioni a coefficienti numerici, si possono cercare soluzioni numeriche (=approssimate) con  NSolve[eq,var]:

NSolve[(x^5) - (x^3) + 1 == 0, x]

Solve e NSolve di solito non funzionano con equazioni non algebriche:

Solve[Sin[x] == x/2,x]

NSolve[Sin[x] == x/2, x]

Per trovare soluzioni numeriche (e approssimate) di equazioni non algebriche si usa 
FindRoot[eq,{variable,initialization point}]

FindRoot[Sin[x] == x/2,{x, 2}]

E` giusto? Tracciamo assieme i grafici delle due funzioni Sin[x] e x/2  e vediamo se si incrociano.  
      Plot[ funzione, {variabile, primo estremo, secondo estremo}]
   Plot[{funzione1,....}, {variabile, primo estremo, secondo estremo}]
(poi vediamo meglio questi comandi)

Plot[{Sin[x], x/2},{x, -Pi, Pi}]

Ne mancano due! Fare molta attenzione con le soluzioni delle equazioni!
Per trovare le altre

FindRoot[Sin[x] == x/2,{x, -1.5}]

FindRoot[Sin[x] == x/2,{x, 1. }]

Analisi: funzioni, derivate, integrali, ....

Derivate:   D[espressione,var]
ed integrali (indefiniti):    Integrate[funzione,var]

D[a x, x]

D[ab  x, ab]

D[ ArcTan[ Log[x^Sin[x]  ]] ,x]

Integrate[ ArcTan[ Log[x^Sin[x]  ]] ,x]

Non ce la fa! Per interrompere il calcolo:   ALT,    oppure      ALT.    (Windows e Linux)

Pero` molti integrali (anche difficili) li sa fare:

Integrate[((Cos[x] Log[x] + Sin[x]/x)/(1 + 
                Log[(x^Sin)[x]]^2)),x]

Definizione di funzioni:    MOLTO IMPORTANTE

f[x_]:=(x^2)  -  (x^3)

f[2]

y // Clear

f[y + 1] // Factor

Eseguire una funzione significa
• sostituire l'argomento alla "x" che appare al secondo membro della definizione  f[x_]:=....
• ed eventualmente fare conti e semplificazioni

g[x_] := Sin[x] // Cos

g[0]

g[f[(x^3)]]

g[ArcCos[v]]

Funzioni di piu` variabili

f3[x_, y_] := Sin[x* y]

e derivate successive:

Clear[x, y]

f3[x, y]

D[f3[x, z],{x, 1},{z, 1}]

D[f3[x, y],{x, 5},{y, 3}]

si puo` farne il grafico

Plot3D[ f3[x, y],  {x, -Pi, Pi}, {y, -Pi, Pi}, 
      PlotPoints -> 50]

Attenzione: non dimenticare il _ nella definizione di una funzione

f2[x] := (x^2) - (x^3)

f2[1]

f2[y]

f2[x]

x = 2

f2[x]

se no, la funzione   f[x]   e` definita solo se l'argomento e` esattamente  x .

NB: la differenza fra
• f[x_] := ....     (due punti uguale)
• f[x_] = ....      (uguale)
sara` chiarita piu` avanti

Ovviamente, Mathematica ha moltissime funzioni predefinite (tutte le elementari e ogni sorta di trascendente). 
Come tutti i comandi di Mathematica, il loro nome inizia con una maiuscola

Clear[x]

Integrate[Log[Sin[x]], x]

PolyLog ??     Controlliamo l'   HELP ONLINE

Ci sono due help:
•  breve descrizione di un comando (Dall'INPUT :  ?comando)
• tutte le >1400 pagine del manuale (e altro)       (SOLO FINO A MATHEMATICA 5)
   ••  o dal MENU  "Help"  
   ••  o con   ALT SHIFT F    (Linux)    o    F1  (Windows)     (e poi ESC per tornare al notebook)

?PolyLog

Calcoli numerici

Precisione arbitraria

1. Calcoli esatti su INTERI e RAZIONALI

(56^23)

(56^230)

(56^2301) // N

(1/3) + (3/4)

(11148594385/311598958943) + (32345678/40934832487)

Le funzioni lavorano in precisione arbitraria, se l'argomento e` in precisione arbitraria.

FactorInteger[  51203478232474832748327497587651771718598  ]

PrimeQ[  4380237281924064295961  ]

c=Log[  4380237281924064295961  ]

Non lo ha calcolato?
No, perche` l'argomento e` esatto ma il risultato non lo e`.s
Bisogna dirgli con quante decimali approssimarlo:             N[espressione,  numero cifre]

N [c, 20]

N [c, 200]

N [c, 2000]

2. Calcoli esatti  anche su COMPLESSI con parti reale ed immaginaria entrambe intere o razionali:

Sqrt[-4]

((10-5I)/(2+I))

Abs[1 + I]

(1 + I) Conjugate[1 + I]

Floating point

3. Calcoli approssimati (ma con approssimazione arbitrariamente alta, almeno in principio: in pratica puo` essere difficile o possono esserci limitazioni dovute a memoria, tempo di calcolo etc.) su reali e complessi

Esempio: lunghezza  della circonferenza del cerchio di raggio 1

2  Pi

Approssimiamola: con 500 cifre decimali?

N[2 Pi, 500]

Con 5000?

N[2 Pi, 5000]

Esempio: Quali sono le prime 121 cifre di e (il numero di Neper)?

N[E, 121]

NB: numeri interi e numeri reali (=approssimati) sono oggetti diversi
       Per esempio, 2 e` un numero intero, ma 2.0, 2.00, ... o anche 2. sono numeri reali

Esempio di numero intero (valutabile con qualunque precisione)

n1 = 1 + (1/(10^10))

N[n1, 50]

Esempio di numero reale: il display mostra poche cifre decimali (ma guardando bene si vede che ne ha 15)

c2=1.+(1/(10^10))

N[c2, 15]

Come fare a vedere piu` cifre, per esempio 15?

Non basta fare
      N[c2,15]
perche`, per default, Mathematica mostra i numeri reali con non piu` di 5 cifre decimali, e omette gli zeri finali.
Serve invece    NumberForm[c2,{num cifre,num cifre decimali}]

NumberForm[c2,{20, 15}]

N[c2,{20, 15}]

Attenzione: Normalmente, in Mathematica non si dichiara il "tipo" dei numeri.
Mathematica fa delle assunzioni su di esso: per esempio, se tutti i numeri che compaiono in un'espressione sono interi, Mathematica assume che il risultato debba essere un intero, e di conseguenza cerca di fare tutte le operazioni in aritmetica esatta -- cosa che puo` richiedere tempi di calcolo molto lunghi.
                                                               FARE MOLTA ATTENZIONE

Il modo piu` semplice per velocizzare conti numerici complicati e/o ripetitivi e` quello  inserire qualche numero reale 
(per esempio, 1.  invece di  1 , oppure approssimare qualche numero con //N)

(Log[(Sin[(Sqrt[2]) + (Sqrt[3]) // N] + 1)^5 // Expand] + 1)^3 // 
      Expand

Esempio: facciamo calcolare un ciclo su interi e reali e confrontiamo i tempi.

Loop:      Do[ comando, {iteratore, numero iterazioni}]

Tempo impiegato:  Timing[comando]    o      comando // Timing    produce  
{tempo impiegato, Output di "comando"}

Do[ArcTan[Log[Sin[Exp[(n^(-3))]]]],{n, 1, 10000}]//Timing

Do[ArcTan[Log[Sin[Exp[(((1. n))^(-3))]]]],{n, 1, 10000}]//Timing

Do[ArcTan[Log[Sin[Exp[((( n//N))^(-3))]]]],{n, 1, 10000}]//Timing

Esercizio: E` possibile ridefinire il comando N in modo che se il suo secondo argomento e` una lista sia = a NumberForm?  (AVANZATO)

Input "elegante"  (Standard Form), sezioni, celle di testo, ...

Tipi di notazione/rappresentazione di input ed output

Si puo` cambiare il formato della notazione usata per mostrare le formule matematiche nelle celle di input ed output.
Formati principali:
  • Input Form: solo caratteri alfanumerici. (Rappresentazione interna = espressione che permette a Mathematica di creare esattamente il risultato)
  • Standard Form: la forma usata normalmente per il display di input ed output; e` parzialmente affinabile (esponenti, pedici, ...) 
  • Traditional Form: una forma adatta alla stampa dei notebooks
  • Full Form:

1.090909389740000

% // InputForm

%% // StandardForm

x^2/Log[y] + Sin[Sqrt[x]]

%  //   InputForm

%% //   StandardForm

%%%  //  TraditionalForm

Le prime due sono equivalenti (non cambia la rappresentazione interna).
Traditional Form no (perche` potrebbe non essere interpretabile in modo univoco): evitarne l'uso - se non per i soli risultati finali, che non verranno modificati piu`.

NB: per una specifica cella si possono settare dal menu`  "Cell -> Display As"

Formule `eleganti' in Standard Form

L'input si puo` rendere un po' piu` elegante con l'uso di apici, pedici, frazioni su due livelli, simboli greci, etc.
Vi si accede:
• da una palette, tipo Basic Input  (dal Menu File)
• con key shortcuts, che sono molti comodi:

Esempi di key shortcuts:
    Sqrt[ ]    ->    (Sqrt[□])               (CTRL 2)
       x/y        ->    (x/y)                 (CTRL /)
       x^3        ->    (x^3)                  (CTRL  6)
            α                                       ( ESC a ESC )

Esempio :  scrivere,  
    usando solo la tastiera
\(η\ \ \ \ \ \ \@\(4\ β\)\ \ \ \ \ \ x\^\(3  α\)\ \ \ \ \ 5\/3\)

Organizzazione dei notebook: gerarchia di sezioni, celle di testo

Inserimento di commenti: 
• all'interno di una formula:      (*   commento   *)
• in un' intera cella di testo  (si crea un cella di testo selezionando la [parentesi a destra che racchiude la] cella e poi da menu` oppure con ALT 7).

Sin[1]

E questa e` una cella di testo:Sin[x]/xe` una bella funzione

Vantaggi di celle di testo rispetto alle ordinarie (di input):
• non sono eseguibili
• miglior (???) formattazione (se uno ci tiene: soprattutto delle formule: viene usata una speciale notazione per "inline formulas")

(Per ritrasformare la cella in cella di input: ALT 9)

Sezioni . 
Si possono organizzare i notebooks gerarchicamente in sezioni, sottosezioni, ...

Modo semplice di farlo:
- creare una cella col titolo della sezione
- selezionare la corrispondente parentesi quadra
- ALT 6, ......, ALT 1 creano sezione (6 piu` profonda, ...., 1 piu` alta)

Esempio : 
      questa cella diventera` il titolo di una sezione

e questa parte della sezione ... .

Personalizzazione dei Notebooks

I Notebook sono personalizzabili in molti modi: il modo piu` semplice e` dai menu`.

Dal menu` Format si puo` cambiare
• lo stile del notebook ("Style sheet": Article classic, Article modern, ....)
• lo stile di una cella ("Style": Title, Subtitle, ...., Text, ...)  -- le principali anche con keyboard shortcuts
• le opzioni di notebook e celle (regolazioni finissime)
• e poi la solita roba: fonti, dimensioni delle fonti, allineamento, zoom, inserimento di righe e "dingbats", ...

Molto di questo pero` non e` importante per l'uso "quotidiano". Siete liberi di esplorare (e apprendere) queste possibilita` secondo i vostri gusti.

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

Grafici 2-dimensionali

1. Grafici di funzioni     f : R -> R

Plot[ f(x), {x,x1,x2}]

Plot[Sin[(x^2) + 2  x],{x, -Pi, 1.3  Pi}]

Esercizio:disegnare il grafico di    (((y^2) - y + 3)/((y^3) - 2  (y^2) - 1))    nell'intervallo  (-10,10)

Plot[(((y^2) - y + 3)/((y^3) - 2  (y^2) - 1)), {y, -10, 
        10}]

Esercizio: scrivere una funzione che disegna il grafico di una funzione f  in un intervallo (x1,x2)
pl(f, x1, x2)

Ci sono varie possibilita`:
•   pl[ f , x1, x2]  oppure   pl[ f , { x1, x2}]    : si passa solo il nome della funzione 
•   pl[ f[x] , x1, x2]    : si passa l'espressione della funzione, e la variabile e` chiamata x
•   pl[ f[x] , x, x1, x2} ]   : si passa l'espressione della funzione, e si specifica il nome della variabile
Scegliamo per es la prima

pl[f_, x1_, x2_]:=

pl[f_, x1_, x2_]:= Plot[ f[x],{x, x1, x2}]

pl[Sin, 0, Pi]

Nota: una funzione puo` essere argomento di un'altra funzione.
Questo e` un esempio, molto elementare, di "programmazione funzionale", che e` molto vicina al modo di pensare di un matematico (e di un fisico) e facile in Mathematica.

Esercizio: Alla funzione  pl cosi` definita  bisogna passare solo il nome della funzione f, non la sua espressione. Non e` allora chiaro come usarla per fare il grafico della funzione   x -> (x^2) - (x^3).
Si saprebbe indicare un modo?
(IL modo giusto di farlo verra` visto piu` avanti: usare una `pure function')

g[z_] := (z^2) - (z^3)

\(pl[\((#\^2 - #\^3)\) &, 1, 2]\)

Function[x, (x^2) - (x^3)]

Esercizio: Scrivere le altre due possibili forme della funzione che crea il plot.

2. Plot di curve in (R^2): 
     2.1 Curva parametrizzata:    t ->(x(t),y(t))

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

Esercizio: disegnare l' arco della spirale di Archimede  t-> {t Cos[t],t Sin[t]} ,  0<t<2π

ParametricPlot[{t Cos[t], t Sin[t]},{t, 0, 3  Pi}];

Brutto: le scale orizzontale e verticale sono diverse. Per renderle uguali:

ParametricPlot[{t Cos[t], t Sin[t]} ,  {t, 0, 5  Pi},AspectRatio -> Automatic];

(vedremo poi meglio come fare aggiustamenti alla grafica, questo e` solo un primo sguardo)

2.2 Curve di livello di una funzione  f: (R^2) -> R

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

Esercizio :  curve di livello della funzione  
        f (x, y) = (((x^2) + (y^2))/(x - 2))
nel rettangolo   -1<x<1,   -2 < y < 2

ContourPlot[(((x^2) + (y^2))/(x - 2)) ,   {x, -1, 
        1}, {y, -2, 2}]

NB: Si possono naturalmente endere uguali le scale orizzontale e verticale, cambiare lo shadowing, colorarlo, etc., tutte cose spiegate sull'help e che (spero) avremo modo di vedere meglio

Plot3D[(((x^2) + (y^2))/(x - 2)) ,  {x, -1, 1},{y, -2, 2},  AspectRatio -> Automatic]

ContourPlot[(((x^2) + (y^2))/(x - 2)) ,  {x, -1, 1},{y, -2, 2},  AspectRatio -> Automatic]

Show[%,ContourShading -> False];

Show[%%,ColorFunction -> Hue];

2.3 Singola curva  di livello di funzione  f: (R^2) -> R

ImplicitPlot[  f(x,y) == valore  ,  {x,x1,x2} ]
           (ma bisogna caricare un "package" grafico   NON IN MATHEMATICA 6)

<<  Graphics`ImplicitPlot`

Esercizio: disegnare la curva di livello  -0.1  di 
     (((x^2) + (y^2))/(x - 1)) 
 per    - 1 < x < 1

ImplicitPlot[(((x^2) + (y^2))/(x - 1)) == - .1,   {x, -1, 1}]

Attenzione: se avete eseguito
    ImplicitPlot 
PRIMA di   
    << Graphics`ImplicitPlot`    
non funziona. Bisogna "rimuovere" il simbolo   ImplicitPlot

Remove[ImplicitPlot]

Menu` File -> Exit

NB:  Se chiudete il notebook col mouse, ne viene aperto un altro (sotto Linux). Per evitarlo, chiudere Mathematica.

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

Esercizi  1

1. Scrivere  (in tre modi diversi) una funzione che disegna un'ellisse di semiassi a e b : 
  ((x^2)/(a^2)) + ((y^2)/(b^2)) = 1 
    - come curva parametrizzata
    - come curva di livello di una funzione
    - come (unione) di grafici di funzioni
   Trattare a e b come parametri: 
             PlotEll[a_,b_]:= .....

2. Quanto e` lunga un'ellisse di semiassi a=2 e b=1?  
Suggerimento: la lunghezza si calcola integrando la norma del vettore tangente: se t-> γ(t) = (3  cos t,2  sin t ) ∈ (R^2) parametrizza l'ellisse allora la lunghezza dell'arco di curva e' data da Int∫ ||γ'(t)|| dt

3. Calcolare l'area di un ellisse di semiassi a e b

4. Equazione polare delle coniche:   ρ = (p/(1 + e cos(θ - (Subscript[θ, 0]))))   (p = parametro;   e = eccentricita`). Disegnarle al variare dell'eccentricita` e , p=1.
(NB: esiste il comando  PolarPlot in un add-on package )

5. Dopo finiti gli esercizi, fare il tour di Mathematica
Help->Getting Started/Demos -> Tour di Mathematica   
                                                Graphics Gallery