({{}})

({{, ({{"Lezione 1"}, {"I primi 60' con Mathematica"}, {Crescenzio Gallo - Università di Foggia
crescenzio.gallo@unifg.it}})}})

Note:

Il materiale visualizzato durante questo seminario è disponibile per il download all'indirizzo http://www.crescenziogallo.it/unifg/seminario-mathematica-2014/

Il materiale utilizzato è tratto dai webinar pubblicati da Adalta e prodotti dal dott. Roberto Cavaliere (Mathematica Technical Sales Manager, r.cavaliere@adalta.it)

12-26 Giugno 2014

Agenda

L’ambiente Mathematica

Front end e kernel

Primi passi con il front end

Help e Documentation Center

Le Palette

Un help speciale: WolframAlpha e il linguaggio naturale

Le basi del linguaggio Mathematica

Definire variabili e funzioni

Il concetto di opzione

Esempi di funzionalità

Calcolo numerico

Calcolo simbolico

Grafica

Applicazioni dinamiche ed interattive

Sorgenti dati integrate

L’ambiente Mathematica: front end e kernel

L’architettura interna di Mathematica consiste di due moduli separati:

L’interfaccia utente o front end: il modulo dedicato al dialogo con l’utente (interpretazioni delle linee di input e  rappresentazione degli output).

Il motore di calcolo o kernel, dedicato alle computazioni vere e proprie

I due moduli sono in collegamento attraverso il MathLink, una libreria in grado di far dialogare il kernel con diversi altri sistemi.

L’ambiente Mathematica: primi passi con il front end

Notebook, Cell e CellBracket

Quando si utilizza il FE tutte le interazioni tra l’utente e Mathematica avvengono per il tramite di un Notebook

I notebook sono documenti attivi suddivisi in unità chiamate Cell (cella). Ogni cella ha una sua lista di proprietà che possono renderla differente dalle altre sia nell’aspetto che nel comportamento.

Un’altra tipologia di cell bracket che si incontra spesso è quella relativa ai gruppi di celle chiusi.
Quando si hanno più celle in un gruppo si possono nascondere alcune celle, ad esempio il codice per generare un grafico

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

La selezione

Per selezionare solo una parte del contenuto di una cella si può operare in due modi. Il primo è quello usuale di selezionare la parte che interessa con il puntatore del mouse trascinandolo da un estremo all'altro della parte in questione, mantenendo premuto il tasto sinistro del mouse. Il secondo modo è molto utile soprattutto per gestire le singole parti delle celle di input, dove si ha spesso l'esigenza di evidenziare un'espressione o parte di essa. Tale modo di selezione delle parti di una cella si attiva semplicemente con dei click successivi sul tasto sinistro del mouse puntato sulla parte da selezionare.

Solve[{(x^2)-2y+1==0,x-2y+1==0}]

Se si vuole selezionare l’intera cella, ad esempio per modificarne una proprietà generale di cella, bisogna cliccare sulla cell bracket.

Solve[{(x^2)-2y+1==0,x-2y+1==0}]

L’ambiente Mathematica: primi passi con il front end

Mathematica ha poche regole da rispettare in maniera rigorosa per quanto riguarda la sintassi

Eseguire calcoli

Per chiedere l'esecuzione di un calcolo o di un qualsiasi comando, dopo aver scritto l'espressione in una nuova cella bisogna digitare contemporaneamente i tasti ⇧+⏎. Questa combinazione di tasti è stata stabilita dalla Wolfram per lasciare inalternato il significato standard del semplice tasto Invio (⏎) che serve per mandare il testo a capo.

2+2

Maiuscole/minuscole

Mathematica è "case sensitive" ossia fa distinzione tra lettere maiuscole e minuscole. Questo significa che la variabile x è diversa dalla variabile X oppure che il comando Plot non funziona se si scrive plot.

Plot[Cos[x],{x,-3,3}]

Le funzioni native

