Aggiornato per Mathematica versione 11

Grafici di funzioni

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

Ultima modifica: 13 marzo 2018

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.

Plot e Plot3D

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

Plot[Sin[x],{x,-π,π}]

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

Plot[f,{x,(Subscript[x, min]),(Subscript[x, max])}]

Altro esempio:

Plot[(x^3)-x,{x,-2,2}]

L'analogo per le funzioni di due variabili è Plot3D:

Plot3D[(x^2)-(y^2),{x,-1,1},{y,-1,1}]

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

Plot3D[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]

Altro esempi:

Plot3D[y Sin[x],{x,-2Pi,2Pi},{y,-1,1}]

Come funzionano internamente

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.

Il grafico di una funzione è una linea spezzata, fatta di segmenti rettilinei. Nella figura seguente si mettono in evidenza i vertici della spezzata:

Plot[Sin[x],{x,-π,π},Mesh->All]

Si noterà che nelle zone a curvatura alta i vertici sono molto fitti, mentre nei tratti rettilinei sono molto più radi. La procedura che Mathematica seguiva fino ad alcune versioni fa era (a grandi linee) questa:
1) la funzione viene calcolata per via numerica in una griglia di punti equispaziati (una cinquantina per default, regolabili con l'opzione PlotPoints);
2) si calcolano gli angoli fra i  segmenti successivi: 
                    
3) qualora l'angolo fra due segmenti successivi della spezzata supera una soglia (MaxBend), Mathematica aggiunge nuovi punti di suddivisione a metà degli intervalli adiacenti;
4) il procedimento riprende dal punto 2 e continua finché gli angoli scendono sotto la soglia oppure si raggiunge un numero massimo di iterazioni regolato da MaxRecursion.
Oggi non so bene cosa succede internamente. MaxBend è “deprecato” e potrebbe venire dismesso in una versione futura non lontana.

With[{p1={0,0},p2={1,1/3},p3={2,1}},Graphics[{{Thick,Circle[p2,1/4,{ArcTan@@(p2-p1),ArcTan@@(p3-p2)}],Line[{p1,p2,p3}]},PointSize[Large],Point[{p1,p2,p3}],Dashed,Translate[Line[{p1,p2}],p2-p1]}]]

Osservate  cosa succede ai punti di suddivisione cambiando valore a MaxRecursion:

Manipulate[Plot[Sin[x],{x,-π,π},Mesh->All,MaxRecursion->maxIterazioni],{{maxIterazioni,0,MaxRecursion},0,4,1,Setter}]

Guardate cosa succede cambiando valore alla soglia MaxBend (che presumo sia una misura angolare in gradi):

Manipulate[Quiet@Plot[Sin[x],{x,-Pi,Pi},Method->{MaxBend->b},Mesh->All],{{b,120,MaxBend},0,120,Appearance->"Labeled"}]

Manipulate[Plot[Sin[x],{x,-Pi,Pi},Method->{MaxBend->b},Mesh->All],{{b,120,MaxBend},0,120,Appearance->"Labeled"}]

La funzione Quiet mette a tacere i messaggi di errore che vengono generati. Provare l’input precedente senza Quiet.

Osservate cosa succede all'angolo fra i segmenti successivi all'aumentare delle iterazioni:

