Introduzione a Mathematica

Gianluca Gorni
Università di Udine, Dipartimento di Matematica e Informatica

7. Grafici di funzioni

Ultima modifica: 14 dicembre 2006

Questo file è concepito principalmente per essere letto interattivamente su schermo. Per questo, e anche per risparmiare spazio, gli output di solito sono omessi. L'utente che legge da schermo li deve rigenerare mandando in esecuzione le celle di input una alla volta.
Qualcuno vorrà stampare per leggere su carta: in tal caso apra i gruppi di celle ed esegua tutte le celle prima di stampare. Le celle si possono eseguire tutte in un sol colpo col menu Kernel>Evaluation>Evaluate Notebook

"Personalizzazione" consigliata di Mathematica

Mathematica ha alcune migliaia di comandi predefiniti nel nòcciolo. Altri comandi sono definiti in file esterni al nòcciolo, da essere "caricati" a richiesta. Tutte le installazioni di Mathematica hanno una collezione di pacchetti standard, documentati nell'aiuto on-line. Il meccanismo di caricamento manuale dei pacchetti è abbastanza astruso. Ogni utente "normale" di Mathematica farebbe bene a personalizzare il programma col pre-caricamento di tutti i pacchetti standard. È una procedura da fare una-tantum e che evita molte rogne in futuro.

Pacchetto aggiuntivo caldamente consigliato:  "DrawGraphics". Il pacchetto si scarica dalla pagina internet di David Park. Le istruzioni per l'installazione sono nel file DrawGraphicsReadMe.txt, il pacchetto stesso è nel file zippato DrawGraphics.zip.

Istruzione per il pre-caricamento automatico dei pacchetti. Eseguite la seguente cella:

ToFileName[{$UserAddOnsDirectory, "Kernel"}, "init.m"]

Il risultato è la posizione sul disco del file init.m. Attenzione: su Windows il file potrebbe essere in una cartella nascosta: nel qual caso bisogna renderla visibile. Se non esiste un file con quel nome in quella posizione, createlo voi come file di testo (puro testo, senza formattazione), e copiateci dentro le righe seguenti:

Needs["Algebra`"];
Needs["Calculus`"];
Needs["DiscreteMath`"];
Needs["Geometry`"];
Needs["Graphics`"];
Needs["LinearAlgebra`"];
Needs["Miscellaneous`"];
Needs["NumberTheory`"];
Needs["NumericalMath`"];
Needs["Statistics`"];
Needs["Utilities`"];
Needs["DrawGraphics`DrawingMaster`"];