Per convenzione tutte le parole codice di Mathematica iniziano con una lettera maiuscola. Se una parola codice è composta da due parole, entrambe hanno la prima lettera maiuscola (esempi).

Il significato dei nomi di funzioni

Tutti i nomi di comandi hanno una etimologia che rispecchia il tipo di operazione o calcolo che eseguono (esempi). Se non si ricorda bene il nome di una funzione e la si vuole cercare nella documentazione di Mathematica basta usare parole chiave relative al tipo di operazione che si vuole fare e ricordarsi che Mathematica è scritto in Inglese (esempi).

La moltiplicazione

Si può indicare in diversi modi, quello più diffuso è il carattere Blank ossia lo spazio. Altri simboli sono il classico * o il simbolo × che si ottiene scrivendo \ [Times]

2 x

2*x

2×x

Uso delle parentesi

Come riportato in tabella, gli argomenti delle funzioni o comandi avvengono tramite parentesi quadre [ ] e non tonde ( ) come in molti altri linguaggi. Se vi sono più argomenti essi vengono separati dalla virgola. La sintassi tipica di un comando Mathematica è:

Nome[argomento1, argomento2, ..., opzione1, opzione2, ...]

dove si intende come argomento un’espressione fornita dall’utente come elemento su cui fare i calcoli o le operazioni mentre opzione è una direttiva relativa al particolare comando usato e di cui l’utente ne chiede uno specifico valore (in seguito si riprenderà questo concetto molto importante, degli argomenti opzionali). Vediamo alcuni esempi.

Calcolo di un integrale, dove si specificano solo due argomenti: la funzione integranda e la variabile indipendente rispetto alla quale eseguire l’integrazione:

r=Integrate[x Log[x],x]

Grafico della funzione integrale, dove si specificano solo due argomenti: la funzione da disegnare e l’intervallo per la variabile indipendente (questo argomento è necessario):

Plot[r,{x,0,2}]

Grafico della funzione integrale con l’aggiunta di commento tramite l’argomento opzionale PlotLabel:

Plot[r,{x,0,2}, PlotLabel->r]

Ulteriori dettagli sulla sintassi, sulle nozioni di base e su come Mathematica opera si possono trovare nella sua documentazione.

L’ordine cronologico degli input/output

Quando si valuta una cella, il front end genera una label progressiva del numero di input seguito dal corrispondente output. In questo modo ad ogni passo possiamo sapere quale numero di input abbiamo valutato e, se abbiamo bisogno del corrispondente output, possia ripescarlo senza doverlo ricalcolare.

Quit[]

2+2

3+3

%1

Se inseriamo più di una linea sulla stessa cella di input verranno generati corrispondenti numeri di linea:

2+2;
3+3;
4+4;
5+5

10 è il risultato dell’ultima riga che ha il progressivo In[7]

I predicati

Tutti i comandi che terminano con una Q (che sta per Question) sono funzioni di tipo predicato: sostanzialmente non fanno altro che applicare un test, rispondendo con True o False a seconda che il test sia verificato o meno (lista completa dei predicati).

Le variabili di ambiente

Ci sono diverse variabili di sistema che forniscono informazioni sul sistema installato e su altri aspetti legati anche alla piattaforma. Tali variabili iniziano sempre con il carattere $.

$PasswordFile

$LicenseID

$MachineID

L’ambiente Mathematica: primi passi con il front end

Eseguire calcoli e computazioni: Mathematica come calcolatrice

In molte situazioni viene naturale usare Mathematica come semplice calcolatrice, ossia invocare una o più funzioni per eseguire calcoli specifici in una determinata sequenza per risolvere un problema, semplice o complesso che sia. Ad esempio si vuole disegnare una certa funzione, calcolarne la derivata prima e poi la seconda e visualizzare le tre funzioni contemporaneamente, calcolare l’integrale indefinito e poi quello definito. Questa sequenza di operazioni tipicamente si esegue con una serie di chiamate a funzioni di base.

Disegnare la funzione:

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

Calcolare la derivata prima:

D[2(x^3)-3(x^2)+2x-4,x]