angolo[{pt1_List,pt2_,pt3_}]:={pt1//First,VectorAngle[pt2-pt1,pt3-pt2]/(Pi/180)};
Manipulate[GraphicsColumn[{Plot[Sin[x],{x,-Pi,Pi},Mesh->All,MaxRecursion->maxIterazioni],ListPlot[Cases[Plot[Sin[x],{x,-Pi,Pi},MaxRecursion->maxIterazioni],Line[pts_]:>Map[angolo,Partition[pts,3,1]],{1,Infinity}][[1]],PlotRange->All,Frame->True,FrameLabel->{None,"angolo fra segmenti (gradi)",None,None}]},Alignment->Automatic],{{maxIterazioni,0,MaxRecursion},0,4,1,Setter}]

Il procedimento funziona bene gran parte delle volte, ma può dare risultati insoddisfacenti per funzioni che oscillano parecchio:

Plot[Sin[83x],{x,0,Pi}]

Plot[Sin[83x],{x,0,Pi},MaxRecursion->Infinity]

A sua volta, la superficie prodotta da Plot3D è in realtà composta da triangoli:

Plot3D[y Sin[x],{x,-2π,2π},{y,-1,1},Mesh->All]

Anche Plot3D procede per raffinamenti successivi: la prima passata è con una griglia equispaziata, che poi viene infittita al bisogno:

Manipulate[Plot3D[y Sin[x],{x,-2π,2π},{y,-1,1},Mesh->All,MaxRecursion->maxIterazioni],{{maxIterazioni,0,MaxRecursion},0,4,1,Setter}]

$RecursionLimit

Un altro modo di influenzare il grafico è l’opzione PlotPoints, che comanda quanti punti (“quasi” equispaziati) usare nella suddivisione di partenza:

Manipulate[Plot[Sin[83x],{x,0,Pi},PlotPoints->n,PerformanceGoal->"Quality"],{n,2,100,1}]

Plot[Sin[83x],{x,0,Pi},PlotPoints->37]

I punti iniziali non sono esattamente equispaziati:

Manipulate[Plot[Abs[x],{x,-1,1},Mesh->All,MaxRecursion->0,PlotPoints->n,PlotRange->All,AxesOrigin->{0,0}],
{n,2,6,1,SetterBar}]

Plot[Sign[x], {x, -1.2, 1.2}]

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

Punti angolosi e discontinuità

Quando il grafico ha punti angolosi si crea un accumulo di punti di suddivisione:

Manipulate[Plot[Abs[x],{x,-1,1},Mesh->All,MaxRecursion->maxIterazioni],{maxIterazioni,0,4,1,Setter}]

Manipulate[Plot3D[Abs[x+y],{x,-π,π},{y,-π,π},Mesh->All,MaxRecursion->maxIterazioni],{maxIterazioni,0,4,1,Setter}]

Nel caso particolare di Abs[x], il punto angoloso si trova esattamente al centro dell'intervallo, e quindi viene mancato alla prima iterazione, che parte con un numero pari di punti di suddivisione:

Plot[Abs[x],{x,-π,π},Mesh->All,MaxRecursion->0]

Il compito di Mathematica è più facile se gli diamo un numero dispari di punti di suddivisione:

Manipulate[Plot[Abs[x],{x,-π,π},Mesh->All,MaxRecursion->0,PlotPoints->n,PlotRange->All,AxesOrigin->{0,0}],
{n,2,10,1,SetterBar}]

Guardate cosa succede cambiando valore alla soglia MaxBend:

Manipulate[Quiet@Plot[Abs[x-Round[x]],{x,-3,4},Method->{MaxBend->b},Mesh->All,PlotPoints->31],{{b,10,MaxBend},0,120}]

Manipulate[Plot3D[Abs[x+y],{x,-π,π},{y,-π,π},Method->{MaxBend->b},Mesh->All],{{b,120,MaxBend},0,120,Appearance->"Labeled"}]

Cosa succede quando c'è una discontinuità, per esempio di salto? In molti casi Mathematica riconosce che c’è un salto, e dove, analizzando la funzione per via simbolica:

Plot[Sign[x],{x,-5,5}]

Plot[Sign[Sin[(x^2)]],{x,-5,5}]

Plot3D[Sign[x+y],{x,-1,1},{y,-1,1}]

Plot3D[Floor[(x^2)+(y^2)],{x,-2,2},{y,-2,2}]

In altri casi non ci riesce, e disegna un tratto (quasi) verticale al posto del salto:

Plot[Nearest[{1,2,3},x],{x,0,5},Mesh->All]

La funzione Nearest dà il valore della data lista più vicino a x.

Plot3D[Nearest[{1,-1},x+y],{x,-1,1},{y,-1,1},Mesh->All]

Se non si vuole il tratto verticale, usare l'opzione Exclusions e assegnare manualmente i punti di discontinuità, o come lista

Plot[Nearest[{1,2,3},x],{x,0,5},Exclusions->{3/2,5/2},Mesh->All]

oppure come equazione:

Plot3D[Nearest[{1,-1},x+y],{x,-1,1},{y,-1,1},Exclusions->x+y==0]

Le funzioni definite con Piecewise, applicano le Exclusions senza bisogno di chiedere:

Plot[Piecewise[{{-1,x<-1},{1,x≥-1}}],{x,-2,2}]

Plot3D[Floor[(x^2)+(y^2)],{x,-2,2},{y,-2,2}]

Plot3D[Im[Log[x+I y]],{x,-1,1},{y,-1,1}]

Plot3D[Re[Log[x+I y]],{x,-1,1},{y,-1,1}]

Plot3D[Re[Log[x+I y]],{x,-1,1},{y,-1,1},Exclusions->None]

Invece che sopprimere i tratti verticali, li possiamo evidenziare con ExclusionsStyle:

Plot[Floor[x],{x,-4,4}]

Plot[Floor[x],{x,-4,4},ExclusionsStyle->Red]

Plot[Floor[x],{x,-4,4},ExclusionsStyle->Dashed]

Plot[Floor[x],{x,-4,4},ExclusionsStyle->Dotted]

Per esempio, per evidenziare gli asintoti verticali:

Plot[(1/((x^2)-1)),{x,-2,2}]

Plot[(1/((x^2)-1)),{x,-2,2},ExclusionsStyle->Red]

Un altro tipo di asintoto verticale non viene trattato come discontinuità di salto, ed ExclusionsStyle non ha effetto:

Plot[(1/(((x-1))^2)),{x,-2,2},ExclusionsStyle->Red,Exclusions->1]

Grafico base e opzioni di visualizzazione

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

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

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

Le parti principali dell'output sono:
1) il "contenitore" Graphics, che semplicemente istruisce il FrontEnd a mostrare l'output come figura, e non come testo. Bisogna cercare di non confonderlo col comando Plot, che è un programma di calcolo di una certa sofisticazione, il cui risultato finale viene avvolto da Graphics per il consumo umano.
2) un oggetto Line, 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:

graficoDelSeno[[1]]//StandardForm

3) una lista di opzioni di visualizzazione:

graficoDelSeno[[2]]//StandardForm