(il carattere ` è alt-096). (L'ultima riga va messa solo se si è installato il pacchetto "DrawGraphics").

Fatto questo, dalla prossima volta che fate partire Mathematica non avrete bisogno di caricare manualmente i pacchetti standard (nonché il DrawGraphics).

Un altro modo per ottenere l'autocaricamento è descritto nell'aiuto on-line sotto la voce Autoloading Packages (sezione 6.16.3, almeno nella mia versione), nell'ultimo paragrafo in fondo.

Coi seguente comandi il testo e le formule nell'output e all'interno dei grafici verranno scritti in forma tradizionale, decisamente più bella. Quindi sono dei comandi altamente consigliati da aggiungere all'init.m.

$FormatType = TraditionalForm;
SetOptions[$FrontEnd, 
        CommonDefaultFormatTypes -> {"Output" -> 
              TraditionalForm}];

Naturalmente, queste "personalizzazioni" di Mathematica hanno un costo: i file potrebbero non girare su altri computer, almeno se non si prendono alcuni accorgimenti.

Plot

Il comando di base per disegnare il grafico di una funzione di una variabile è Plot:

Plot[Sin[x],{x, -Pi, Pi}];

La sintassi di base è semplice: Plot[funzione,{variabile, inf, sup}]. Altro esempio:

Plot[x^3 - x,{x, -2, 2}];

Per produrre una bella figura in Mathematica di solito si va per approssimazioni  successive: prima si vede cosa viene con le impostazioni di default, e poi si aggiustano i dettagli uno per volta usando le opzioni. L'ordine in cui le opzioni sono date non ha importanza.

Grafico base e opzioni di visualizzazione

Com'è rappresentato un grafico internamente a Mathematica? Per saperlo usiamo InputForm  e StandardForm, rimpiccioliamo i caratteri (selezionare la cella e poi usare il menu Format>Size>Smaller) per avere una visuale d'insieme:

Plot[Sin[x],{x, -Pi, Pi}]//InputForm//StandardForm

Graphics[{{Line[{{-3.141592391790405,  -2.6179938806858837*^-7},  {-2.88670272818237,  -0.25213889196341355},  {-2.608723248393842,  -0.5080069997492934},  {-2.347653339586964,  -0.7131204212611489},  {-2.0965832775706224,  -0.8649292437569434},  {-1.967459776050496,  -0.9223551787683759},  {-1.895639532033744,  -0.9477007807106174},  {-1.829333123564902,  -0.9667651045914428},  {-1.761933894577177,  -0.9817887599829267},  {-1.726421401685748,  -0.9879148386395656},  {-1.6887741358033697,  -0.9930486867121878},  {-1.6730467316016515,  -0.9947769803573823},  {-1.6561285974352775,  -0.996361410492786},  {-1.6415064975304088,  -0.9975010773404583},  {-1.6255458069249227,  -0.9985016215519943},  {-1.6158772085883775,  -0.9989840291277866},  {-1.606900936957649,  -0.9993482993604226},  {-1.5983223675775864,  -0.9996211824589528},  {-1.5939293279595275,  -0.99973244406044},  {-1.589177242377171,  -0.9998310757272946},  {-1.5844971192425916,  -0.9999061456112971},  {-1.5801911827004844,  -0.9999558686658562},  {-1.571725827649626,  -0.9999995680141116},  {-1.5640315075455222,  -0.9999771186975212},  {-1.5559027243603387,  -0.9998890923534056},  {-1.5478579445494514,  -0.999736926845371},  {-1.5433124386670776,  -0.9996223417200457},  {-1.5391069473719194,  -0.9994979336332916},  {-1.5231959215542745,  -0.9988673146044424},  {-1.508736285672799,  -0.9980748936376652},  {-1.4933747404175826,  -0.9970044457347939},  {-1.461513229760943,  -0.9940345429176441},  {-1.4263442878243904,  -0.9895849335338147},  {-1.3639584830021971,  -0.9786852066169905},  {-1.3053899347059348,  -0.9649859833349602},  {-1.1722390540517127,  -0.9216218596882009},  {-1.0501558578372316,  -0.867500765405519},  {-0.7887415357696856,  -0.7094669459933793},  {-0.5373270604926758,  -0.5118415543145262},  {-0.2697324932262869,  -0.26647361190518665},  {-0.012137772750434078,  -0.012137474718667603},  {0.2616370397147976,  
                    0.2586622254848518},  {0.5254120053894933,  
                    0.5015694802512553},  {0.7791871242736528,  
                    0.7027013025535851},  {0.9077370790732587,  
                    0.7881128613261776},  {1.0491423351471911,  
                    0.8669961574133117},  {1.1834458789018947,  
                    0.925913141207723},  {1.3090976992301935,  
                    0.9659519000533466},  {1.3777576599320338,  
                    0.981425823071751},  {1.4115802020983816,  
                    0.9873518656643325},  {1.4429395172998656,  
                    0.9918374469130116},  {1.4712789953878533,  
                    0.9950522358283519},  {1.5014503439149545,  
                    0.9975965307241794},  {1.5186973148958112,  
                    0.9986431534294095},  {1.5271535879042457,  
                    0.9990478068214179},  {1.5349235158580439,  
                    0.9993566397149916},  {1.5418741217336762,  
                    0.9995817821814739},  {1.5494934593682814,  
                    0.9997731025006338},  {1.557152546613171,  
                    0.9999069250750359},  {1.5652334617215027,  
                    0.9999845273059885},  {1.5738744808243974,  
                    0.999995262487626},  {1.5818586045750482,  
                    0.9999388136291295},  {1.5860268955867807,  
                    0.9998840171292116},  {1.590621818758292,  
                    0.9998034813711373},  {1.5999193815766544,  
                    0.9995759538126735},  {1.6080752570469872,  
                    0.9993052211474814},  {1.6168557639006889,  
                    0.9989394516402537},  {1.6327349194694354,  
                    0.9980824185354398},  {1.6483752690000972,  
                    0.9969922628207966},  {1.664820242732899,  
                    0.9955830070890067},  {1.6941998396397973,  
                    0.9923954443130232},  {1.7284044041082836,  
                    0.9876055357375542},  {1.7601855917872362,  
                    0.9821193947063365},  {1.832270756625954,  
                    0.9660098805988249},  {1.901874875368537,  
                    0.9456922972001949},  {1.9674991078851773,  
                    0.922339982475398},  {2.090209890362475,  
                    0.8681104190514862},  {2.3443294225073035,  
                    0.7154466815504688},  {2.6146290466415105,  
                    0.5029111934098893},  {2.8749288239851816,  
                    0.2635146543573844},  {3.1252287545383166,  
                    0.016363168748097807},  {3.141592391790405,  
                    2.6179938806858837*^-7}}]}}, {PlotRange  ->  Automatic,  
            AspectRatio  ->  GoldenRatio^(-1),  
            DisplayFunction  :>  $DisplayFunction,  
            ColorOutput  ->  Automatic,  Axes  ->  Automatic,  
            AxesOrigin  ->  Automatic,  PlotLabel  ->  None,  
            AxesLabel  ->  None,  Ticks  ->  Automatic,  
            GridLines  ->  None,  Prolog  ->  {},  Epilog  ->  {},  
            AxesStyle  ->  Automatic,  Background  ->  Automatic,  
            DefaultColor  ->  Automatic,  
            DefaultFont  :>  $DefaultFont,  RotateLabel  ->  True,  
            Frame  ->  False,  FrameStyle  ->  Automatic,  
            FrameTicks  ->  Automatic,  FrameLabel  ->  None,  
            PlotRegion  ->  Automatic,  ImageSize  ->  Automatic,  
            TextStyle  :>  $TextStyle,  FormatType  :>  $FormatType}]

Ho colorato l'output per distinguere meglio le due parti di cui si compone:
1) un oggetto Line[] (evidenziato in rosso qui sopra), contenente una lista di coppie di punti {ascissa,ordinata}. Questo è il piatto forte del grafico, cioè la curva descritta dal punto (x, f(x)) al variare di x. Vediamo anche che per Mathematica il grafico di una funzione non è una curva ma una linea spezzata.
2) una lista di opzioni di visualizzazione (in blu).

Si può pensare in questo modo: il Line[] descrive la curva in astratto:

Show[Graphics[Plot[Sin[x],{x, -Pi, Pi}][[1]]]];

mentre le opzioni specificano la forma, posizione, e accessori vari, della finestra che apriamo per vedere la curva.

Il più delle volte Plot ci dà dei grafici accettabili al primo tentativo. Chi non si accontenta deve imparare a manipolare le opzioni.

Ci sono due tipi di opzioni: quelle che influenzano il piatto forte, cioè la linea spezzata in rosso, e le opzioni di visualizzazione, cioè la parte in blu. Cominciamo da queste ultime.

Intanto un trucco: può succedere che il calcolo delle coordinate della Line[] sia lungo e laborioso. Se vogliamo cambiare le opzioni di visualizzazione, siamo costretti ad aspettare che Mathematica ricalcoli tutte le coordinate? No! Possiamo memorizzare l'output in una variabile, e poi dare le nuove opzioni dentro a Show:per esempio assegnamo l'output di Plot alla variabile grafico:

grafico=Plot[Sin[x], {x, -Pi, Pi}];

e poi cambiamo le opzioni di visualizzazione:

Show[grafico,AspectRatio -> 1/3];

Questo è un grafico semplice, che viene calcolato in un baleno. Ma se si fa un grafico intensivo di calcoli, per esempio la soluzione di un'equazione differenziale, conviene salvare il risultato in una variabile, e manipolare le opzioni con Show.

AspectRatio

AspectRatio è il rapporto altezza/larghezza.
Attenzione: nel dare le proporzioni degli schermi delle TV o dei monitor si usa il rapporto larghezza/altezza (classici sono i rapporti 4/3 e 16/9).
Per default l'AspectRatio è 1/GoldenRatio:

1/GoldenRatio // FunctionExpand

In altre parole, salvo avviso contrario Mathematica presenta i suoi grafici nelle proporzioni della sezione aurea, di greco-romana memoria:

grafico = Plot[Sin[x], {x, -Pi, Pi}];

Possiamo dare all'AspectRatio qualsiasi valore numerico, per esempio 1, che corrisponde a un quadrato:

Show[grafico, AspectRatio -> 1];

oppure 3/4, la proporzione classica dei televisori:

Show[grafico, AspectRatio -> 3/4];

o 9/16, quella dei televisori a schermo largo:

Show[grafico, AspectRatio -> 9/16];

o 2/3, quella delle fotografie:

Show[grafico, AspectRatio -> 2/3];

o ancora (Sqrt[2]) , quello dei fogli A3, A4 ecc.:

Show[grafico, AspectRatio -> (Sqrt[2])];

C'è anche un AspectRatio non numerico: Automatic, che forse sarebbe meglio chiamare "proporzione naturale": quella in cui le lunghezze in orizzontale e in verticale hanno la stessa scala, in cui i cerchi sono cerchi e non ellissi, e i quadrati sono quadrati e non rettangoli:

Show[grafico, AspectRatio -> Automatic];

Confrontate: con il rapporto aureo un cerchio viene disegnato come un'ellisse:

Show[{grafico, Graphics[Circle[{0, 0}, 1]]}];

con AspectRatio->Automatic il cerchio si mostra come un vero cerchio:

Show[{grafico, Graphics[Circle[{0, 0}, 1]]}, 
        AspectRatio -> Automatic];

PlotRange

Non sempre Mathematica mostra tutto quanto il piatto forte Line[]. Per esempio

grafico = Plot[x^3 - x, {x, -3, 3}];

Noterete che l'ascissa della curva non va da -2 a 2, ma circa da -1.5 a 1.5. Perché? Dunque, Mathematica ha calcolato le coordinate della spezzata fra -2 e 2, come richiesto, ma poi ha giudicato che soltanto una parte della spezzata fosse "interessante", e ha mostrato solo quella.
Possiamo costringere Mathematica a mostrarci tutta la spezzata con PlotRange->All:

Show[grafico,PlotRange -> All];

In effetti Mathematica aveva tagliato via le "code" del grafico, che sono quasi rettilinee e quasi verticali, lasciando in evidenza la zona attorno all'origine, in cui c'è un'oscillazione.
L'algoritmo che Mathematica usa per decidere cos'è interessante e cosa no c'indovina piuttosto spesso. Comunque un utente sofisticato vorrà aggiustare manualmente la regione da visualizzare.
Per questo si può agire in tre modi:
1) modificare l'intervallo delle ascisse su cui si calcola il grafico; le code è meglio non calcolarle del tutto, invece che prima calcolarle e poi tenerle nascoste.

Plot[x^3 - x, {x, -1.5, 1.5}];

2) non cambiare la spezzata sottostante, ma aggiustare in verticale la finestra che si vuole aperta sul grafico usando PlotRange->{yminimo,ymassimo}:

Show[grafico,PlotRange -> {-1, 2}];

3) aggiustare sia in orizzontale che in verticale la finestra con PlotRange->{{xmin,xmax},{ymin,ymax}}:

Show[grafico,PlotRange -> {{-1, 1.3}, {-1, 2}}];

Esempio:

strano = 
        Plot[ArcTan[x] + ArcTan[1/x] - Pi/2, {x,  .00000001, 
            1}];

A prima vista è un grafico stranissimo. Però se ingrandiamo la finestra verticale vediamo che si tratta del grafico della funzione nulla, perturbata da un "rumore numerico" dovuto agli arrotondamenti:

Show[strano, PlotRange -> {-1, 1}];

Ticks

Mathematica ha un suo algoritmo interno per decidere dove mettere le tacche ("ticks") e i numeri sugli assi. Questo algoritmo è usato quando l'opzione sulle tacche è quella di default: Ticks->Automatic:

grafico = Plot[Sin[x], {x, -Pi, Pi}];

In un grafico di una funzione trigonometrica è meglio avere le tacche nei multipli notevoli di π, invece che nei punti decimali. A questo fine diamo come opzione Ticks->{{tacche in ascissa},{tacche in ordinata}}:

Show[grafico,Ticks -> {{-Pi, -Pi/2, Pi/2, Pi}, {-1, 
                  1}}];

Show[grafico,Ticks -> {{-Pi, -Pi/2, Pi/2, Pi}, 
                Automatic}];

Si può anche usare il comando PiScale[xmin,xmax] per avere automaticamente delle tacche multiple di π:

Show[grafico,Ticks->{PiScale[-Pi, Pi],Automatic}];

Se non si vuole alcuna tacca si può scrivere Ticks->None, oppure Ticks->{{},{}}:

Show[grafico,Ticks -> None];

Le tacche possono anche essere il risultato di un calcolo. Definiamo

Expand[
      Integrate[36 (x - 1) (x - 1/3) (x + 2/3), x]]

f[x_] = 
        9  (x^4) - 8  (x^3) - 10  (x^2) + 8  x;
grafico = Plot[f[x], {x, -2, 2}];

Vogliamo mettere le tacche nei punti in cui si annulla la derivata prima:

sol = Solve[f'[x] == 0, x]

Potremmo anche inserire i valori manualmente, ma facciamolo fare a Mathematica: trasformiamo la lista di liste di regole di sostituzione in una lista di valori con slash-dot:

x /. sol

e la inseriamo nei Ticks:

Show[grafico,Ticks->{x /. sol,Automatic}];

Possiamo mettere le tacche corrispondenti anche sull'asse verticale: mandando le regole di sostituzione nella coppia {x,f[x]} si ottiene una lista di coppie {ascissa,ordinata}:

{x, f[x]} /. sol

Ticks vuole una lista di sole ascisse e una di sole ordinate. La ricaviamo con una trasposizione:

Transpose[{x, f[x]} /. sol]

Ecco il risultato:

Show[grafico,Ticks->Transpose[{x, f[x]} /. sol]];

Il risultato è poco leggibile, perché i numeri sono troppo grossi. Un modo per rimediare è di stringere la finestra verticalmente:

Show[grafico, Ticks -> Transpose[{x, f[x]} /. sol], 
        PlotRange -> {-6, 2}];

Si possono dare anche etichette simboliche qualsiasi alle tacche, al posto dei valori numerici: basta dare una coppia {posizione,etichetta} dove prima avremmo messo semplicemente posizione:

Plot[x^2 - 1,{x, -2, 2},Ticks->{{\({\(-1\), \*""\!\(x\_1\)""}\),\({1, \*""\!\(x\_2\)""}\)},Automatic}];

Altri aggiustamenti ancora più fini delle tacche sono descritti nell'aiuto su Ticks.

Axes, AxesOrigin, AxesLabel, Frame

Si possono sopprimere gli assi cartesiani con Axes->False:

Plot[Sin[x], {x, -Pi, Pi}, Axes -> False];

Si può anche sopprimere uno solo dei due assi dando come valore di Axes una coppia di valori True, False:

Plot[Sin[x], {x, -Pi, Pi}, 
        Axes -> {True, False}];

Una cosa che sconcerta spesso anche gli utenti esperti è che Mathematica non sempre fa incrociare gli assi nel punto (0,0), se questo è lontano dalla zona che Mathematica reputa "interessante": nell'esempio che segue gli assi si incontrano in (0,4):

grafico = Plot[x^3 - x + 5, {x, -2, 2}];

Se questo ci dà fastidio, mettiamo mano all'opzione AxesOrigin:

Show[grafico,AxesOrigin -> {0, 0}];

Hmm, ancora non ci siamo: Mathematica insiste nel mostrare solo la parte "interessante" dell'asse verticale. Dobbiamo chiedere aiuto a PlotRange:

Show[grafico,AxesOrigin -> {0, 0},PlotRange -> {-1, 7}];

Possiamo mettere delle etichette agli assi, con l'opzione AxesLabel->{etichetta ascisse,etichetta ordinate}:

Plot[Sin[x],{x, -Pi, Pi},AxesLabel->{"θ","sen θ"}];

Possiamo mettere una cornice, con l'opzione Frame->True:

Plot[Sin[x], {x, -Pi, Pi}, Frame -> True];

o anche la cornice senza assi:

Plot[Sin[x], {x, -Pi, Pi}, Frame -> True, 
        Axes -> False];

Background, PlotLabel

Si può colorare lo sfondo di un grafico con Background->colore. Conviene avere caricato il pacchetto Graphics`Colors`:

Needs["Graphics`Colors`"]

Plot[Sin[x],{x, -Pi, Pi},Background -> Yellow];

Un elenco dei colori con nomi predefiniti si trova all'aiuto per Graphics`Colors`. Si può anche dare un livello di grigio:

Plot[Sin[x],{x, -Pi, Pi},Background -> GrayLevel[ .8]];

oppure una mescolanza di Rosso-Verde-Blu (RGB: Red-Green-Blue):

Plot[Sin[x],{x, -Pi, Pi},Background->RGBColor[.8,.2,.4]];

Quando lo sfondo è scuro automaticamente il resto si schiarisce.

Si può aggiungere un'etichetta al grafico nel suo complesso con PlotLabel->etichetta:

Plot[Sin[x],{x, -Pi, Pi},PlotLabel -> "Grafico del seno"];

Prolog, Epilog

Al grafico di una funzione si possono aggiungere delle primitive grafiche con le opzioni Prolog ed Epilog. La differenza fra le due è che il Prolog mette gli oggetti sotto la curva principale, mentre Epilog li mette sopra. Nel caso che gli oggetti siano tutte curve dello stesso colore la differenza non si nota.

Plot[Sin[x],{x, -Pi, Pi},Prolog -> {Point[{1, 1}], Circle[{0, 0}, 1], 
                Line[{{0, 0}, {Pi, 1}}]}];

Nella figura seguente ci sono due dischi: la sinusoide passa sopra uno e sotto l'altro:

Plot[Sin[x],{x, -Pi, Pi},Prolog -> {{Yellow, Disk[{-1, 0}, 1]}, 
              Text["prologo", {-1, 0}]},Epilog -> {{Yellow, Disk[{1, 0}, 1]}, 
                Text["epilogo", {1, 0}]}];

Usando Prolog ed Epilog insieme con Text si possono aggiungere etichette in un qualsiasi punto del grafico:

Plot[Sin[x],{x, -Pi, Pi},Epilog->{PointSize[ .02],Point[{Pi/2, 1}],Text["max", {Pi/2,  .9}],Point[{-Pi/2, -1}],Text["min", {-Pi/2, - .9}]}];

PlotStyle

PlotStyle è un'opzione che va ad intaccare la curva grafico principale, e non la finestra che si apre sulla curva. Esempi

Plot[Sin[x],{x, -Pi, Pi},PlotStyle -> Dashing[{ .02,  .02}]];

Plot[Sin[x],{x, -Pi, Pi},PlotStyle -> Red];

Plot[Sin[x],{x, -Pi, Pi},PlotStyle -> GrayLevel[ .5]];

Si può assegnare lo spessore della curva: l'unità di misura è la larghezza del grafico finale. Nel caso seguente la curva ha per spessoe 2/100=.02 della larghezza della figura:

Plot[Sin[x],{x, -Pi, Pi},PlotStyle -> Thickness[ .02]];

Plot[Sin[x],{x, -Pi, Pi},PlotStyle -> {Blue, Thickness[ .02]}];

Se andiamo a sbirciare nella rappresentazione interna del grafico, vediamo che le direttive del PlotStyle vanno a finire con l'oggetto Line[], e non nelle opzioni di visualizzazione:

Plot[Sin[x],{x, -Pi, Pi},PlotStyle -> {Blue, Thickness[ .02]}]//InputForm//StandardForm

Graphics[{RGBColor[0. ,  0. ,  1. ], Thickness[0.02], {Line[{{-3.141592391790405,  -2.6179938806858837*^-7},  {-2.88670272818237,  -0.25213889196341355},  {-2.608723248393842,  -0.5080069997492934},  {-2.347653339586964,  -0.7131204212611489},  {-2.0965832775706224,  -0.8649292437569434},  {-1.967459776050496,  -0.9223551787683759},  {-1.895639532033744,  -0.9477007807106174},  {-1.829333123564902,  -0.9667651045914428},  {-1.761933894577177,  -0.9817887599829267},  {-1.726421401685748,  -0.9879148386395656},  {-1.6887741358033697,  -0.9930486867121878},  {-1.6730467316016515,  -0.9947769803573823},  {-1.6561285974352775,  -0.996361410492786},  {-1.6415064975304088,  -0.9975010773404583},  {-1.6255458069249227,  -0.9985016215519943},  {-1.6158772085883775,  -0.9989840291277866},  {-1.606900936957649,  -0.9993482993604226},  {-1.5983223675775864,  -0.9996211824589528},  {-1.5939293279595275,  -0.99973244406044},  {-1.589177242377171,  -0.9998310757272946},  {-1.5844971192425916,  -0.9999061456112971},  {-1.5801911827004844,  -0.9999558686658562},  {-1.571725827649626,  -0.9999995680141116},  {-1.5640315075455222,  -0.9999771186975212},  {-1.5559027243603387,  -0.9998890923534056},  {-1.5478579445494514,  -0.999736926845371},  {-1.5433124386670776,  -0.9996223417200457},  {-1.5391069473719194,  -0.9994979336332916},  {-1.5231959215542745,  -0.9988673146044424},  {-1.508736285672799,  -0.9980748936376652},  {-1.4933747404175826,  -0.9970044457347939},  {-1.461513229760943,  -0.9940345429176441},  {-1.4263442878243904,  -0.9895849335338147},  {-1.3639584830021971,  -0.9786852066169905},  {-1.3053899347059348,  -0.9649859833349602},  {-1.1722390540517127,  -0.9216218596882009},  {-1.0501558578372316,  -0.867500765405519},  {-0.7887415357696856,  -0.7094669459933793},  {-0.5373270604926758,  -0.5118415543145262},  {-0.2697324932262869,  -0.26647361190518665},  {-0.012137772750434078,  -0.012137474718667603},  {0.2616370397147976,  
                      0.2586622254848518},  {0.5254120053894933,  
                      0.5015694802512553},  {0.7791871242736528,  
                      0.7027013025535851},  {0.9077370790732587,  
                      0.7881128613261776},  {1.0491423351471911,  
                      0.8669961574133117},  {1.1834458789018947,  
                      0.925913141207723},  {1.3090976992301935,  
                      0.9659519000533466},  {1.3777576599320338,  
                      0.981425823071751},  {1.4115802020983816,  
                      0.9873518656643325},  {1.4429395172998656,  
                      0.9918374469130116},  {1.4712789953878533,  
                      0.9950522358283519},  {1.5014503439149545,  
                      0.9975965307241794},  {1.5186973148958112,  
                      0.9986431534294095},  {1.5271535879042457,  
                      0.9990478068214179},  {1.5349235158580439,  
                      0.9993566397149916},  {1.5418741217336762,  
                      0.9995817821814739},  {1.5494934593682814,  
                      0.9997731025006338},  {1.557152546613171,  
                      0.9999069250750359},  {1.5652334617215027,  
                      0.9999845273059885},  {1.5738744808243974,  
                      0.999995262487626},  {1.5818586045750482,  
                      0.9999388136291295},  {1.5860268955867807,  
                      0.9998840171292116},  {1.590621818758292,  
                      0.9998034813711373},  {1.5999193815766544,  
                      0.9995759538126735},  {1.6080752570469872,  
                      0.9993052211474814},  {1.6168557639006889,  
                      0.9989394516402537},  {1.6327349194694354,  
                      0.9980824185354398},  {1.6483752690000972,  
                      0.9969922628207966},  {1.664820242732899,  
                      0.9955830070890067},  {1.6941998396397973,  
                      0.9923954443130232},  {1.7284044041082836,  
                      0.9876055357375542},  {1.7601855917872362,  
                      0.9821193947063365},  {1.832270756625954,  
                      0.9660098805988249},  {1.901874875368537,  
                      0.9456922972001949},  {1.9674991078851773,  
                      0.922339982475398},  {2.090209890362475,  
                      0.8681104190514862},  {2.3443294225073035,  
                      0.7154466815504688},  {2.6146290466415105,  
                      0.5029111934098893},  {2.8749288239851816,  
                      0.2635146543573844},  {3.1252287545383166,  
                      0.016363168748097807},  {3.141592391790405,  
                      2.6179938806858837*^-7}}]}}, {PlotRange  ->  Automatic,  
            AspectRatio  ->  GoldenRatio^(-1),  
            DisplayFunction  :>  $DisplayFunction,  
            ColorOutput  ->  Automatic,  Axes  ->  Automatic,  
            AxesOrigin  ->  Automatic,  PlotLabel  ->  None,  
            AxesLabel  ->  None,  Ticks  ->  Automatic,  
            GridLines  ->  None,  Prolog  ->  {},  Epilog  ->  {},  
            AxesStyle  ->  Automatic,  Background  ->  Automatic,  
            DefaultColor  ->  Automatic,  
            DefaultFont  :>  $DefaultFont,  RotateLabel  ->  True,  
            Frame  ->  False,  FrameStyle  ->  Automatic,  
            FrameTicks  ->  Automatic,  FrameLabel  ->  None,  
            PlotRegion  ->  Automatic,  ImageSize  ->  Automatic,  
            TextStyle  :>  $TextStyle,  FormatType  :>  $FormatType}]

Ne segue che il PlotStyle non è cambiabile con Show:

grafico = Plot[Sin[x], {x, -Pi, Pi}];

Show[grafico, PlotStyle -> Blue];

Assi con le frecce

Nello stile di Mathematica non si mettono le frecce sugli assi cartesiani, e non è fornito un'opzione semplice per aggiungerle. Tuttavia si può ovviare col seguente programmino:
(il carattere ` è alt-096)