e poi la seconda:

D[2(x^3)-3(x^2)+2x-4,{x,2}]

Verificare quando la derivata seconda si annulla:

Solve[%==0,x]

Visualizzare il grafico della funzione e delle sue due prime derivate:

Plot[{-4+2 x-3 (x^2)+2 (x^3),2-6 x+6 (x^2),-6+12 x},{x,-3,3}]

Calcolare l’integrale indefinito:

Integrate[2(x^3)-3(x^2)+2x-4,x]

e poi quello definito:

Integrate[2(x^3)-3(x^2)+2x-4,{x,-3,3}]

Si vuole verificare la forma delle soluzioni generali di una equazione di secondo grado del tipo a (x^2) + b x + c == 0

Solve[a x^2+b x+c==0,x]

L’ambiente Mathematica: help e Documentation Center

Mathematica dispone di diversi livelli di help. Quello più semplice è da riga di comando e si ottiene anteponendo il simbolo ? al nome di un comando.

?Integrate

Si può anche utilizzare il carattere jolly * se non si ricorda il nome completo. In tal caso verrà restituito un elenco di tutte le parole codice che contengono le lettere indicate.

?Integ*

Questo tipo di help è molto sintentico, riepiloga il principale compito del comando e la sintassi di base per il caso più semplice. In genere si ricorre a tale help per una veloce consultazione della sintassi e dei casi di utilizzo, quando già si conosce la funzione o il comando da utilizzare. In altri casi è opportuno fare riferimento al sistema completo di help chiamato Documentation Center.

Il campo etichettato SEARCH è quello dove si possono scrivere le parole chiave per la ricerca dei documenti. Se la parola che si inserisce corrisponde esattamente (anche nelle maiuscole) ad una parola codice, viene aperta direttamente la pagina corrispondente alla Reference Page (pagina di riferimento) del comando. In tutti gli altri casi, viene restituita una pagina con dei link alle varie pagine di documentazione dove compare la parola (o le parole) inserita(e). Se non vengono trovati riferimenti viene restituita una pagina vuota. La barra dei comandi del visualizzatore della documentazione (anche riferito come help browser) viene descritta dalla seguente figura:

L’aspetto più significativo da conoscere in merito al centro di documentazione è la struttura organizzativa dei documenti, la loro classificazione ed il loro scopo.

L’intero sistema di documentazione è replicato fedelmente sul web all’indirizzo http://reference.wolfram.com/mathematica/guide/Mathematica.html.
Ciascun tipo di pagina ha una sua struttura ben definita e replicata in tutte le pagine dello stesso tipo. Ad esempio, le pagine di riferimento, che sono quelle più indicative e ricche di informazioni per ciascun comando, hanno la seguente struttura:

La figura che segue mostra la pagina di riferimento per il comando Solve nella sua struttura completa (visibile quando tutti i gruppi di celle sono chiusi) e con la sua configurazione di default ossia con la sezione EXAMPLES espansa:

Nella versione 8 è stato anche aggiunto un ulteriore aiuto “rapido” per l’inserimento celle, quello che compare quando si clicca sul bottone a forma di crocetta a sinistra della barra di inserimento. La figura seguente ne mostra il contenuto:

L’ambiente Mathematica: le Palette

Mathematica dispone anche del meccanismo della Palette, ossia delle pulsantiere che mettono a disposizione le principali funzioni (oltre quelle dei menu) in maniera semplice ed immediata, ossia tramite bottoni.

Esempio di “assistente” per la scrittura di testi: la palette Classroom Assistant (menu Palettes).

Esempio di personalizzazione dei grafici: la palette Drawing Tools (menu Graphics).

Cosa è Mathematica: un help speciale - WolframAlpha e il linguaggio naturale

Con la versione 8 Mathematica integra anche il motore computazionale WolframAlpha. Tra le tante cose che si possono chiedere a WolframAlpha c’è anche il supporto per imparare ad usare Mathematica tramite il linguaggio naturale.