Si può pensare in questo modo:
1) il Line[] descrive l'oggetto da ritrarre,
2) mentre le opzioni specificano la posizione e i settaggi della macchina fotografica che ritrae l'oggetto.

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, e le opzioni di visualizzazione. 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 dare le nuove opzioni dentro a Show:

Show[graficoDelSeno,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.

Manipulate[Graphics[{Red,Line[{{0,0},{1,0},{2,1},{0,0}}],Blue,Circle[{1,1/2},1/2]},AspectRatio->ar,Background->bg,Axes->ax,PlotRange->pr],
{{ar,1/GoldenRatio,"AspectRatio"},.1,3},
{{bg,White,"Background"},ColorSlider},
{{ax,False,"Axes"},{False,True}},
{{pr,Automatic,"PlotRange"},{0,0},{2,2}}]

AspectRatio

Forse vi ricorderete come Mathematica ci mostra un cerchio o un semicerchio quando usiamo Graphics:

Graphics[Circle[]]

Graphics[Circle[{0,0},1,{0,Pi}]]

Cosa succede se disegnamo il semicerchio come il grafico della funzione x↦(Sqrt[1-(x^2)])?

Plot[(Sqrt[1-(x^2)]),{x,-1,1}]

Se per caso questo semicerchio non vi convince, avete buon occhio. Misurate, e troverete che la larghezza della figura è poco più di una volta e mezza l'altezza, rapporto che poco si addice a un semicerchio. Per capire cosa succede, introduciamo il concetto di AspectRatio, che si potrebbe tradurre alla lettera in "rapporto di aspetto", ma che in italiano non ha un corrispettivo di uso comune.

Chi vuole può guardarsi un filmato sulla storia del rapporto di aspetto nel cinema e TV dalle origini ai nostri giorni: https://vimeo.com/68830569

AspectRatio in Mathematica è il rapporto altezza/larghezza di una figura.
Attenzione: nel dare le proporzioni degli schermi delle TV,  dei monitor e del cinema si usa il rapporto larghezza/altezza (classici sono i rapporti 4/3 e 16/9).
Per default l'AspectRatio restituito da Plot è 1/GoldenRatio:

1/GoldenRatio//FunctionExpand

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

Plot[Sin[x],{x,-π,π},AspectRatio->1/3]

Manipulate[Plot[Sin[x],{x,-π,π},AspectRatio->ar],{{ar,1/GoldenRatio,"AspectRatio"},1/10,5,Appearance->"Labeled"}]

Manipulate[Plot[Sin[x],{x,-π,π},AspectRatio->ar,Background->Yellow],{{ar,1/GoldenRatio,"rapporto larghezza : altezza"},{Automatic->"naturale",1/GoldenRatio->"sezione aurea (1.62:1)",1->"quadrato (1:1)",3/4->"TV vecchio stile (4:3)",9/16->"TV schermo largo (16:9)",2/3->"foto 35mm (3:2)",(Sqrt[2])->"carta A4 (1:(Sqrt[2]))",1/2.40->"Panavision (2.40:1)",1/2.35->"CinemaScope (2.35:1)"}}]

Manipulate[Graphics[{Circle[{0,0},1],Circle[{2,1},2/3],Rectangle[{-1,1},{0,2}]},AspectRatio->ar],{{ar,1/GoldenRatio,"AspectRatio"},{Automatic,1/GoldenRatio,1,3/4,9/16,2/3,(Sqrt[2])}}]

Manipulate[r=.8;Graphics[{Rotate[{Line[{{-1,-1},{1,-1},{1,1},{-1,1},{-1,-1}}],Line[{{1,1},{0,1.5},{-1,1}}],Line[{{-.2,-1},{-.2,0},{.2,0},{.2,-1}}]}/.{a_?NumberQ,o_}:>{1.3a,o},.6Sin@θ],Line[r{{-4,-3},{4,-3},{4,3},{-4,3},{-4,-3}}]},AspectRatio->ar],
{{ar,Automatic,"AspectRatio"},{Automatic,1/GoldenRatio,1,3/4,9/16,2/3,(Sqrt[2])}},{θ,0,2Pi,Pi/100,AnimationRunning->True,AnimationRate->40,ControlType->Animator}]

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

grafico=Plot[Sin[x],{x,-π,π}]

Show[grafico,AspectRatio->1]

oppure 3/4, la proporzione classica dei televisori e dei film fino ai primi anni '50:

Show[grafico,AspectRatio->(3/4)]

Show[grafico,AspectRatio->4/3]

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

Show[grafico,AspectRatio->(9/16)]

o 2/3, quella delle fotografie con pellicola 35mm:

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]

Le figure fatte direttamente con Graphics hanno per default AspectRatio -> Automatic. Confrontate: con il rapporto aureo un cerchio viene disegnato come un'ellisse:

Graphics[Circle[{0,0},1]]

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

La primitiva Point rimane sempre circolare, non diventa ellittica:

Graphics[{Circle[{0,0},1],PointSize[.3],Point[{0,0}]},AspectRatio->1/2]

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

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

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

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

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

Plot3D non sembra usare la sezione aurea, ma piuttosto un rapporto di circa 5:5:2 di (lato x):(lato y):(lato z)

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