Needs["Graphics`Arrow`"]

SetAttributes[ArrowsOnAxes, HoldFirst];
ArrowsOnAxes[gr_, opts___?OptionQ] := 
        Module[{grph, extractOptions, ox, oy, xmin, xmax, ymin, ymax, xst, 
            ystprlg}, 
          grph = Block[{$DisplayFunction = Identity}, 
              gr]; 
extractOptions = 
            If[$VersionNumber ≥ 4, 
              Last /@ AbsoluteOptions[##1] &, 
              FullOptions]; 
{{ox, 
                oy}, {{xmin, xmax}, {ymin, ymax}}, {xst, yst}, prlg} = 
            extractOptions[
              Graphics[grph], {AxesOrigin, PlotRange, AxesStyle, 
                Prolog}]; 
Show[grph, 
            Prolog -> 
              Append[prlg, {Append[xst, Arrow[{xmin, oy}, {xmax, oy}, opts]], 
                  Append[yst, 
                    Arrow[{ox, ymin}, {ox, ymax}, opts]]}]]];

ArrowsOnAxes[Plot[Sin[x], {x, -Pi, Pi}]];

C'è un piccolo difetto: le tacche si sovrappongono alle frecce. Senza tacche viene meglio:

ArrowsOnAxes[
        Plot[Sin[x], {x, -Pi, Pi}, Ticks -> None]];

Grafici di più funzioni insieme sullo stesso intervallo

Possiamo disegnare i grafici di due o più funzioni contemporaneamente su un dato intervallo (lo stesso per tutte le funzioni) semplicemente dando a Plot una lista di funzioni invece di una singola funzione.
Esempio con due funzioni:

Plot[{Sin[x], x^2}, {x, -Pi, Pi}];

Esempio con tre funzioni:

Plot[{Sin[x], x^2, x^3 - x}, {x, -Pi, Pi}];

Disegnamo insieme i grafici di una funzione e della retta tangente in un punto:

Clear[x];
(Subscript[x, 0]) =  .7;
f[x_] = x^3 - x;
tangente[x_] = 
        f[(Subscript[x, 0])] + f'[(Subscript[x, 0])] (x - (Subscript[x, 0]));
Plot[{f[x], tangente[x]}, {x, -2, 3}, 
        Epilog -> {PointSize[ .02], 
            Point[{(Subscript[x, 0]), f[(Subscript[x, 0])]}]}];

Possiamo differenziare le varie curve dando come PlotStyle una lista di stili: ogni stile è fra graffe:

Plot[{Sin[x],x^2,x^3 - x},{x, -Pi, Pi},PlotStyle->{{Red},{Blue, Thickness[ .01]},{Dashing[{ .02,  .02}]}}];

Caricato il pacchetto Graphics`Legend` si può aggiungere una didascalia per etichettare le tre curve:
(il carattere ` è alt-096)

Needs["Graphics`Legend`"];

Plot[{Sin[x],x^2,x^3 - x},{x, -Pi, Pi},PlotStyle->{{Red},{Blue, Thickness[ .01]},{Dashing[{ .02,  .02}]}},PlotLegend->{"sen x","(x^2)","(x^3)-x"}];

La didascalia è gigantesca e copre parte della figura. Per modificarla vedere l'aiuto on-line.

Grafici su intervalli distinti

Plot fa sempre grafici su un singolo intervallo. Se vogliamo il grafico di una funzione su due intervalli non sovrapposti, oppure di più funzioni su intervalli non coincidenti, dobbiamo disegnare un grafico su un intervallo per volta e poi combinarli insieme con Show. Esempio:

primo=Plot[Sin[x], {x, 0, Pi}];
secondo=Plot[Cos[x], {x, Pi/2, 3  Pi/2}];
Show[{primo,secondo}];

Se Mathematica incontra un punto dell'intervallo assegnato in cui la funzione non è definita (o ha valori complessi non reali) darà un messaggio d'errore, e il grafico può venire imperfetto:

Plot[(Sqrt[Sin])[x], {x, -2 Pi, 2  Pi}];

Si noterà che le arcate non toccano bene l'asse x, come invece dovrebbero. Per avere un grafico fatto di tratti disgiunti conviene combinare più grafici fatti ognuno su un singolo intervallo:

primo=Plot[(Sqrt[Sin])[x],{x, -2 Pi, -Pi}];
secondo=Plot[(Sqrt[Sin])[x],{x, 0, Pi}];
Show[{primo, secondo}];

DisplayFunction

Si sarà forse notato che con

f[x_] = Log[Abs[x]];
xnegativo = 
        Plot[f[x], {x, -4, - .1}];
xpositivo = Plot[f[x], {x,  .1, 4}];
Show[{xnegativo, xpositivo}];

saltano fuori  tre grafici, ognuno in una cella sua. I primi due sono prodotti dal comando Plot, e il terzo dallo Show. A noi qui interessava solo il terzo. Possiamo cancellare i primi due selezionandoli col mouse e facendo "Edit>Clear". C'è anche un modo, un tantino macchinoso, di impedire che i primi due vengano visualizzati: è di disattivare e poi riattivare la visualizzazione con l'opzione DisplayFunction. Precisamente: DisplayFunction->Identity disattiva la visualizzazione, mentre DisplayFunction->$DisplayFunction la riattiva. Perché proprio "Identity"? Il motivo c'è, ma è arcano. Vediamo piuttosto un esempio:

primo=Plot[(Sqrt[Sin])[x],{x, -2 Pi, -Pi},DisplayFunction -> Identity];
secondo=Plot[(Sqrt[Sin])[x],{x, 0, Pi},DisplayFunction -> Identity];
Show[{primo, secondo},DisplayFunction -> $DisplayFunction];

Il pacchetto DrawGraphics per combinare più oggetti grafici

La faccenda del DisplayFunction è uno degli aspetti meno intuitivi della grafica in Mathematica. David Parks ha scritto un pacchetto (DrawGraphics) in cui si definisce un modello grafico alternativo e più semplice per combinare insieme diversi elementi grafici. Con DrawGraphics non c'è più bisogno, fra l'altro, di Epilog e Prolog, e il più delle volte si può anche fare a meno di PlotStyle. Quando gli elementi da combinare sono tanti vale decisamente la pena di fare le cose alla maniera di DrawGraphics.

Con DrawGraphics si scrive Draw invece di Plot, però Draw da solo non mostra il risultato. Bisogna inserire Draw, insieme con altri elementi grafici, in una lista e racchiuderla in Draw2D, dandole poi le opzioni di visualizzazione:

Draw2D[
{Circle[{0, 0}, 1],Circle[{-1/3, 1/3}, 1/6],{Blue, Disk[{-1/3, 1/3}, 1/10]},Circle[{1/3, 1/3}, 1/6],{Blue, Disk[{1/3, 1/3}, 1/10]},
{Red,Thickness[ .03],Draw[x^2 - 1/2, {x, -1/2, 1/2}]},
{Thickness[ .01], 
                  Line[{{0, -1/4}, {0, 1/4}}]},
Blue,Text["cucù", {1/3, -2/3}]},
AspectRatio -> Automatic,PlotRange -> All];

Grafici di più funzioni insieme; un problemino risolto.

Guardiamo un attimo il grafico di (Sqrt[Cos])[x] su [-π/2, π/2]:

Plot[(Sqrt[Cos])[x], {x, -Pi/2, Pi/2}];

Non assomiglia a un semicerchio? L'altra metà del cerchio sarebbe il grafico di -(Sqrt[Cos])[x]. Come facciamo a disegnarli insieme? Un modo è di fare due Plot separati e poi di combinarli, ma in questo caso si può dare a Plot una lista di funzioni, invece di una singola funzione:

Plot[{-(Sqrt[Cos])[x], (Sqrt[Cos])[x]},{x, -Pi/2, Pi/2}];

Non sembra più un cerchio, ma un'elllisse sì.

Come facciamo a decidere se è davvero un'ellisse?
In geometria analitica s'impara che l'equazione di un'ellisse in forma normale è ((x^2)/(a^2)) + ((y^2)/(b^2)) = 1.

ellisseGenerica=(((x^2)/(a^2)) + ((y^2)/(b^2)) == 1)

La nostra presunta ellisse passa per i punti (π/2, 0) e (0, 1). Cerchiamo quindi per che valori dei parametri a, b l'ellisse passa per quei punti. Imponiamo che l'ellisse passi per (π/2, 0):

ellisseGenerica/.{x -> Pi/2, y -> 0}

Imponiamo che passi per (0, 1):

ellisseGenerica/.{x -> 0, y -> 1}

Possiamo combinare le due condizioni in un'unica lista mettendo una lista di liste di sostituzioni:

eq=(ellisseGenerica/.{{x -> Pi/2, y -> 0},{x -> 0, y -> 1}})

Risolviamo le equazioni rispetto ai parametri a, b:

Solve[eq, {a, b}]

Ci sono quattro soluzioni, ma si ottengono una dall'altra con cambi di segno. Prendiamo l'ultima, che è positiva:

sol = Last[Solve[eq, {a, b}]]

Se dunque il nostro grafico di ±(Sqrt[Cos])[x] è davvero un'ellisse, questa deve avere come equazione la seguente:

nostraEllisse = (ellisseGenerica /. sol)

Per disegnare il grafico dell'ellisse prima bisogna esplicitare y in funzione di x:

Solve[nostraEllisse, y]

ellisseEsplicita = y /. Last[Solve[nostraEllisse, y]]

Disegnamo insieme i grafici di ±(Sqrt[Cos])[x] e dell'ellisse insieme:

Plot[{-(Sqrt[Cos])[x], (Sqrt[Cos])[x], -ellisseEsplicita, 
          ellisseEsplicita}, {x, -Pi/2, Pi/2}];

Non si sovrappongono! Ma quale delle due cuve è l'ellisse? Coloriamo l'ellisse di rosso con l'opzione PlotStyle:

Needs["Graphics`Colors`"];

Plot[{-(Sqrt[Cos])[x],(Sqrt[Cos])[x],-ellisseEsplicita,ellisseEsplicita},{x, -Pi/2, Pi/2},PlotStyle->{{Black},{Black},{Red},{Red}}];

FilledPlot

Con la funzione FilledPlot, definita nel pacchetto omonimo, si può colorare la regione fra il grafico di una funzione e l'asse x, oppure la regione fra due funzioni:

Needs["Graphics`FilledPlot`"]

FilledPlot[x^2, {x, 0, 1}];

FilledPlot[{x^2, x^3}, {x, 0, 1}];

FilledPlot[{x^2, x^3, x^4}, {x, 0, 1}];

Con l'opzione Fills si decide il colore della regione:

FilledPlot[Sin[x], {x, 0, Pi}, Fills -> Yellow];

Più informazioni nell'aiuto on-line su Adds-on>Standard Packages>Graphics>FilledPlot

Quando si vogliano combinare un FilledPlot con altri elementi grafici usando DrawGraphics, ricordarsi di usare FilledDraw invece di FilledPlot:

Draw2D[
{FilledDraw[{x^2 - x, x - x^2}, {x, 0, 1}], 
          Line[{{1/2, -1/2}, {1/2, 1/2}}], 
Text[
            y == (x^2) - x, {1/4, -1/4}], 
Text[
            y == -(x^2) + x, {1/4, 
              1/4}]}, 
Axes -> True, 
        AxesFront -> True, 
        Ticks -> {{0, 1}, {1/4, -1/4}}];

L'opzione AxesFront->True fa passare gli assi al di sopra degli elementi del grafico, invece che sotto.

ParametricPlot

Molte curve interessanti non si scrivono agevolmente nella forma y = f(x), ma piuttosto in forma parametrica (x(t), y(t)). Per disegnare questo tipo di curve c'è ParametricPlot. La curva è specificata dalla coppia {ascissa,ordinata}, che dipendono da un parametro che varia in un intervallo. Vediamo per esempio una cicloide:

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

Attenti a non confondersi con la sintassi di Plot, in cui una coppia di funzioni di t non fa una curva parametrica, ma due grafici cartesiani delle due funzioni t ↦ x(t), t ↦ y(t):

Plot[{t + Sin[t],1 + Cos[t]},{t, 0, 4  Pi},AspectRatio -> Automatic,PlotStyle->{{Red},{}}];

Dando una lista di coppie, ParametricPlot disegna più curve insieme, che si possono distinguere con PlotStyle. Per esempio:

ParametricPlot[{{Cos[t], Sin[3  t]},{Cos[t], Sin[2  t]}},{t, 0, 2  Pi},PlotStyle->{{Red},{Blue}}];

In questo pacchetto  è definita l'opzione Oriented, che mette delle frecce direzionali sulle curve:

ParametricPlot[{Cos[t], Sin[t]}, {t, 0, 2  Pi}, 
        Oriented -> True];

ImplicitPlot

Problema. L'equazione di un'ellisse è ((x^2)/2) + ((y^2)/3) == 1; come ne disegnamo il grafico?

Soluzione 1. Scomponiamo l'ellisse in due metà: una di sopra e l'altra di sotto e poi le disegnamo insieme con Plot:

sol = Solve[((x^2)/2) + ((y^2)/3) == 1, y]

dueMetà = y /. sol

Plot[Evaluate[dueMetà], {x, -(Sqrt[2]), (Sqrt[2])}, 
        AspectRatio -> Automatic];

Soluzione 2 (meglio!). Usiamo il comando ImplicitPlot (definito nel pacchetto omonimo)

Needs["Graphics`ImplicitPlot`"];

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

Altri esempi:

ImplicitPlot[
        ((x^2)/2) - ((y^2)/3) == 1, {x, -5, 5}];

ImplicitPlot[
        2  (y^2) - 2  x y + 4  (x^2) == 1, {x, -5, 5}];

Esercizi

Fra le parabole di equazione y = a (x^2) + b x + c trovare quella che passa per i punti (1, 1), (2, 3), (-1, -1), e disegnarne il grafico, coi tre punti messi in evidenza e con etichette (Subscript[P, 1]), (Subscript[P, 2]), (Subscript[P, 3]).

Disegnare il grafico del cos x insieme a quelli dei suoi polinomi di MacLaurin fino all'ordine 6.

Generare tre combinazioni lineari a coefficienti casuali di sen x, cos x, e disegnarne insieme i grafici, distinguendoli con stili diversi.

(Lungo/avanzato) Consideriamo l'insieme dei punti della forma (n π/5, sen(n π/5)) per n = 0, …, 5 e disegnarne un grafico. Trovare poi i polinomi di grado rispettivamente 1, 2, 3, ecc. i cui grafici passano per i primi 2, 3, 4, ecc. punti dell'insieme, e disegnarne i grafici, separatamente e poi insieme, magari distinguendoli con stili diversi.