W|A include circa dieci trilioni di data sets sugli argomenti più svariati. Ci sono diversi modi per richiamare WolframApha dall’interno di Mathematica, sia da linea di codice che programmaticamente.

input di Mathematica in linguaggio naturale (Inglese)

interrogazione Wolfram|Alpha

codice inline espresso in linguaggio naturale ed incassato in script di codice Mathematica

Esempi di domande:

Dini surface
Fermat theorem
nutrition facts cheese
population history in Italy
how far is Milan from Rome
GDP history in France
boiling point of sulphur
earthquake in Italy 1980

Tramite la sequenza di tasti SHIFT + CTRL + = si può far comparire il simbolo  che indica un riquadro dentro il quale possiamo scrivere un’espressione in linguaggio naturale e WolframAlpha tenterà di trasformarla in input di Mathematica. Tale riquadro può essere integrato dentro qualsiasi linea di input di Mathematica.

LinguisticAssistant

Manipulate[LinguisticAssistant,{f,{Sin,Cos,Tan,Csc,Sec}}]

Allo stesso modo con la sequenza SHIFT + = si può far comparire il simbolo  che indica un input che verrà elaborato da WolframAlpha e, se esiste una corrispondente espressione Mathematica, verrà fornita, altrimenti verrà dato un output in stile WolframAlpha.

Le basi del linguaggio Mathematica: definire variabili e funzioni

In molti altri casi, dopo poche operazioni ci si rende conto che si comincia ad aver bisogno di sintetizzare il codice, evitare di ripetere alcuni argomenti e dunque si desiderano definire delle variabili. L’assegnazione di un valore ad una variabile può essere fatta principalmente con due comandi: Set (simbolo =) oppure SetDelayed (simbolo :=).

f= 2(x^3)-3(x^2)+2x-4

Plot[f,{x,-3,3}]

d1=D[f,x]

d2=D[f,{x,2}]

Plot[{f,d1,d2},{x,-3,3}]

L’aver definito f come una variabile e non come una funzione, ossia non aver previsto alcun argomento da fornire per poter invocare f, ha da una parte semplificato la scrittura della definizione, ma, dall’altra, l’ha resa più rigida. Infatti, se si desidera cambiare la variabile indipendente nell’istruzione Plot o Integrate, non si può.

Integrate[f,y]

Plot[f,{t,0,10}]

Si provi a vedere la definizione associata ad f

?f

Si comprende che f dipende strettamente dalla variabile chiamata x. Inoltre, se alla x si assegna un valore, f diventerà un numero e non più una funzione ed in alcuni casi questo diventa un problema per la corretta esecuzione delle operazioni. Si riportano alcuni esempi.

x=10

Ovviamente f mantiene sempre la sua definizione

?f

Però non appena si utilizza f in una espressione di input, essa viene sostituita con il suo valore e poi alla x viene a sua volta sostituito il suo valore 10.

D[f,x]

Integrate[f,x]

La Plot funziona, perchè prima di valutare la f essa definisce i valori per la variabile x considerata “interna” alla Plot stessa e poi la sostituisce nella espressione di f.

Plot[f,{x,-2,2}]

Dunque, è sempre preferibile isolare la variabili di un’espressione da quelle “globali”, usando una definizione che preveda anche l’introduzione di argomenti: si passa dal definire una variabile f a definire una funzione f(x). Nel caso precedente:

Clear[f, x]

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

??f

Ora per poter usare f bisogna anche indicare un argomento, che può essere una qualsiasi espressione di Mathematica

f[r]

f[1]

f[Cos[w]]

f["stringa"]

Ora si provi ad osservare cosa succede nel seguente caso.

x=10

g[x_]=-4+2 x-3 (x^2)+2 (x^3)

??g

Si noti che si è usato lo stesso codice per definire f(x)

??f

La differenza tra i due risultati è dovuta al comando Set (simbolo =). Infatti la corretta interpretazione di una riga del tipo

espressione_sinistra = espressione_destra

è la seguente:

"valuta espressione_destra ed il risultato ottenuto assegnalo all'espressione che risulta dalla valutazione di espressione_sinistra".

Entrambe le valutazioni (lato sinistro e destro) vengono effettuate nel momento della definizione. Questo significa che la situazione di memoria corrente influenza la definizione. Da cui nell'esempio precedente la funzione g(x) è diventata un numero perchè al momento della sua definizione la variabile x aveva il valore 10. Dunque g(x) ha preso il risultato della valutazione dell’espressione -4+2 x-3 (x^2)+2 (x^3)

Si riporta un altro esempio, dove la valutazione immediata comporta addirittura un errore.

Clear[f,g,x]

f[x_]=x[[1]]+x[[2]]

Non è possibile definire una funzione che estrae una parte dell’argomento utilizzando il Set perchè il lato destro dell’assegnazione viene valutato immediatamente, ma al momento della sua esecuzione x ancora non esiste: si suppone esisterà quando f verrà invocata. 
Dunque, oltre a Set esiste il comando SetDelayed che consente di rimandare la valutazione del lato destro dell’assegnazione al momento in cui la funzione viene invocata. Si ripropongono gli esempi di prima:

x=10

g[x_]:=-4+2 x-3 (x^2)+2 (x^3)

??g

Plot[g[x],{x,-2,2}]

f[x_]:=x[[1]]+x[[2]]

f[{2,2}]

Le basi del linguaggio Mathematica: Il concetto di opzione

Quasi tutte le funzioni native di Mathematica mettono a disposizione una o più opzioni. Il concetto è molto semplice: ci sono sempre tanti modi diversi per eseguire una certa operazione, spesso con il raggiungimento del medesimo risultato ma con differenti rappresentazioni. Ad esempio, il grafico di una funzione - pur essendo sempre lo stesso - può essere rappresentato in numerosi stili diversi. Anche nel caso degli algoritmi di calcolo, le opzioni possono fornire un comodo strumento per personalizzare l’esecuzione di una determinata operazione.
Vediamo ad esempio quante opzioni ha l’istruzione Plot.

Options[Plot]

Length[%]

Vediamone qualcuna.

La precisione del calcolo (WorkingPrecision)

Plot[(z/(10^15))+Im[WeierstrassZeta[z, {3,4}]],{z,0,1}]

Plot[z/(10^15)+Im[WeierstrassZeta[z, {3,4}]],{z,0,1},WorkingPrecision-> 32]

Clear[f,x]

f=(∫_(-∞)^t)((20 Exp[x])/x)\[DifferentialD]x

Plot[Sin[f],{t,-45,-30}]

Plot[Sin[f],{t,-45,-30}, WorkingPrecision->32]

Plot3D[Sin[x y+10^16],{x,0,3},{y,0,3}]

Plot3D[Sin[x y+10^16],{x,0,3},{y,0,3},WorkingPrecision->20]

Il riempimento dell’area sottostante la curva o tra più curve (Filling):

Plot[Evaluate[Table[BesselJ[n,x],{n,4}]],{x,0,10},Filling->Axis]

Plot[{Sin[x]+x/2,Sin[x]+x}, {x, 0, 10},Filling->{1->{2}}]

Varie possibilità di personalizzare il filling:

Table[Plot[Sin[x],{x,0,2Pi},Filling->f],{f,{Axis,Top,Bottom,0.3}}]

Evidenziare le singolarità (Exclusions / ExclusionsStyle):

Plot[Sin[Floor[x]],{x,0,20}]

Plot[Sin[Floor[x]],{x,0,20},ExclusionsStyle->Directive[{Dashing[{.0025,.01}],Red,Thick}]]

È possibile specificare i punti da escludere:

Plot[(1/((x+(1/4)) (x-(1/2)))),{x,-1,1},Exclusions->{x==-(1/4),x==(1/2)}]

Anche le singolarità eliminabili possono essere indicate utilizzando la stessa tecnica:

Plot[(((x^2)-3 x+2)/(x-2)),{x,0,4},Exclusions->{x==2},ExclusionsStyle->{None,{AbsolutePointSize[6],Red}}]

Plot3D[Floor[x y ],{x,-2,2},{y,-2,2}]

Plot3D[Im[ArcSin[(x+I y)^5]],{x,-2,2},{y,-2,2},ExclusionsStyle->{None,Red},Mesh->None]

DensityPlot[Tan[x y],{x,-2,2},{y,-2,2},ColorFunction->"Rainbow",Exclusions->{Cos[x y]==0}]

Aggiungere elementi non direttamente collegati al calcolo del grafico (Epilog / Inset).

Inset è una direttiva (non un’opzione) che permette di aggiungere un oggetto all'interno di un grafico, ad esempio tramite l’opzione Epilog. Inset è molto più potente della direttiva Text che permette di inserire un testo. Infatti con Inset si possono inserire anche oggetti quali panel, slider, ecc.

gr=Plot3D[Sin[x y],{x,-2,2},{y,-2,2},Axes->False,ImageSize->100,Boxed->False]

Plot[Sin[x],{x,0,2π},Epilog->Inset[gr,{5,.5}]]

gr=RevolutionPlot3D[Sin[x],{x,0,2Pi},{θ,0,Pi/2},Axes->False,Boxed->False,ViewPoint->Front,Mesh->None,BoundaryStyle->Thick]

Plot[Sin[x],{x,0,2π},Epilog->Inset[gr,{4,.5}]]

Dynamic[Plot[Cos[x],{x,-2,2},Axes->assi,ImagePadding->0,Epilog->Inset[Panel[Column[{"Disegna assi",Checkbox[Dynamic[assi]]}]],{1.5,.8}]]]

Vediamo un esempio di opzione per la modifica dell’algoritmo da usare per un determinato calcolo.

NIntegrate[1/Sqrt[x], {x, 0, 1}, MaxPoints -> 20]

Modificando il numero massimo di punti:

NIntegrate[1/Sqrt[x], {x, 0, 1}, MaxPoints -> 1000]

NIntegrate[Exp[Cos[x]],{x,0,10},Method->{"RiemannRule","Type"->"Left"},PrecisionGoal->2]

NIntegrate[Exp[Cos[x]],{x,0,10},Method->{"RiemannRule","Type"->"Right"},PrecisionGoal->2]

Per default Solve utilizza le funzioni inverse per risolvere equazioni complesse non polinomiali.

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

Si può chiedere a Solve di usare il metodo Reduce per trovare il set completo di soluzioni:

Solve[Sin[x]==1/2.,x,Method->Reduce]

Esempi di funzionalità: calcolo simbolico

Es. Equazioni.

Solve[a (x^4)+b x+c==0,x]

Ora anche Solve ammette la specifica del dominio di appartenenza delle variabili.

Solve[a x^2+b x+c==0,x]

Solve[a x^2+b x+c==0,x, Reals]

Utilizzo di Reduce per il calcolo degli asintoti della funzione (1/((y^2)-2)) sfruttando la definizione di limite

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

Reduce[ForAll[M,M>0,Exists[δ,δ>0,ForAll[y,Element[x | y,Reals]&&0<Abs[y-x]<δ,Abs[(1/((y^2)-2))]>M]]],x]

Es. Integrali.

∫(1/((x^5)-1))\[DifferentialD]x

(∫_(-∞)^∞)((Boole[(1/2)<sin(x)<(2/3)])/(x^2))\[DifferentialD]x

Volendo si può chiedere il risultato in forma tradizionale:

TraditionalForm[%]

Aggiungere ipotesi

Assuming[x∈ℝ,∫(Abs[2-(Abs[x])])\[DifferentialD]x]

Series[Min[x^2,1+a]Cos[x]+Sin[x],{x,0,2}]

Series[Min[x^2,1+a]Cos[x]+Sin[x],{x,0,2},Assumptions->a>0]

Esempi di funzionalità: calcolo numerico