Il rapporto (lato x):(lato y):(lato z) è detto BoxRatios. Per avere rapporti "naturali" si può dare BoxRatios -> Automatic:

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

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

Rapporti diversi si dettano con una lista. Per esempio, per avere un cubo si può fare così:

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

PlotRange

Non sempre Mathematica mostra tutto quanto il grafico. Per esempio

Plot[(x^3)-x,{x,-2,2}]

Osservate che mancano le “code” del grafico a sinistra e a destra. I punti sopra la quota 3 e sotto la quota -3 sono assenti anche dalla rappresentazione interna:

Plot[(x^3)-x,{x,-2,2}][[1]]

Per vedere tutto in questo caso bisogna dare l'opzione PlotRange -> All:

Plot[(x^3)-x,{x,-2,2},PlotRange->All]

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:

Plot[(x^3)-x,{x,-2,2},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}:

Plot[(x^3)-x,{x,-1.5,1.5},PlotRange->{-1,2}]

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

Plot[(x^3)-x,{x,-1.5,1.5},PlotRange->{{-1,1.3},{-1,2}}]

Esempio:

strano=Plot[ArcTan[x]+ArcTan[(1/x)]-(π/2),{x,.00000001,1},MaxRecursion->5]

Plot[ArcTan[x]+ArcTan[(1/x)]-(π/2)Sign[x],{x,-1,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}]

Show[strano,PlotRange->{-1,1},Axes->False,Frame->True]

In effetti la funzione è (localmente) costante:

D[ArcTan[x]+ArcTan[(1/x)]-(π/2),x]//Simplify

anche se non è costante globalmente:

Plot[ArcTan[x]+ArcTan[(1/x)]-(π/2),{x,-1,1},Axes->False,Frame->True]

Plot[ArcTan[x]+ArcTan[(1/x)],{x,-1,1},Axes->False,Frame->True]

Mathematica riconosce la costanza anche per via simbolica in alcune situazioni, e in altre dà risultati dubbi:

FullSimplify[ArcTan[x]+ArcTan[(1/x)],x>0]

FullSimplify[ArcTan[x]+ArcTan[(1/x)],x<0]

FullSimplify[ArcTan[x]+ArcTan[(1/x)]==Pi/2,x>0]

FullSimplify[ArcTan[x]+ArcTan[(1/x)]+(π/2),x<0]

FullSimplify[ArcTan[x]+ArcTan[(1/x)]-(π/2),Element[x,Reals]]

FullSimplify[ArcTan[x]+ArcTan[(1/x)]-(π/2)Sign[x],Element[x,Reals]]

ArcTan[x]+ArcTan[(1/x)]-(π/2)Sign[x]/.x->0

FunctionDomain[ArcTan[x]+ArcTan[(1/x)]-(π/2)Sign[x],x]

ArcCot[0]

Plot[ArcTan[x]+ArcTan[(1/x)]-(π/2)Sign[x],{x,-1,1}]

È deludente il seguente risultato nella versione 11.3:

PossibleZeroQ[ArcTan[x]+ArcTan[(1/x)]-(π/2),Assumptions->(x>0)]

FullSimplify[ArcTan[x]+ArcTan[(1/x)]-(π/2),x>0]

La parte del grafico che viene esclusa da PlotRange per default non viene mostrata affatto, ma possiamo scegliere di farla vedere come un tratto orizzontale stilizzato, con l'opzione ClippingStyle:

Plot[1/(x^2),{x,-1,1}]

Plot[1/(x^2),{x,-1,1},ClippingStyle->Dashed]

Plot[1/(x^2),{x,-1,1},ClippingStyle->Red]

ClippingStyle è più utile per grafici in tre dimensioni, dove per default Plot3D mostra le parti fuori dal PlotRange come appiattite:

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

Plot3D[(x^2)+(y^2),{x,-2,2},{y,-2,2},PlotRange->{0,4}]

Plot3D[(x^2)+(y^2),{x,-2,2},{y,-2,2},PlotRange->{0,4},ClippingStyle->None]

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

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->{{-π,-(π/2),0,(π/2),π},{-1,1}}]

Show[grafico,Ticks->{{-π,-(π/2),(π/2),π},Automatic}]

Show[grafico,Ticks->{Range[-Pi,Pi,Pi/3],Automatic}]

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

Show[grafico,Ticks->None]

Show[grafico,Ticks->False]

Show[grafico,Ticks->{}]

Show[grafico,Ticks->{{},{}}]

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

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

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

{x,f[x]}/.sol

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

Ecco il risultato:

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

Show[grafico,
Graphics[{PointSize[Medium],Point[{x,f[x]}/.sol]}],Ticks->Transpose[{x,f[x]}/.sol],PlotRange->{-6,5}]

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,1},Automatic}]

Plot[(x^2)-1,{x,-2,2},Ticks->{{{-1,"(Subscript[x, 1])"},{1,"(Subscript[x, 2])"}},Automatic}]

Plot[(x^2)-1,{x,-2,2},Ticks->{{{-1,"(Subscript[x, 1])"},{1,"(Subscript[x, 2])"}},Automatic},TicksStyle->Directive[Red, Bold]]

Plot[(x^2)-1,{x,-2,2},Ticks->{{{-1,"(Subscript[x, 1])"},{1,"(Subscript[x, 2])"}},Automatic},BaseStyle->{FontFamily->"Times"}]

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

I Ticks. in 3D si comportano in modo per molti versi simile:

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

Plot3D[(x^2)+(y^2),{x,-1,1},{y,-1,1},Ticks->None]

Axes, AxesOrigin, AxesLabel, Frame

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

Plot[Sin[x],{x,-π,π},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,-π,π},Axes->{True,False}]

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

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

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

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

Clear[θ];
Plot[Sin[x],{x,-π,π},AxesLabel->{θ,Sin[θ]}]

Clear[θ];
Plot[Sin[x],{x,-π,π},AxesLabel->Automatic]

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

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

o anche la cornice senza assi:

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

Plot[Sin[x],{x,-π,π},Frame->True,Axes->False,FrameTicks->{{{-1,0,1},{0}},{None,Automatic}},FrameLabel->{"basso","sinistra","alto","destra"}]

Plot[Sin[x],{x,-π,π},Frame->True,Axes->False,FrameTicks->{{{0},None},{{-1,{0,"centro"},1},{.5}}},FrameLabel->{{"sinistra","destra"},{"basso","alto"}}]

In tre dimensioni le tacche sono legate agli assi, i quali di solito sono incorporati nella “scatola” che racchiude il grafico, ma si possono evidenziare togliendo la scatola:

Plot3D[(x^2)+(y^2),{x,-1,1},{y,-1,1},Boxed->False]

Plot3D[(x^2)+(y^2),{x,-1,1},{y,-1,1},Boxed->False,Ticks->None]

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

Plot3D[(x^2)+(y^2),{x,-1,1},{y,-1,1},AxesLabel->{x,y,z}]

Plot3D[(x^2)+(y^2),{x,-1,1},{y,-1,1},AxesLabel->{x,y,z},Ticks->None]

Plot3D[(x^2)+(y^2),{x,-1,1},{y,-1,1},AxesLabel->{x,y,z},Ticks->None,Boxed->False]

Background, PlotLabel

Background è l'opzione per colorare lo sfondo del grafico:

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

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

Plot[Sin[x],{x,-π,π},Background->GrayLevel[0.9]]

Manipulate[Plot[Sin[x],{x,-π,π},Background->GrayLevel[grigio],PlotLabel->Style[(Background->InputForm@GrayLevel[grigio]),Background->White]],{{grigio,1},0,1}]

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

Plot[Sin[x],{x,-π,π},Background->RGBColor[0.8,0.2,0.4]]

Manipulate[Plot[Sin[x],{x,-π,π},Background->RGBColor[r,g,b]],
{{r,0,rosso},0,1},{{g,0,verde},0,1},{{b,0,blu},0,1}]

Manipulate[Plot[Sin[x],{x,-π,π},Background->col],
{col,ColorSlider}]

Plot[x,{x,0,1},Background->Black,PlotStyle->White,AxesStyle->White]

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

Plot[Sin[x],{x,-π,π},PlotLabel->"Grafico del seno\n",AxesLabel->{x,y}]

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,-π,π},Prolog->{Point[{1,1}],Circle[{0,0},1],Line[{{0,0},{π,1}}]}]

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

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

Plot[Sin[x],{x,-π,π},Prolog->{{Red,Disk[{-1,0},1]},Text["prologo",{-1,0}]},Epilog->{{Yellow,Opacity[.5],Disk[{1,0},1]},Text["epilogo",{2,0}]}]

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

Plot[Sin[x],{x,-π,π},Epilog->{PointSize[0.02],Point[{(π/2),1}],Text["max",{(π/2),0.9}],Point[{-(π/2),-1}],Text["min",{-(π/2),-0.9}]}]

Plot[Sin[x],{x,-π,π},Epilog->{PointSize[0.02],Point[{(π/2),1}],Text["max",{(π/2),0.9},Background->Yellow],Point[{-(π/2),-1}],Text["min",{-(π/2),-0.9}]}]

Il posizionamento fine delle scritte si può fare come già spiegato in una lezione precedente:

Manipulate[Plot[Sin[x],{x,-π,π},PlotRange->{-1,2},Epilog->{PointSize[0.02],Point[{(π/2),1}],Text["max",{(π/2),1},{a,b},Background->Yellow]},PlotLabel->Row[{"Text[","\"max\", ",{(π/2),1},", ",{a,b},"]"}]],
{{a,0},-2,2},{{b,0},-6,6}]

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,-π,π},PlotStyle->Dashed]

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

Plot[Sin[x],{x,-π,π},PlotStyle->Gray]

Particolarmente indicato per figure destinate alla stampa:

Plot[Sin[x],{x,-π,π},PlotStyle->Black]

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,-π,π},PlotStyle->Thickness[Large]]