Anche dal punto di vista numerico Mathematica ha raggiunto (ed in molti casi superato) i migliori software numerici.

Es. Integrali.

Integrazione numerica di una funzione discontinua:

fun=(Piecewise[{{((Sin[10 x])/(Sqrt[-x])), -∞<x<0}, {(1/(Sqrt[x])), 0<x<1}, {Sin[2000 x] (x^2), 1<x<2}, {((Cos[2 x])/x), 2<x<∞}}]);
TraditionalForm[fun]

Costruiamone il grafico

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

Calcoliamone l'integrale da -∞ a +∞

NIntegrate[fun,{x,-Infinity,Infinity}]

Una delle funzioni più frequentemente utilizzata in Mathematica è la N che serve per convertire una espressione simbolica in un valore numerico. Quando abbiamo terminato un calcolo simbolico e vogliamo vedere il valore numerico possiamo invocare la N sul risultato.

Cos[4]

N[Cos[4]]

Tramite N possiamo scegliere anche il livello di precisione

N[π]

N[π,32]

Gli algoritmi per la gestione della precisione arbitraria nel calcolo numerico sono utilizzati da tutte le funzioni numeriche, anche quelle della grafica.

f=(∫_(-∞)^t)((20 Exp[x])/x)\[DifferentialD]x

Plot[Sin[f],{t,-45,-30}]

Plot[Sin[f],{t,-45,-30}, WorkingPrecision->32]

Anche i numeri random possono avere una precisione arbitraria.

data=RandomVariate[BinormalDistribution[1/2],10^4, WorkingPrecision->120];//AbsoluteTiming

Length[data]

data//First

Se si vuole impostare la precisione uguale per tutti i valori reali nell’ambito di una sessione di lavoro, si può usare la variabile $Pre ed il comando SetPrecision

$Pre=Function[{input},SetPrecision[input,32]];

2+3

Cos[4]

(1/7)

Esempi di funzionalità: la grafica

Mathematica dispone di centinaia di funzioni dedicate espressamente alla grafica in due e tre dimensioni, per funzioni note analiticamente o in forma tabellare. Le principali funzioni sono

?Plot

Plot[{x Sin[1/x],Abs[x],-Abs[x]}, {x,-1/2,1/2}]

Plot[{Exp[x],Log[x],x},{x,-3,3}]

?Plot3D

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

Plot3D[{Re[Sin[x+I y]],Im[Sin[x+I y]]},{x,-2Pi,2Pi},{y,0,2}]

?ContourPlot

{Plot3D[Sin[x y],{x,-2,2},{y,-2,2}],ContourPlot[Sin[x y],{x,-2,2},{y,-2,2}]}

?DensityPlot

{Plot3D[Sin[x y],{x,-2,2},{y,-2,2}],ContourPlot[Sin[x y],{x,-2,2},{y,-2,2}], DensityPlot[Sin[x y],{x,-2,2},{y,-2,2}]}

?LogPlot

LogPlot[Tooltip@{Log[n],n,n Log[n],n^2},{n,10,10^3}]

Esempi di funzionalità: applicazioni dinamiche ed interattive

Mathematica ha rivoluzionato il concetto di computazione interattiva e dinamica, introducendo funzioni dinamiche che istantaneamente creano interfacce intuitive e interattive. Le computazioni sottostanti vengono eseguite in run-time.

Integrate[1/(x^3+1),x]

Alla base di Manipulate c’è la funzione Dynamic

Clear[a,b,c]

Grid[{{"Statico",Solve[a (x^2)+b x + c == 0,x]},{"Dinamico",Dynamic[Solve[a (x^2)+b x + c == 0,x]]}},Alignment->Left,Dividers->All]

Assegniamo ora dei valori ai parametri a, b, c

{a=0,b=1,c=-2}

Si può creare un oggetto di tipo SetterBar per modificare più semplicemente i valori di a, b e c

SetterBar[Dynamic[a],{-1,0,1}]