Plot[Sin[x],{x,-π,π},PlotStyle->Directive[Blue,Thickness[0.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->Directive[Blue,Thickness[0.02]]]//InputForm//StandardForm

Ne segue che il PlotStyle non è cambiabile con Show:

grafico=Plot[Sin[x],{x,-π,π}]

Show[grafico,PlotStyle->Red]

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

PlotTheme

Plot[Sin[x],{x,-π,π},PlotTheme->"Web"]

Plot[Sin[x],{x,-π,π},PlotTheme->"Business"]

Plot[Sin[x],{x,-π,π},PlotTheme->"Scientific"]

Plot[Sin[x],{x,-π,π},PlotTheme->"Marketing"]

Plot[Sin[x],{x,-π,π},PlotTheme->"Monochrome"]

Assi con le frecce

Se si vogliono gli assi che terminano con le frecce, si può fare così:

Plot[x^3,{x,-1,1},AxesStyle->Arrowheads[.04]]

Manipulate[Plot[x^3,{x,-1,1},AxesStyle->Arrowheads[ah]],
{{ah,.05,"dimensione freccia"},0,1}]

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

Esempio con tre funzioni:

Plot[{Sin[x],(x^2),(x^3)-x},{x,-π,π}]

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

Clear[x,f,tangente];
(Subscript[x, 0])=-1;
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[Large],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,-π,π},
PlotStyle->{Red,Directive[Blue,Thick],Dashed}]

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

Tooltip, Legended, PlotLabels, Callout

Tooltip assegna un’etichetta che compare quando il puntatore è sopra il grafico della funzione. Per default l’etichetta è la formula della funzione:

Plot[Tooltip[Sin[x]],{x,-π,π}]

Possiamo mettere come etichetta quello che ci pare:

Plot[Tooltip[Sin[x],"funzione seno"],{x,-π,π}]

Plot[{Tooltip[Sin[x],Sin[x]],
Tooltip[Cos[x],Cos[x]]},
{x,-π,π}]

Plot[Tooltip[{Sin[x],Cos[x]}],
{x,-π,π}]

Plot3D[Tooltip[{x+y,(x^2)+(y^2)}],{x,-1,1},{y,-1,1}]

Plot[{Tooltip[Sin[x]],
Tooltip[(x^2)],
(x^3)-x},
{x,-π,π}]

Plot[{Tooltip[Sin[x],"seno di x"],
Tooltip[(x^2),"quadrato"],
Tooltip[(x^3)-x]},
{x,-π,π}]

Plot[{Tooltip[Sin[x],Plot[Sin[x],{x,-2,2}]],
Tooltip[(x^2),"quadrato"],
Tooltip[(x^3)-x,"altro"]},
{x,-π,π}]

Legended stampa un’etichetta esplicativa a fianco del grafico, con lo stile corrispondente alla funzione:

Plot[{Legended[Sin[x],Sin[x]],
Legended[Cos[x],Cos[x]]},
{x,-π,π}]

Plot[{Legended[Sin[x],"seno"],Legended[(x^2),"quadrato"],Legended[(x^3)-x,"altro"]},{x,-π,π}]

Plot3D[{Legended[x+y,x+y],Legended[(x^2)+(y^2),(x^2)+(y^2)]},{x,-1,1},{y,-1,1}]

Plot[{Legended[Sin[x],Sin[x]],Legended[(x^2),(x^2)],Legended[(x^3)-x,(x^3)-x]},{x,-π,π},PlotStyle->{Red,Directive[Blue,Thickness[0.01]],Dashed}]

Un’altra maniera di annotare un grafico è PlotLabels, da non confondere con PlotLabel:

Plot[{Sin[x],(x^2),(x^3)-x},{x,-π,π},PlotStyle->{Red,Directive[Blue,Thickness[0.01]],Dashed},PlotLabels->Automatic]

Plot[{Sin[x],(x^2),(x^3)-x},{x,-π,π},PlotStyle->{Red,Directive[Blue,Thickness[0.01]],Dashed},PlotLabels->Placed[{"seno","quadrato","cubica"},Above]]

Come Tooltip possiamo mettere non solo un testo, ma anche un grafico:

Plot[Tooltip[Sin[x],Graphics[{Circle[],PointSize[Large],Point@AngleVector[t],Point[{0,Sin[t]}],Thick,Circle[{0,0},1,{0,t}],Line[{{0,0},{0,Sin[t]}}],Dashed,Line[{{0,0},AngleVector[t],{0,Sin[t]}}],Text[Style[Sin[x],Large],{0,Sin[t]/2},{0,-1.5}, {0,1}],Text[Style[x,Large],AngleVector[t/2],1.5AngleVector[t/2]]},Axes->True]/.t->.5],{x,-π,π}]

Clear[x];
(Subscript[x, 0])=0.7`;
f[x_]=(x^3)-x;
tangente[x_,x0_]=f[x0]+f'[x0] (x-x0);
Manipulate[
Plot[{Tooltip[f[x],"f[x]"],Tooltip[tangente[x,x0],"retta tangente"]},{x,-2,3},Epilog->{PointSize[0.02`],Point[{x0,f[x0]}]},PlotRange->{{-2,3},{-5,25}}],
{{x0,.7},-2,3}]

Clear[x];
x00=0.7`;
f[x_]=(x^3)-x;
tangente[x_,x0_]=f[x0]+f'[x0] (x-x0);
Manipulate[With[{x0=p0[[1]]},
tangente[x_]=f[x0]+f'[x0] (x-x0);
Plot[{Tooltip[f[x],"funzione"],Tooltip[tangente[x,x0],Row[{"pendenza della retta tangente = ",Rationalize[f'[x0],.1] }]]},{x,-2,3},Epilog->{PointSize[0.02`],Point[{x0,f[x0]}]},PlotRange->{{-2,3},{-6,25}}]],
{{p0,{0.7,f[0.7]}},Locator,Appearance->None},TrackedSymbols:>{p0}]

Clear[x];
x00=0.7;
f[x_]=(x^3)-x;
tangente[x_,x0_]=f[x0]+f'[x0] (x-x0);
Manipulate[With[{x0=p0[[1]]},
Plot[{Legended[f[x],"f(x)"],Legended[tangente[x,x0],Row[{"pendenza= ",Rationalize[f'[x0],.1] }]]},{x,-2,3},Epilog->{PointSize[0.02`],Point[{x0,f[x0]}]},PlotRange->{{-2,3},{-5,25}}]],
{{p0,{x00,f@x00}},Locator},TrackedSymbols:>{p0}]

Un altro modo ancora di etichettare funzioni è Callout:

Plot[{Callout[Sin[x],Sin[x],Right],Callout[(x^2),"quadrato",Left],Callout[(x^3)-x,"polinomio",Left]},{x,-π,π},PlotStyle->{Red,Directive[Blue,Thickness[0.01]],Dashed}]

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,π}];
secondo=Plot[Cos[x],{x,(π/2),((3 π)/2)}];
Show[primo,secondo,PlotRange->All]

Attenzione a cosa succede se si dimentica di dare l’opzione PlotRange->All:

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

Il problema è che il Show prende il valore del PlotRange dal primo grafico, e lo applica a quello finale.

Il problema si ripete qui:

primo=Plot[1/x,{x,0,1}];
secondo=Plot[20+1/x,{x,-1,0}];
Show[primo,secondo]

però mettere PlotRange->All nello Show non è soddisfacente:

primo=Plot[1/x,{x,0,1}]

primo=Plot[1/x,{x,0,1}];
secondo=Plot[20+1/x,{x,-1,0}];
Show[primo,secondo,PlotRange->All]

Qui il problema è che i due grafici separati sono tagliati dai rispettivi PlotRange e PlotRange->All non può far riapparire quanto è stato tagliato. La soluzione è di mettere PlotRange->All ad entrambi i due grafici separati, e poi combinarli con PlotRange->Automatic:

primo=Plot[1/x,{x,0,1},PlotRange->All];
secondo=Plot[20+1/x,{x,-1,0},PlotRange->All];
Show[primo,secondo,PlotRange->Automatic]

Che cosa succede se si dimentica di mettere PlotRange->Automatic nello Show:

primo=Plot[1/x,{x,0,1},PlotRange->All];
secondo=Plot[20+1/x,{x,-1,0},PlotRange->All];
Show[primo,secondo]

Se Mathematica incontra un punto dell'intervallo assegnato in cui la funzione non è definita, salta le parti mancanti:

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

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 π,-π},PlotRange->All];
secondo=Plot[(Sqrt[Sin[x]]),{x,0,π}];
Show[{primo,secondo}]

Un’altra via è di usare la sintassi x∈regione:

Plot[Sin[x],x∈RegionUnion[Line[{{0},{Pi}}],Line[{{2Pi},{3Pi}}]]]

Plot[Sin[x],x∈Line[{{{0},{Pi}},{{2Pi},{3Pi}}}]]

Plot[Sin[x],
x∈ImplicitRegion[Sin[t]≥-1/2&&-Pi≤t≤4Pi,
t]]

Plot[Sin[x],x∈ImplicitRegion[Sin[x]≥-1/2&&-Pi≤x≤4Pi,x],PlotPoints->100]

Dove la sintassi x∈regione brilla è per funzioni di due variabili:

Plot3D[x*Sin[y],{x,y}∈Disk[]]

Plot3D[x*Sin[y],{x,y}∈RegionUnion[Disk[],Polygon[{{0,0},{2,1},{2,-1}}]]]

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,-(π/2),(π/2)},AspectRatio->Automatic]

Non assomiglia a una semiellisse? L'altra metà della semiellisse 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,-(π/2),(π/2)}]

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[Tooltip@{-(Sqrt[Cos[x]]),(Sqrt[Cos[x]]),-ellisseEsplicita,ellisseEsplicita},{x,-(π/2),(π/2)}]

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

Plot[{-(Sqrt[Cos[x]]),Legended[(Sqrt[Cos[x]]),±(Sqrt[Cos[x]])],-ellisseEsplicita,Legended[ellisseEsplicita,"ellisse"]},{x,-(π/2),(π/2)},PlotStyle->{{Black},{Black},{Red},{Red}}]

Plot[{Tooltip[-(Sqrt[Cos[x]]),±(Sqrt[Cos[x]])],Tooltip[(Sqrt[Cos[x]]),±(Sqrt[Cos[x]])],Tooltip[-ellisseEsplicita,"ellisse"],Tooltip[ellisseEsplicita,"ellisse"]},{x,-(π/2),(π/2)},PlotStyle->{{Black},{Black},{Red},{Red}}]

Filling

Con l'opzione Filling si può colorare la regione fra il grafico di una funzione e l'asse x, oppure la regione fra due funzioni:

Plot[Sin[x],{x,-Pi,Pi},Filling->Axis]

Plot[Sin[x],{x,-Pi,Pi},Filling->Bottom]

Plot[{x,Sin[x]},{x,-Pi,Pi},Filling->Axis]

Plot[{x,Sin[x]},{x,-Pi,Pi},Filling->Bottom]

Plot[{x,Sin[x]},{x,-Pi,Pi},Filling->{1->{2}}]

Plot[{x,Sin[x]},{x,-Pi,Pi},Filling->{1->{{2},Yellow},2->Bottom}]

Plot[(x^2),{x,0,1},Filling->Axis]

Plot[{Tooltip[(x^2),quadrato],Tooltip[(x^3),cubo]},{x,0,1},Filling->{1->{2}}]

Plot[{(x^2),(x^3),(x^4)},{x,0,1},Filling->{1->{2},2->{3}}]

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

Plot[Sin[x],{x,0,2π},Filling->Axis,FillingStyle->Yellow]

DiscretePlot, DiscretePlot3D

DiscretePlot[Cos[n],{n,0,100}]

DiscretePlot[(((-1))^n)Cos[n],{n,0,100}]

DiscretePlot3D[Binomial[n,m]/(2^n),{n,1,20},{m,0,20},ExtentSize->Full]

DiscretePlot3D[Binomial[n,m]/(2^n),{n,1,20},{m,0,20}]

ParametricPlot, ParametricPlot3D

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

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):