Panel[
Column[
{Row[{"Imposta a ",SetterBar[Dynamic[a],Range[-5,5]]}],Row[{"Imposta b ",SetterBar[Dynamic[b],Range[-5,5]]}],Row[{"Imposta c ", SetterBar[Dynamic[c],Range[-5,5]]}]}]]

Esempio: un data fitting manuale.

dati=Table[{x,2.5x^2-8x+1.87+RandomReal[{-1,1}]},{x,-2,5,0.05}];

ListPlot[dati]

Manipulate[
Show[
ListPlot[dati],
Plot[a x^2+b x+c,{x,-2,5},PlotStyle->{Thick,Red}],PlotRange->{{-2,5},{-40,40}}],
{a,-10,10},
{b,-10,10},
{c,-10,10}]

Esempio: una interpolazione manuale.

Manipulate[
Plot[InterpolatingPolynomial[pts,x],{x,-2,2},PlotRange-> {{-2,2},{-10,10}},Filling->Axis,FillingStyle->LightGreen,ImageSize->600],{{pts,{{-0.25,0.86},{0.53,0.08},{0.97,0.73},{0.12,0.10},{0.78,0.52}}},{-2,-10},{2,10},Locator,LocatorAutoCreate->True}]

Esempi di funzionalità: le sorgenti dati

Sorgenti dati computabili

Mathematica mette a disposizione una serie di banche dati affidabili, robuste ed aggiornate costantemente. Questo è un elenco completo delle banche dati Computable Data

Vediamone alcuni esempi.

ChemicalData contiene le proprietà di oltre 44.000 compositi:

ChemicalData["SulfurousAcid"]

ChemicalData["SulfurousAcid","Properties"]

ChemicalData["SulfurousAcid","AcidityConstant"]

ChemicalData["SulfurousAcid","MoleculePlot"]

Ovviamente i dati sono disponibili in formato e struttura tali da poter essere immediatamente disponibili in Mathematica. Pertanto, si possono programmare anche complesse applicazioni che sfruttano tali dati e creano report, grafici, modelli, ecc. semplicemente richiedendo i dati ai server Wolfram. Ecco un esempio di come una chiamata a ChemicalData si innesta facilmente in una porzione di codice Mathematica.

Una distribuzione dei pesi molecolari:

all=ChemicalData[];
all=Map[ChemicalData[#,"MolecularWeight"]&,all];
all=Cases[all,_Real];
dist=BinCounts[all,{0,800,20}];

$Pre=Function[{input},SetPrecision[input,6]];

dist=Transpose[{Table[i,{i,20,800,20}],dist}]

ListLogPlot[dist,Filling->Axis]

WeatherData fornisce dati meteo in tempo reale da tutte le stazioni del mondo:

WeatherData[{"Foggia",5}]

stazione="LIBF";

WeatherData[stazione, "Properties"]

$Pre=.

WeatherData[stazione, "Temperature","DateValue"]

DateListPlot[WeatherData[stazione, "MeanTemperature", {{2000,12,31},{2013,12,31}, "Month"}], Joined->True,Filling->Bottom]

DateListPlot[WeatherData[stazione, "Temperature", {{2011,1,1},{2011,6,1}, "Month"}], Joined->True,Filling->Bottom]

min=WeatherData[stazione, "MinTemperature", {{2009, 1, 1}, {2009, 12, 31}, "Day"}];
max=WeatherData[stazione, "MaxTemperature", {{2009, 1, 1}, {2009, 12, 31}, "Day"}];

DateListPlot[{min,max}, Joined->True,Filling->{1->{2}}]

Conclusioni

Mathematica è un ambiente molto potente sia per il calcolo sia per lo sviluppo di applicazioni. La sua sintassi è molto semplice ma sicuramente prendere dimestichezza con tutte le sue funzionalità richiede un periodo iniziale di training. 

L’importante è comprendere non solo le regole di sintassi e di utilizzo delle varie funzioni ma anche il concetto di linguaggio simbolico e stile funzionale di programmazione.