ParametricPlot[{{t+Sin[t],1+Cos[t]},{Cos[t],1-Sin[t]}},{t,0,4 π},PlotStyle->{Red,Directive[Black,Thick]}]

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

Clear[t];ParametricPlot[{Legended[{Cos[t],Sin[3 t]},{Cos[t],Sin[3 t]}],Legended[{Cos[t],Sin[2 t]},{Cos[t],Sin[2 t]}]},{t,0,2 π}]

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

ParametricPlot può anche dare l’immagine di una regione piana tramite una trasformazione nel piano.
Per esempio, l’immagine del quadrato unitario tramite la trasformazione lineare (x,y)↦(x+y,x-y):

ParametricPlot[{x+y,x-y},{x,0,1},{y,0,1}]

L’immagine del disco unitario tramite la trasformazione non lineare (x,y)↦((x^2)+y,x-y x):

ParametricPlot[{(x^2)+y,x-y x},{x,y}∈Disk[],MeshFunctions->{Function[{x,y,u},u],Function[{x,y,u,v},v]},Mesh->5]

ParametricPlot3D può disegnare una curva parametrica nello spazio tridimensionale, per esempio un’elica:

ParametricPlot3D[{Cos[t],Sin[t],t/4},{t,0,6Pi}]

ParametricPlot3D può disegnare una superficie parametrica nello spazio tridimensionale, per esempio la bottiglia di Klein:

ParametricPlot3D[{((-2)/15)Cos[u](3Cos[v]-30Sin[u]+90((Cos[u])^4)Sin[u]-60((Cos[u])^6)Sin[u]+5Cos[u]Cos[v]Sin[u]),((-1)/15)Sin[u](3Cos[v]-3((Cos[u])^2)Cos[v]-48((Cos[u])^4)Cos[v]+48((Cos[u])^6)Cos[v]-60Sin[u]+5Cos[u]Cos[v]Sin[u]-5((Cos[u])^3)Cos[v]Sin[u]-80((Cos[u])^5)Cos[v]Sin[u]+80((Cos[u])^7)Cos[v]Sin[u]),
(2/15)(3+5Cos[u]Sin[u])Sin[v]},
{u,0,Pi},{v,0,2Pi},PlotStyle->Opacity[.5],Boxed->False,Axes->False]

ContourPlot

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 (più veloce!). Usiamo il comando ContourPlot

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

Il luogo delle soluzioni di una equazione algebrica:

ContourPlot[((x^2)/(2y))+((x (y^2))/3)==x+y,{x,-3,3},{y,-3,3},PlotPoints->150]

Una curva implicita a forma di cuore:

ContourPlot[((((x^2)+(y^2)-1))^3)-(x^2)(y^3)==0,{x,-2,2},{y,-2,2},AspectRatio->Automatic,PlotPoints->150]

La curva a forma di cuore è una delle curve di livello di una funzione di due variabili:

Plot3D[((((x^2)+(y^2)-1))^3)-(x^2)(y^3),{x,-2,2},{y,-2,2},PlotRange->{-1,1},ClippingStyle->None,MeshFunctions->{#3&},PlotPoints->51]

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

Esiste anche ContourPlot3D, che disegna le superfici di livello di una funzione reale di tre variabili:

ContourPlot3D[x^4+y^4+z^4-(x^2+y^2+z^2)^2+3(x^2+y^2+z^2)==3,{x, -2,2}, {y, -2, 2}, {z, -2, 2},Mesh->None,ContourStyle->Directive[Orange,Opacity[0.8],Specularity[White,30]]]

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.

Riprodurre in Mathematica i cartelli stradali di strada dissestata  e di zona soggetta ad allagamento .

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.