Numeri

interi, razionali, reali esatti, reali approssimati, complessi, algebrici, analitici, casuali

Gianluca Gorni
Università di Udine, Dipartimento di Scienze Matematiche, Informatiche e Fisiche

Ultima modifica: 15 dicembre 2017

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 Evaluation > Evaluate Notebook. Oppure selezionare tutto e poi mandare in valutazione.

Inizializzazione

Inizializzazione consigliata:

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

Numeri interi

Le quattro operazioni

I numeri interi in Mathematica sono quantità esatte. Le quattro operazioni si scrivono con + - * /

2+3

2-3

1*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20

6/2

La moltiplicazione si può anche fare con uno spazio invece dell'asterisco. Il sistema visualizza i segni di moltiplicazione, che però non vengono inseriti internamente

1 2 3

La potenza

La potenza si fa in formato ascii (InputForm) con ^:

2^10

Il nome di InputForm ha radici storiche: era il formato normale dell’input nelle primissime versioni di Mathematica. A volte può ancora servire per svelare strutture che altrimenti sono nascoste: convertire la seguente cella in InputForm:

(Entity["Udine", Entity["City",{"Udine","FriuliVeneziaGiulia","Italy"}], "Entity[\"City\", {\"Udine\", \"FriuliVeneziaGiulia\", \"Italy\"}]", "city"])

La notazione bidimensionale (2^10) si può ottenere in diversi modi:

con la tavolozza Palettes ▶ Basic Math Assistant, cliccando sul pulsante nell'angolo in alto a sinistra che contiene lo schema della potenza (■^□) questo schema appare nel cursore; battendo 2 lo schema diventa (2^□); premendo il tasto tabulatore ⇥, oppure cliccando sul quadratino vuoto, lo schema diventa (2^■); battendo 10 lo schema diventa finalmente (2^10).

({{, ,                    }})

NotebookOpen[ToFileName[{$TopDirectory,"SystemFiles","FrontEnd","Palettes"},"BasicMathAssistant.nb"]];

battere 2, poi andare sul menu Insert > Typesetting>Superscript. Il 2 diventa (2^■). Battere 10 e si ha finalmente (2^10).

battere 2 e poi  Ctrl[^]  oppure  Ctrl[6] (le abbreviazioni da tastiera sono indicate nel menu Insert > Typesetting). Il 2 diventa (2^■). Battere 10 e si ha finalmente (2^10).

Un primo piccolo esempio di output dinamico

Un semplice output dinamico: i quadrati dei numeri interi successivi, uno ogni secondo:

n=0;
Dynamic[n++;Pause[1];(n^2)]

Funziona così:
n=0 inizializza la variabile n;
n++ aumenta di 1 il valore di n;
Pause[1] fa fare una pausa per 1 secondo;
(n^2) calcola il quadrato di n;
i punti-e-virgola fanno sì che quello che li precede ha effetto solo dentro al Kernel, senza restituire niente al FrontEnd; (n^2) non ha il punto-e-virgola, per cui il suo valore è restituito al FrontEnd;
Dynamic rispedisce al Kernel il comando ogni volta che la variabile n risulta cambiata:

Se voglio che il valore di n rimanga locale e non interferisca con altri oggetti che contengono n, devo avvolgerlo con DynamicModule:

DynamicModule[{n=0},
Dynamic[n++;Pause[1];(n^2)]]

Variante, coi numeri di Fibonacci:

DynamicModule[{n=0},
Dynamic[n++;Pause[1];Fibonacci[n]]]

Variante, in cui il tempo è segnato da un rintocco:

DynamicModule[{n=0,rintocco=Sound[SoundNote[15,.1,"Percussion"]]},
Dynamic[n++;Pause[1];EmitSound[rintocco];Fibonacci[n]]]

A dire il vero, l'impostazione con n++ non è nello spirito più puro di Mathematica. Meglio sarebbe questo:

Animate[Fibonacci[n],{n,1,Infinity,1},AnimationRate->1]

figura dinamica

DynamicModule[{t=0,n=0,tper=0},Graphics[{Text[Column[{Style[\[MathematicaIcon],FontSize->100],Spacer[10],Style["FrontEnd",Large]},Center],{-1,0}],Text[Column[{Style[\[KernelIcon],FontSize->100],Spacer[10],Style["Kernel",Large]},Center],{1,0}],
Text["MathLink",{0,.1}],
Thickness[Large],Arrow[{{-.4,.4},{.4,.4}}],Arrow[{{.4,-.2},{-.4,-.2}}],Red,
Dynamic[t=Clock[{0,Infinity}];tper=Mod[t,4];n=Ceiling[t/4];If[tper≤2,{Text[Style[DisplayForm@FormBox[RowBox[{"n","=",n-1}],TraditionalForm],Medium],{1.8,0},{1,0}],Text[Style["n++;Pause[1];(n^2)",Medium],{tper/2-.5,.4},{0,-2}]},{Text[Style[DisplayForm@FormBox[RowBox[{"n","=",n}],TraditionalForm],Medium],{1.8,0},{1,0}],Text[Style[(n^2),Medium],{2-tper/2-.5,-.2},{0,-1.5}]}]]},PlotRange->{1.8{-1,1},.7{-1,1}}]]

Fattoriali, radici, classi di resto

La dimensione degli interi in Mathematica è limitata praticamente solo dalla memoria disponibile. Per esempio il fattoriale di 100 è un numero molto grande, e Mathematica lo riporta con tutte le cifre, senza troncare:

100!

I fattoriali dei numeri interi successivi, uno ogni secondo:

DynamicModule[{n=0},
Dynamic[n++;Pause[1];n!]]

Radici

La radice quadrata con Sqrt[ ]:

Sqrt[1024]

Si può anche scrivere (Sqrt[1024]), usando uno di diversi modi ridondanti: la tavolozza, oppure riempendo lo schema (Sqrt[■]), che a sua volta si può far comparire con la tavolozza Palettes ▶ Basic Math Assistant, oppure col menu Insert > Typesetting>Radical, oppure ancora con Ctrl[2] oppure Ctrl[@] .

Si può sempre chiedere in linguaggio naturale inglese, se si è collegati a internet:

Le radici cubiche, quarte ecc. si fanno con la potenza a esponente razionale:

8^(1/3)

(8^(1/3))

oppure con lo shema (■^(1/□)), che compare al solito con la tavolozza, oppure col menu col menu Insert > Typesetting>Radical seguito da Insert > Typesetting>Opposite Position, oppure ancora con Ctrl[2]Ctrl[5]

(8^(1/3))

Quando si prende la radice di un numero negativo o complesso, Mathematica restituisce un valore complesso, basato sul valore principale del logaritmo complesso:

Simplify[(Sqrt[a])==Exp[Log[a]/2]]

Molti rimangono perplessi davanti a questo output:

((-8.)^(1/3))

quando si sarebbero aspettati -2. Se si vuole la radice reale bisogna usare il comando apposito CubeRoot

CubeRoot[-8]

oppure il più generale Surd

Surd[x,3]

Notare la lieve differenza grafica nel simbolo di radice:

Surd[x,2]

(Sqrt[x])

Confrontare la radice quadrata di -1 con Sqrt e con Surd:

Sqrt[-1]

Surd[-1,2]

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

Plot[CubeRoot[x],{x,-1,1}]

Moduli

Il modulo, o classe di resto di n rispetto a m (o quoziente della divisione n:m) si fa con Mod[n,m]:

Mod[13,5]

Con DiscretePlot si fanno rapidamente grafici di funzioni di variabile intera. Per esempio, un grafico dei valori dei resti modulo 5 dei numeri da 0 a 50:

DiscretePlot[Mod[n,5],{n,0,50}]

Un grafico dei valori del fattoriale:

DiscretePlot[n!,{n,0,5}]

Un grafico dei valori della radice quadrata:

DiscretePlot[(Sqrt[n]),{n,0,100}]

Un grafico interattivo delle classi di resto modulo k, in cui k si può scegliere da una barra:

Manipulate[DiscretePlot[Mod[n,k],{n,0,50}],{k,2,20,1,SetterBar}]

Trovate funzioni tipicamente intere nella tavolozza  Palettes ▶ Basic Math Assistant > Basic Commands > Integer Functions

Test di interezza, positività, primalità ecc.

IntegerQ è un test per l'appartenenza di un numero agli interi:

IntegerQ[23]

IntegerQ[1/2]

La Q alla fine di IntegerQ sta per "Question". Ci sono altri test logici il cui nome finisce per Q: EvenQ (dà vero se il numero è pari), OddQ (vero se è dispari), PrimeQ (vero se è un numero primo):

EvenQ[11]

OddQ[11]

PrimeQ[11]

La funzione Prime[n] calcola l'n-esimo numero primo:

Prime[10]

I numeri primi successivi, uno al secondo:

DynamicModule[{n=0},
Dynamic[n++;EmitSound[Sound[SoundNote[15,.1,"Percussion"]]];Pause[1];Prime[n]]]

Ci sono altri test il cui nome non termina per Q: Positive (vero se il numero è positivo), Negative (vero se è negativo) NonPositive (vero se il numero è ≤0), NonNegative (vero se il numero è ≥0):

Positive[3^5]

NonNegative[0]

Negative[0]

Positive[(((-1))^7)]

C'è un alto modo di chiedere se un numero è intero, con sintassi molto diversa:

Element[5,Integers]

che si può anche scrivere nella forma

5∈Integers

Qui il simbolo Integers sta per l'insieme dei numeri interi relativi ℤ. Il simbolo ∈ si può inserire con la tavolozza Palettes>BasicTypesetting, oppure con EscelemEsc o, più brevemente, EscelEsc.
Chi ha familiarità col LATEX può trovare più comodo battere Esc\inEsc.

Il simbolo ℤ si può inserire con EscdsZEsc (double struck Z).

C'è anche il simbolo di non appartenenza: ∉, che si scrive per esempio con Esc!elEsc

4∉Integers

ma comunque c'è anche l'operatore di negazione Not, che si abbrevia con il punto esclamativo:

Not[5∈Integers]

!(5∈Integers)

Che differenza c'è fra IntegerQ[x] e Element[x,Integers]? Il test IntegerQ è un test di "ovvia appartenenza", che restituisce False se appena non sia ovvio che l'oggetto è un intero: per esempio il simbolo a non è un intero, e IntegerQ dà False:

IntegerQ[a]

IntegerQ non esegue il calcolo, e può dare risposte “sbagliate”

IntegerQ[(((1+(Sqrt[2])))^2)-2(Sqrt[2])]

Un vantaggio di IntegerQ è che ha tempo di esecuzione brevissimo e affidabile dentro un programma. Se svolgesse i calcoli non potremmo prevedere quanto ci metterebbe ad eseguirli. Non esiste un algoritmo generale per decidere se un’espressione simbolica corrisponde a un intero o no.

Invece nei casi in cui l'oggetto non sia né ovviamente intero né ovviamente non intero, Element restituisce l'input senza pronunciarsi su vero o falso:

a∈Integers

In TraditionalForm l'oggetto Integers appare come ℤ.

Che differenza c'è fra i test il cui nome termina in Q e gli altri?
La differenza quando l'oggetto da testare non è ovvio se soddisfa o no alla condizione: i test con Q in tali casi restituiscono False, mentre gli altri restituiscono la domanda senza pronunciarsi. Provare:

IntegerQ[x+y z]

Positive[x+y z]

L’uso principale di Element è per dichiarare che un certo simbolo appartiene a un certo insieme numerico:

Simplify[Sin[x+2n π],n∈Integers]

Sintassi standard e tradizionale

Attenzione: se per caso non l'aveste già notato, gli argomenti dei test, e in generale delle funzioni (Sqrt, Positive, Negative, IntegerQ ecc.) sono sempre fra parentesi quadre. Le parentesi tonde sono riservate per specificare l'ordine delle operazioni in una espressione. Questa convenzione distingue Mathematica dalla notazione matematica tradizionale, e bisogna farci l'abitudine al più presto.
Per esempio: Positive(2) viene interpretato come il prodotto dei due simboli Positive e 2, cioè come equivalente di 2*Positive:

Positive(2)

Altro principio generale: i nomi delle funzioni, delle costanti, e in generale dei simboli, in Mathematica cominciano sempre con una lettera alfabetica. Se poi il simbolo è predefinito, la prima lettera è sempre maiuscola, e quasi sempre è un nome scritto per disteso, non un'abbreviazione.

Attenzione: la "forma tradizionale" delle formule non seguono le regole delle parentesi quadre e delle lettere maiuscole. Per esempio nell'output della seguente cella sta scritto log(5), con lettere minuscola e parentesi tonda:

With[{espressione=Log[5]+Cos[4]},
TabView[{"Forma standard"->StandardForm[espressione],"Forma tradizionale"->TraditionalForm[espressione]}]]

Si raccomanda di non abituarvi a scrivere i vostri input nella sintassi tradizionale, perché spessisimo mandano Mathematica in confusione. Pericoloso è pure copiare e incollare un output in forma tradizionale; il risultato è imprevedibile. È prudente, prima di copiare un output tradizionale, convertire la cella in formato standard, usando il menu Cell > Convert To > StandardForm

Il pericolo è segnalato dalla quadra a margine delle celle tradizionali, che è tratteggiata:

cos(4)+log(5)

Consiglio di scrivere in formato standard e poi, volendo, convertire in tradizionale col menu

Cos[4]+Log[5]

Sintassi alternative senza parentesi

Con le funzioni di una variabile si possono usare due sintassi alternative in cui non c'è bisogno di mettere le parentesi quadre: la notazione Prefix e la Postfix: i seguenti costrutti sono equivalenti:

normale (con le parentesi quadre):

f[x]

prefisso (funzione, chiocciola e argomento, at):

f@x

suffisso (argomento, due slash e poi funzione):

x//f

Il non dover scrivere le parentesi è molto comodo quando per esempio si deve aggiungere una funzione all'interno di una espressione complicata e già scritta.

Esempi:

Log[Sqrt[x]]

Log@Sqrt@x

x//Sqrt//Log

La notazione con prefisso @ ricorda da vicino la notazione matematica della composizione di funzioni col cerchietto f ◦ g(x), con la differenza che @ si può usare anche per l’argomento finale.

Chi vuole il cerchietto (ma solo per belleza, non per fare i calcoli) può inserirlo con l’alias TEX Esc\circEsc.

Numeri razionali

Le frazioni: come si scrivono

Le frazioni si scrivono con il segno di frazione diagonale /, mentre nell'output vengono col segno di frazione orizzontale:

12/5

Si può anche inserire una frazione in input nella forma (n/m). Ci sono diversi modi:

(facile da ricordare ma lungo) usando la tavolozza Palettes ▶ Basic Math Assistant
 e cliccando sulla frazione (■/□), e poi riempiendo i quadrati;

(lunghetto) scrivendo il numeratore n e poi scegliendo dal menu Insert > Typesetting>Fraction

(veloce) scrivendo il numeratore n e poi premendo Ctrl[/]

(veloce) scrivendo prima Ctrl[/], poi il numeratore, tasto tabulazione ⇥, e infine il denominatore

Quando si manda una frazione in esecuzione, questa viene ridotta automaticamente ai minimi termini:

(1825/105)

L'espressione decimale di un numero (razionale o non) si ricava con la funzione N:

N[1/3]

N[31/7]

C'è la funzione Rationalize, che cerca un approssimante razionale (con denominatore "piccolo") di un numero in virgola mobile:

Rationalize[0.7777777777777]

Rationalize non trova numeri razionali soddisfacenti nelle vicinaze "immediate" di 0.777777 o di 3.1415926:

Rationalize[0.777777]

Rationalize[3.1415926]

Possiamo comunque allargare la ricerca in un intorno di raggio un millesimo:

Rationalize[0.777777,1/1000]

Disuguaglianze

Confronto di frazioni, o più in generale di due numeri:

(23/8)>(14/5)

(1928347/83746)≤(1230894/8662189)

I segni di ordine debole ≤ e ≥ si scrivono battendo > e = in successione: l'interfaccia utente converte automaticamente la coppia in un simbolo unico.

Cifre decimali, periodo e antiperiodo

La funzione RealDigits dà le cifre decimali di un numero (razionale e non). RealDigits per un numero con forma decilale finita restituisce una lista, il cui primo elemento a sua volta è un elenco di cifre (la prima è non nulla), mentre l'ultimo elemento è un intero che ci dice quante di quelle cifre sono prima della virgola. Per esempio, 1/2 ha espansione decimale 0,5, cioè l'elenco delle cifre (esclusa la prima nulla) è {5}, e di queste cifre nessuna è prima della virgola:

RealDigits[1/2]

31/20 ha espansione decimale 1,55, cioè l'elenco delle cifre (esclusa la prima nulla) è {1,5,5}, e di queste cifre una è prima della virgola:

N[31/20]

RealDigits[31/20]

Il numero di cife prima della virgola può essere negativo:

RealDigits[1/20]

Quando il numero razionale ha forma decimale periodica, come (Row["0", ",", (Row), (OverBar["3"])]), l'output di RealDigits ha come primo elemento una lista che comincia con le cifre dell'antiperiodo (se ce ne sono), seguite dalla lista (fra ulteriori graffe) delle cifre del periodo. In coda c'è di nuovo il numero che dice quante di queste cifre sono prima della virgola:

N[4/3]

RealDigits[4/3]

N[1/3]

RealDigits[1/3]

RealDigits[31/7]

RealDigits[3/70]

Attenzione: RealDigits non tiene conto del segno del numero:

RealDigits[-2]

RealDigits[-2/11]

RealDigits[0]

Possiamo anche ricostruire un numero razionale dalle cifre usando FromDigits:

FromDigits[{{5},0}]

FromDigits[{{5,0,2},0}]

FromDigits[{{5,0,2,{3}},1}]

FromDigits[{{1,4,2,{3,1,2,4}},1}]

Le funzioni RealDigits e FromDigits lavorano anche in base non decimale. Consultare la documentazione per approfondimenti.

Il seguente programmino (i principianti non lo leggano, lo usino e basta) definisce la funzione FormaDecimaleConBarra, che dato un numero razionale restituisce la forma decimale con la barra sopra il periodo, come ci è familiare dall'aritmetica delle scuole elementari e medie:
FormaDecimaleConBarra[1/7] dà (Row["0", ",", (Row), (OverBar["142857"])]),
FormaDecimaleConBarra[152/1300] dà (Row["0", ",", (Row[1, 1]), (OverBar["692307"])]).

prependiZero={{cifre___},primaDellaVirgola_Integer?Negative}:>{{0,cifre},primaDellaVirgola+1};
casoSenzaPeriodo={{cifre__Integer},primaDellaVirgola_Integer}:>Row[{IntegerString[FromDigits[Take[{cifre},primaDellaVirgola]]],",",IntegerString[FromDigits[Take[{cifre},Length[{cifre}]-primaDellaVirgola]]]/."0"->""}];
allungaAntiPeriodo=({{antiperiodo___Integer,{periodo1_,periodo2___Integer}},primaDellaVirgola_Integer}/;Length[{antiperiodo}]<primaDellaVirgola):>{{antiperiodo,periodo1,{periodo2,periodo1}},primaDellaVirgola};
casoConPeriodo={{antiperiodo___Integer,{periodo__Integer}},primaDellaVirgola_Integer}:>Row[{IntegerString[FromDigits[Take[{antiperiodo},primaDellaVirgola]]],",",Row[Take[{antiperiodo},Length[{antiperiodo}]-primaDellaVirgola]],OverBar[IntegerString[FromDigits[{periodo}]]]}];
FormaDecimaleConBarra[n_/;n∈Integers]:=n;
FormaDecimaleConBarra[r_?NonNegative/;r∈Rationals]:=RealDigits[r]//.prependiZero/.casoSenzaPeriodo//.allungaAntiPeriodo/.casoConPeriodo;
FormaDecimaleConBarra[r_?Negative/;r∈Rationals]:=Row[{"-",FormaDecimaleConBarra[-r]}];

FormaDecimaleConBarra[10000/7]

Test di razionalità

Il test per l'appartenenza ai razionali ha sintassi diversa da quello per gli interi: (i colori sono per aiutare l'occhio a distinguere la sintassi)

Element[3/2,Rationals]

o anche

(3/2)∈Rationals

Gli interi sono particolari razionali:

Element[2,Rationals]

Mathematica sa che la radice di 2 non è razionale:

(Sqrt[2])∈Rationals

Chiediamo se  (Sqrt[2])+(Sqrt[3]) è razionale:

(Sqrt[2])+(Sqrt[3])∈Rationals

Mathematica non riesce a decidere. Possiamo chiamare in nostro soccorso algoritmi più potenti con FullSimplify:

FullSimplify[(Sqrt[2])+(Sqrt[3])∈Rationals]

Niente da fare, almeno nella versione corrente (2017-12-15). Strano, perché il comando Reduce dà il risultato in batter d’occhio:

Reduce[(Sqrt[2])+(Sqrt[3])==(n/m),{n,m},Integers]

In TraditionalForm i Rationals si manifestano col carattere ℚ:

a∈Rationals

Osservate come il Kernel vede i numeri razionali:

FullForm[1/3]

ciò nonostante i razionali sono considerati “atomi”, cioè indivisibili ai fini della sintassi:

AtomQ[1/3]

TreeForm[1/3]

Numeri reali esatti (simbolici)

Expand

Mathematica accetta e fa operazioni anche numeri in forma simbolica, esatta:

Sqrt[2]^2

In generale Mathematica non espande automaticamente le potenze o i prodotti di espressioni simboliche non semplicissime:

((((Sqrt[2])+(Sqrt[3])))^2)

Per espandere le potenze usare Expand:

Expand[((((Sqrt[2])+(Sqrt[3])))^2)]

Expand si trova nella tavolozza insieme con altre funzioni che manipolano espressionio algebriche:


Ci sono due modi di usare la tavolozza per funzioni come Expand, a seconda che quando si clicca ci sia un qualche input selezionato oppure no. Se c'è un input selezionato, l'Expand ci si avvolge attorno; altrimenti compare lo schema Expand[expr] in cui expr è già selezionata, e si può direttamente riempire scrivendo da tastiera, senza altri clic.

Si può usare la tavolozza per manipolare una formula un passo alla volta: se vogliamo espandere il quadrato senza toccare il resto

((((Sqrt[2])+(Sqrt[3])))^2)-3((Sqrt[6])-(Sqrt[3]))

selezioniamo il quadrato, lo avvolgiamo con Expand tramite la tavolozza (o anche manualmente)

Expand[((((Sqrt[2])+(Sqrt[3])))^2)]-(Sqrt[6])

poi selezioniamo Expand[((((Sqrt[2])+(Sqrt[3])))^2)] e usiamo il menu Evaluation > Evaluate in Place

5+2 (Sqrt[6])-(Sqrt[6])

Come passare da un'espressione a un'altra: FlipView e TabView

Un primo esempio di FlipView: cliccate ripetutamente sull'output

FlipView[{((((Sqrt[2])+(Sqrt[3])))^2),Expand[((((Sqrt[2])+(Sqrt[3])))^2)]}]

Con TabView si può dare un'etichetta ("tab") alle due formule: si passa dall'una all'altra cliccando sull'etichetta

TabView[{"originale"->((((Sqrt[2])+(Sqrt[3])))^2),"espanso"->Expand[((((Sqrt[2])+(Sqrt[3])))^2)]}]

Il simbolo -> si ottiene scrivendo successivamente i caratteri -> : alla battitura successiva la combinazione -> viene automaticamente convertita in una freccia.

->a

Pi greca e il numero di Nepero

Una delle costanti reali note a Mathematica è pi greca, che si scrive (in versione ascii) con Pi:

3<Pi<Sqrt[10]

Invece di Pi si può anche scrivere π, che compare nella solita tavolozza Palettes ▶ Basic Math Assistant, oppure con EscpEsc.

3<π<(Sqrt[10])

Il numero di Nepero si scrive in versione ascii con E (maiuscolo!). Lo si può anche scrivere in minuscolo, però Mathematica gli riserva il simbolo speciale e, che si trova nella solita tavolozza Palettes ▶ Basic Math Assistant

accanto a π, oppure con EsceeEsc (attenzione alle due "e"). L'abbreviazione da tastiera è riportata nel riquadro giallo che compare quando si tiene il puntatore sopra il pulsante della e.

E-E

Test di realità

Il test per l'appartenenza ai reali è simile a quello per i razionali:

π∈Reals

(Sqrt[-1])∈Reals

Element[(2/5),Reals]

I test Positive, Negative, NonNegative, NonPositive funzionano anche sui reali esatti.

Positive[(((1+(Sqrt[2])))^2)-3(Sqrt[2])]

Anche Rationalize funziona con numeri reali esatti:

Rationalize[π,1/1000]

Reali approssimati in virgola mobile

La funzione N

I numeri decimali in virgola mobile si scrivono alla maniera anglosassone, col punto:

3.14

Per avere la versione decimale approssimata di un numero simbolico esatto usare la funzione N:

N[1/3]

N[Sqrt[2]]

TabView[{"esatto"->π,"approssimato"->N[π]}]

TabView[{"esatto"->π,"approssimato"->N[π]},Alignment->Center]

La funzione N mostra solo poche cifre decimali, ma internamente il nòcciolo ne tiene molte di più, non temete: precisamente 16, cioè quelle di un numero macchina. Un modo per vedere tutte le cifre interne è di scrivere FullForm:

N[(1/3)]

FullForm[N[(1/3)]]

Cosa vuol dire il segnetto ` alla fine? Indica che la cifra precedente è l'ultima significativa.

Si può anche specificare quante cifre significative calcolare di un numero in partenza esatto: per esempio, se voglio 100 cifre decimali di (Sqrt[2]) scrivo

N[(Sqrt[2]),100]

Manipulate[(Sqrt[2])≈N[(Sqrt[2]),n],
{{n,5,"cifre decimali"},
{5,10,20,50,100,1000,10000},SetterBar}]

Manipulate[DisplayForm[FormBox[HoldForm[(((Sqrt[163])π)/(Log[(640320^3)+744]))],TraditionalForm]]≈N[(((Sqrt[163])π)/(Log[(640320^3)+744])),n],
{{n,5,"cifre decimali"},
{5,10,20,30,40,1000,10000},SetterBar}]

Cosa succede quando si chiede una precisione minore della precisione macchina? Qui il comportamento è cambiato nella versione 5 di Mathematica, per cui il seguente comado potrebbe dare risultati diversi a seconda della versione:

N[(Sqrt[2]),4]

FullForm[N[(Sqrt[2]),4]]

Per avere pieno controllo sulla formattazione di un numero in virgola mobile c'è il comando NumberForm, a cui rimandiamo gli interessati:

NumberForm[N[(Sqrt[2])],9]

RealDigits funziona anche con numeri reali approssimati:

RealDigits[N[E]]

Statistica sulle cifre dell'espansione decimale di e, π, (Sqrt[2]) con n cifre, per farsi un'idea se sono equamente distribuite:

Manipulate[Histogram[First@RealDigits[N[numero,n]],10,PlotRange->{{0,10},All}],
{numero,{π,E,(Sqrt[2])}},
{n,(10^(Range[1,5]))}]

Operazioni

Quando in un'espressione ci sono mescolati numeri esatti e in virgola mobile, Mathematica automaticamente converte tutto in virgola mobile. Per esempio, la seguente espressione è simbolica esatta, e il nòcciolo la lascia com'è:

1+(Sqrt[2])

Se invece di 1 scrivo il numero in virgola mobile 1. anche la radice quadrata diventa in virgola mobile e la somma viene eseguita:

1.0+(Sqrt[2])

Mathematica tratta molto diversamente i numeri esatti da quelli in virgola mobile. Il seguente conto esatto dà per risultato esattamente zero:

((((Sqrt[2])))^2)-2

mentre se la radice quadrata è in virgola mobile non viene esattamente zero:

((N[(Sqrt[2])])^2)-2

Occasionalmente si ottengono risultati inattesi usando N:

Pi*Rationalize[1/Pi,1/(10^30)]

Se non si specifica una precisione, N esegue i calcoli coi numeri reali macchina, ma tiene traccia della precisione del risultato, che può essere molto misera:

N[136308121570117 π-428224593349304]

(10^30)N[136308121570117 π-428224593349304]//FullForm

Imponendo a N un certo numero di cifre significative, il calcolo è eseguito con numeri in virgola mobile di precisione arbitraria, decisa caso per caso dagli algoritmi interni, in modo che il risultato finale abbia il numero di cifre significative desiderato:

(10^30)N[136308121570117 π-428224593349304,10]

N[136308121570117 π-428224593349304,20]

A volte viene comodo il comando Chop, che taglia via i numeri in virgola mobile vicini allo zero-macchina e lascia invariati gli altri:

Chop[.0000001]

Chop[.00000000001]

Test

I test per l'appartenenza ai reali funzionano anche per i numeri in virgola mobile:

.33333∈Reals

Notare che agli Integers e ai Rationals possono appartenere solo numeri esatti:

1.0∈Integers

1.0∈Reals

I due oggetti 1/2 e 0.5 sono distinti:

.5∈Rationals

(1/2)∈Rationals

(1/2)∈Reals

Se non specifichiamo la precisione, N[] lavora con numeri macchina con precisione macchina di 16 cifre decimali:

N[(Sqrt[2])]//Precision

N[(Sqrt[2])]//Precision//N

Precisione in partenza e in arrivo

Consideriamo questo numero esatto:

numeroEsatto=12738103345051546-9007199254740992 (Sqrt[2]);

Applichiamogli N[]:

N[numeroEsatto]

Chiediamo invece il valore con 16 cifre decimali:

N[numeroEsatto,16]

Come mai viene diverso da sopra?
La cosa è sottile: le 16 cifre che chiediamo con N[numeroEsatto,16] sono la precisione in arrivo. Invece con N[numeroEsatto] si chiedono 16 cife di precisione in partenza. Questo numero x è scelto perversamente: se si parte con (Sqrt[2]) di 16 cifre, ci sono degli errori di cancellazione che rendono il risultato finale di precisione bassissima:

N[numeroEsatto]//FullForm

Invece chiedendo N[numeroEsatto,16], il programma calcola (Sqrt[2]) con precisione molto più alta di 16 cifre, in modo che al netto degli errori di cancellazione il risultato finale abbia 16 cifre significative:

N[numeroEsatto,16]//FullForm

Morale: N[numeroEsatto] è più veloce ma meno preciso di N[numeroEsatto,16]. Ci sono casi in cui la differenza è vistosa.

Overflow e underflow

Può Mathematica andare in overflow o underflow lavorando con numeri in virgola mobile? Certamente sì, se esaurisce la memoria a disposizione. Il più grande numero macchina gestibile su questo computer è

$MaxMachineNumber

$MinMachineNumber

Se in un calcolo si supera tale valore, entra in gioco l'aritmetica a precisione arbitraria. Questa non è completamente arbitraria (come potrebbe???), ma per lo meno porta il massimo numero (in virgola mobile) gestibile (sempre su questa macchina) al seguente:

$MaxNumber

Provate per esempio a calcolare 2*$MaxNumber.

$MinNumber

Numeri complessi

L'unità immaginaria si scrive in input ascii con I; l'output ha un formato speciale:

(((1+I))^2)

Sqrt[-1]

La lettera i in input si può ricavare dalla tavolozza Palettes>BasicMathInput, oppure battendo EsciiEsc.

Attenzione: per Mathematica la radice cubica dei numeri negativi è la cosiddetta "radice principale", che non è reale. Per esempio, la radice cubica di -8 non è -2, anche se di primo acchito non è chiaro:

((-8)^(1/3))

Il valore in virgola mobile:

N[((-8)^(1/3))]

Per separare parte reale e parte immaginaria c'è ComplexExpand:

ComplexExpand[((-8)^(1/3))]

FlipView[{((-1)^(1/3)),ComplexExpand[((-8)^(1/3))]}]

Parte reale e parte immaginaria si estraggono anche con Re e Im:

Re[((-8)^(1/3))]

Im[((-8)^(1/3))]

ReIm[((-8)^(1/3))]

ReIm[((-8)^(1/3))]

With[{z=((-8)^(1/3))},
TabView[{"radice cubica"->HoldForm@((-8)^(1/3)),N->(HoldForm[((-8)^(1/3))]≈N[z]),
ComplexExpand->HoldForm[((-8)^(1/3))]==ComplexExpand[z],
Re->Re[z],
Im->Im[z],
ReIm->ReIm[z],
"grafico"->Graphics[{PointSize[.02],Point[{Re[z],Im[z]}]},PlotRange->3,Axes->True]},Alignment->Center]]

(N, Re, Im e Mod sono alcuni dei rari esempi di funzioni di Mathematica il cui nome è un'abbreviazione, invece di una parola o frase completa).

Altro modo ancora di decidere se (8^(1/3)) è reale è di fare direttamente la domanda:

((-8)^(1/3))∈Reals

C'è un buon motivo per questa scelta, ma lo si capisce solo quando si conoscono i numeri complessi. Se si vuole la radice cubica tradizionale si può prendere la radice cubica del valore assoluto e poi cambiare di segno:

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

Plot[CubeRoot[x],{x,-8,8}]

Mathematica dà la radice cubica "principale", che segue la regola del tergicristallo: se si chiede la radice quadrata, cubica ecc. principale di qualcosa, Mathematica prende un tergicristallo incardinato nell'origine e con un fermo sull'asse reale negativo, e lo fa girare in senso orario o antiorario fino a quando raggiunge il numero di cui estrarre la radice (se il numero sta sull'asse reale negativo si intende che l'angolo è π, non l'opposto); quindi divide l'angolo che il tergicristallo forma con l'asse reale positivo, e lo divide per 2 (o per 3, ecc.). La radice algebrica si trova lungo il raggio ottenuto dalla divisione.
Per esempio con la radice cubica di -8:

Graphics[{{Gray,Disk[{0,0},8,{0,Pi}]},{LightGray,Disk[{0,0},2,{0,Pi/3}]},Circle[{0,0},2],PointSize[.03],{{Red,Point[{-8,0}]},Point[{Re[z],Im[z]}],Text[Re[z]+I Im[z],{Re[z],Im[z]},{0,-2}]}/.Solve[(z^3)==-8,z]},AspectRatio->Automatic,Axes->True,PlotLabel->"Radici cubiche algebriche di -8",PlotRange->8.2,Ticks->{{-8},None}]

Per le radici quadrate di 1+i:

With[{z0=1+I},
sol=Solve[(z^2)==z0,z];Graphics[{{Gray,Disk[{0,0},Sqrt@2,{0,Arg[z0]}]},{LightGray,Disk[{0,0},Sqrt@Sqrt@2,{0,Arg[z0]/2}]},Circle[{0,0},Sqrt[Abs[z0]]],PointSize[.03],{Red,{Point[{Re[z],Im[z]}],Text[1+I,{Re[z],Im[z]},{0,-2}]}/.z->z0},{Point[{Re[z],Im[z]}],Text[z,{Re[z],Im[z]},{0,-2}]}/.sol},AspectRatio->Automatic,Axes->True,PlotLabel->"Radici quadrate algebriche di 1+I"]]

Un pannello interattivo per impratichirsi con le radici ennesime dei numeri complessi. Il numero z si può muovere col mouse, e le posizioni della radice aritmetica e di quelle algebriche si aggiornano in tempo reale.
Osservate la discontinuità della radice (z^(1/n)) quando z attraversa l'asse reale negativo.

Manipulate[z0={1,I}.pt;
radice=(z0^(1/n));
coordinateRadice={Re[radice],Im[radice]};
sol=Solve[(z^n)==z0,z];Graphics[{{Gray,Disk[{0,0},Abs[z0],Sort[{0,Arg[z0]},Less]]},{LightGray,Disk[{0,0},Abs[radice],Sort[{0,Arg[z0]/n},Less]]},{Red,Locator[pt],Text[z,pt,-4Normalize[pt]]},Text[(z^(1/n)),coordinateRadice,-3Normalize[coordinateRadice]],
If[n==2,Text[-(z^(1/n)),-coordinateRadice,-3Normalize[-coordinateRadice]],Sequence@@{}],Circle[{0,0},Abs[radice]],PointSize[.03],Point[{Re[z],Im[z]}]/.sol},AspectRatio->Automatic,Axes->True,PlotRange->2,PlotLabel->Style[Framed["Radici "<>Which[n==2,"quadrate",n==3,"cubiche",n==4,"quarte",n==5,"quinte"]<>" aritmetiche e algebriche di "Style[z,Red]],FontSize->14],
AxesLabel->{"ℝ","I ℝ"},Ticks->{Range[-2,2],Transpose[{Range[-2,2],I*Range[-2,2]}]}],
{{pt,{-.5,1.6}},Locator},
{{n,2,"indice di radice"},{2,3,4,5}}]

Il test per un numero complesso è Element[z,Complexes]:

I∈Complexes

3.14∈Complexes

1+3.14I∈Complexes

Numeri algebrici

Un numero algebrico è una radice di un polinomio a coefficienti interi. Per esempio (Sqrt[2]) è radice di (x^2)-2, 1-(Sqrt[3]) è radice di (x^2)-2x-2; quindi (Sqrt[2]) e 1-(Sqrt[3]) sono numeri algebrici. Non sempre i numeri algebrici hanno una rappresentazione in termini di radicali; anche quando c'è, la rappresentazione può essere molto complicata. Per esempio, le soluzioni di equazioni di terzo e quarto grado si possono rappresentare con radicali, ma le formule sono pesantissime: guardate per esempio una delle radici di (x^4)+2(x^3)-3x+1:

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

I numeri algebrici comunque sono trattabili e manipolabili anche se non si hanno espressioni con radicali. Mathematica ha una sua sintassi per esprimere i numeri algebrici:

Root[polinomio, variabile, numero d'ordine]

Per esempio, la prima radice del polinomio (x^4)+2(x^3)-3x+1 si può scrivere così:

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

Questa sintassi è accettata da Mathematica ed è più naturale per gli umani, ma Mathematica per i suoi scopi la converte subito nel suo formato interno leggermente criptico per chi non c'è abituato:

Root[1-3 #1+2 ((#1)^3)+((#1)^4)&,1]

Qui il simbolo #1 sta per l'argomento numero 1 della funzione (in questo caso funzione polinomiale di una variabile), quello che un umano scriverebbe con x. L'& commerciale indica "qui termina la formula della funzione". Indicare il nome della variabile non serve, perché è standardizzata in #1.
In StandardForm e internamente i monomi sono ordinati in ordine crescente di grado. Invece in TraditionalForm l'ordinamento è in ordine decrescente:

Root[1-3 #1+2 ((#1)^3)+((#1)^4)&,1]//StandardForm

Root[1-3 #1+2 ((#1)^3)+((#1)^4)&,1]//TraditionalForm

A tutti gli effetti un oggetto del tipo Root[] è da considerare un numero simbolico esatto (se il polinomio sottostante è esatto). Il valore in virgola mobile si calcola con N:

N[Root[1-3 #1+2 ((#1)^3)+((#1)^4)&,1]]//FullForm

N[Root[1-3 #1+2 ((#1)^3)+((#1)^4)&,3],1000]

Si può fare anche il percorso a ritroso: da un numero in virgola mobile a un approssimante algebrico, usando RootApproximant. Prendiamo per esempio il rapporto fra due numeri successivi di Fibonacci: con 8 cifre decimali:

((Fibonacci[1001])/(Fibonacci[1000]))

N[((Fibonacci[1001])/(Fibonacci[1000])),8]

C'è un numero algebrico molto vicino, che, guarda caso, è la sezione aurea:

RootApproximant[1.6180340]

Lo si trova con RootApproximant, che è un parente di Rationalize.

C'è un test di appartenenza anche per i numeri algebrici:

Element[(Sqrt[2]),Algebraics]

(Sqrt[3])-(Sqrt[5])∈Algebraics

Root[(x^4)-3(x^3)+2,x,2]∈Algebraics

π∈Algebraics

E∈Algebraics

π+E∈Algebraics

In TraditionalForm il simbolo per l'insieme degli algebrici è 𝔸.

Sappiamo che l'insieme dei numeri complessi non ha un ordinamento con proprietà simili a quelle dei numeri reali. In base a che criterio sono ordinate le radici di un polinomio?
Il seguente pannello mostra le posizioni delle varie radici col loro numero d'ordine:

Clear[x,a];
Manipulate[
radici=Table[Root[(x^5)+a4 (x^4)+a3 (x^3)+a2 (x^2)+a1 x+a0,x,n],{n,5}];Graphics[{PointSize[.02],Table[{ColorData["Rainbow"][i/5],Point[ReIm@radici[[i]]]},{i,5}],If[num,Table[{ColorData["Rainbow"][i/5],Text[i,ReIm@radici[[i]],2{Cos[2Pi i/5],Sin[2Pi i/5]}]},{i,5}],Sequence@@{}]},Frame->True,PlotRange->3,FrameLabel->{"parte reale","parte immaginaria",None,None}],
Item[Row[{"Le radici del polinomio ","(x^5) + (Subscript[a, 4]) (x^4) + (Subscript[a, 3]) (x^3) + (Subscript[a, 2]) (x^2) + (Subscript[a, 1]) x + (Subscript[a, 0])"}]],
{{a0,0,(Subscript[a, 0])},-2,2,ControlPlacement->Right},{{a1,0,(Subscript[a, 1])},-2,2,ControlPlacement->Right},{{a2,0,(Subscript[a, 2])},-2,2,ControlPlacement->Right},{{a3,0,(Subscript[a, 3])},-2,2,ControlPlacement->Right},{{a4,0,(Subscript[a, 4])},-2,2,ControlPlacement->Right},{{num,False,"con numero d'ordine"},{False,True},ControlPlacement->Bottom},SaveDefinitions->True]

L'ordine parrebbe essere questo: prima le radici puramente reali, in ordine crescente. Poi le radici non reali, dapprima in ordine crescente di parte reale, e, a parità di parte reale, in ordine crescente di parte immaginaria. Si può consulare la documentazione per vedere se abbiamo indovinato o no.

Quando il polinomio intero di cui è radice il numero algebrico è di primo o secondo grado, Mathematica preferisce scrivere l'espressione per radicali:

Root[2x-3,x,1]

Root[(x^2)-2x+3,x,1]

Le radici di un polinomio a coefficienti algebrici sono pure algebriche. Mathematica ci dà d'ufficio un sistema polinomiale a coefficienti interi corrispondente:

Root[(Sqrt[2])(x^3)-I x+2,x,1]

RootReduce riporta a una singola equazione:

Root[(Sqrt[2])(x^3)-I x+2,x,1]//RootReduce

Somma e prodotto e quozionte di numeri algebrici è ancora un numero algebrico. Però Mathematica non lo riconosce direttamente:

Root[(x^4)+2(x^3)-3x+1,x,1]+Root[3(x^3)+x-6,x,1]

Per questo c'è il comando RootReduce:

Root[(x^4)+2(x^3)-3x+1,x,1]+Root[3(x^3)+x-6,x,1]//RootReduce

RootReduce si può usare anche per trovare un polinomio a coefficienti interi di cui una data espressione algebrica è radice:

(Sqrt[2])+(Sqrt[3])//RootReduce

(((Sqrt[2])-(Sqrt[3]))/(1-(Sqrt[5])))//RootReduce

Esiste anche la funzione MinimalPolynomial:

(((Sqrt[2])-(Sqrt[3]))/(1-(Sqrt[5])))//MinimalPolynomial

RootReduce per via "manuale"

Conti come questi si possono anche fare "manualmente" manipolando equazioni. Prima di tutto carichiamo le seguenti definizioni ausiliarie:

Unprotect[Plus];
Unprotect[Power];
Unprotect[Times];
((a_==b_)+c_):=(a+c==b+c);
((a_==b_)*c_):=(a*c==b*c);
(a_==b_)^n_:=(a^n==b^n)
Protect[Plus];
Protect[Power];
Protect[Times];

Poi poniamoci il problema di trovare il polinomio a coefficienti interi di cui è radice (Sqrt[2])+(Sqrt[3]). Cominciamo con l'equazione

Clear[x];
x==(Sqrt[2])+(Sqrt[3])

Eleviamo al quadrato l'equazione: usiamo il simbolo %, che sta per l'ouput immediatamente precedente:

Clear[x];
x==(Sqrt[2])+(Sqrt[3]);
((%)^2)

Espandiamo il quadrato:

Clear[x];
x==(Sqrt[2])+(Sqrt[3]);
((%)^2);
%//ExpandAll

Sottraiamo 5 ad ambo i membri:

x==(Sqrt[2])+(Sqrt[3]);
((%)^2);
%//ExpandAll;
%-5

Eleviamo al quadrato ed espandiamo:

x==(Sqrt[2])+(Sqrt[3]);
((%)^2);
%//ExpandAll;
%-5;
((%)^2)//ExpandAll

Sottraiamo 24 da ambo i membri:

Clear[x];
x==(Sqrt[2])+(Sqrt[3]);
((%)^2);
%//ExpandAll;
%-5;
((%)^2)//ExpandAll;
%-24

Ecco trovato un polinomio a coefficienti interi di cui (Sqrt[2])+(Sqrt[3]) è radice!

Senza i punti e virgole si vedono gli output intermedi:

Clear[x];
x==(Sqrt[2])+(Sqrt[3])
((%)^2)
%//ExpandAll
%-5
((%)^2)//ExpandAll
%-24

Clear[x];
x==(Sqrt[2])+(Sqrt[3]);
((%)^2)//ExpandAll;
%-5;
((%)^2)//ExpandAll;
%-24

Numeri analitici

Con la versione 7 di Mathematica sono stati introdotti dei nuovi numeri, che forse possiamo chiamare "numeri analitici": sono le soluzioni di equazioni trascendenti che contengono funzioni analitiche.
Per esempio, il punto di incontro fra la bisettrice e il grafico del coseno:

Plot[{x,Cos[x]},{x,-Pi,2Pi},AspectRatio->Automatic]

Cos[x]-x==0

Se chiediamo di risolvere l'equazione nell'intervallo [0,2π], Mathematica dà questo risultato

Reduce[Cos[x]==x&&0≤x≤Pi,x,Reals]

Internamente l'oggetto contiene molte più cifre:

radice=Root[{#1-Cos[#1]&,0.7390851332151606416571598004931240519724493544470752692177`20.602059988087557}]

Come nel caso dei numeri algebrici, l'oggetto #1-Cos[#1]& è la funzione da annullare

Plot[x-Cos[x],{x,-Pi,2Pi}]

Il numero 0.73908513321516064166… è un'approssimazione numerica della radice, precisa quanto basta affinché nel raggio della sua precisione ci sia una sola radice esatta dell'equazione.

Potrebbe sembrare che l'oggetto sia soltanto un'approssimazione numerica in virgola mobile. E invece è un oggetto simbolico che si può calcolare con precisione arbitraria, al pari di π e di (Sqrt[2]):

N[radice,2000]

I simboli degli insiemi numerici ℕ, ℤ, ℚ, ℝ, ℂ, 𝔸 in StandardForm

Mathematica ha nel suo repertorio le lettere ℕ, ℤ, ℚ, ℝ, ℂ ecc. Si possono scrivere con le tavolozze Palettes>Basic Typesetting, oppure con EscdsNEsc, EscdsZEsc, EscdsQEsc, EscdsREsc, EscdsCEsc ("ds" sta per "double-struck"). Però Mathematica associa loro significato soltanto in TraditionalForm. Possiamo però dare noi il significato anche in StandardForm coi comandi seguenti. Con l'eccezione di ℕ, basta questo:

ℤ=Integers;
ℚ=Rationals;
ℝ=Reals;
𝔸=Algebraics;
ℂ=Complexes;

Ora possiamo chiedere a Mathematica se è vero per esempio che

4∈ℤ

e Mathematica ci dice di sì.

Per i numeri naturali non c'è un simbolo Naturals predefinito. Ma possiamo definirlo noi, con una sintassi che non è il caso di discutere a questo livello, fidatevi:

Naturals/:Element[n_,Naturals]:=Element[n,Integers]&&n≥0;
ℕ=Naturals;

Ecco che funziona:

3∈ℕ

-5∈ℕ

I∈ℕ

(2/3)∈ℕ

0∈ℕ

1.0∈ℕ

Un elenco comleto dei simboli disponibili a Mathematica si può vedere la documentazione a Listing of Named Characters.

Numeri casuali

Il comando RandomReal[] genera un numero macchina casuale compreso fra 0 e 1:

RandomReal[]

Lo si trova sulla tavolozza  Palettes ▶ Basic Math Assistant > Basic Commands > Random Functions

Ogni volta che si chiama RandomReal[] viene un numero (quasi certamente) nuovo:

RandomReal[]

La distribuzione dei numeri prodotti da RandomReal[] è uniforme sull'intervallo [0,1]. Se si vuole una distribuzione uniforme su un intervallo qualsiasi [a,b] basta scrivere RandomReal[{a,b}]:

RandomReal[{2,3}]

Si può anche generare una lista di numeri casuali con questa sintassi:

RandomReal[{0,1},5]

Per verificare se la distribuzione è uniforme, possiamo farne l'istogramma:

Histogram[RandomReal[{0,1},10000]]

Aumentando il numero di punti si vede che l'istogramma si livella:

Manipulate[Histogram[RandomReal[{0,1},n]],
{n,{10,100,1000,10000,100000}}]

Si possono anche generare numeri interi casuali compresi fra a e b:

RandomInteger[{0,10}]

o, più semplicemente, un numero casuale che vale 0 o 1 con probabilità 1/2:

RandomInteger[]

o ancora una lista di tali numeri, in pratica la simulazione di una sequenza di lanci di monete:

RandomInteger[{0,1},20]

Un'applicazione didattica: generiamo dei numeri interi che si possano scomporre facilmente in fattori primi, da usare per degli esercizi:

(2^(RandomInteger[{1,3}]))*(3^(RandomInteger[{0,2}]))*(5^(RandomInteger[{0,1}]))*(7^(RandomInteger[{0,1}]))*(11^(RandomInteger[{0,1}]))*(13^(RandomInteger[{0,1}]))

Si possono generare numeri casuali secondo le principali distribuzioni non uniformi. Per esempio secondo la distribuzione normale (NormalDistribution, Gaussiana) di media 0 e scarto quadratico medio 1:

RandomReal[NormalDistribution[0,1],10]

Histogram[RandomReal[NormalDistribution[0,1],1000]]

Manipulate[Histogram[RandomReal[NormalDistribution[0,1],n]],
{n,{10,100,1000,10000,100000}}]

Maggiori informazioni nella documentazione: Continuous Distributions, Discrete Distributions.

Divertimenti casuali

Un pulsante che quando cliccato spara un numero a caso:

Button["dammi un numero",Print@RandomReal[]]

Manipulate[x,Button["dammi un numero",x=RandomReal[]]]

Attenzione che il Manipulate precedente assegna dei valori a una variabile globale:

Dynamic[x]

Si può localizzare la variabile con DynamicModule:

DynamicModule[{x=1},
Manipulate[x,Button["dammi un numero",x=RandomReal[]]]]

Un output che dà un numero casuale aggiornato ogni secondo:

Dynamic[RandomReal[],UpdateInterval->1]

Un cursore che salta a una posizione casuale una volta al secondo:

Dynamic[Slider[RandomReal[]],UpdateInterval->1]

o dieci volte al secondo:

Dynamic[Slider[RandomReal[]],UpdateInterval->1/10]

Un punto casuale in un quadrato, aggiornato ogni mezzo secondo

Dynamic[Graphics[{PointSize[Large],Point[RandomReal[{-1,1},2]]},PlotRange->1],UpdateInterval->1/2]

Piove su una mattonella:

DynamicModule[{l={}},Dynamic[Graphics[{PointSize[.02],Point@Refresh[AppendTo[l,RandomReal[{0,1},2]],UpdateInterval->10]},PlotRange->{{0,1},{0,1}},Frame->True,FrameTicks->None]]]

DynamicModule[{l={}},Dynamic[Graphics[Point[AppendTo[l,RandomReal[{0,1},2]]],PlotRange->{{0,1},{0,1}},Frame->True,FrameTicks->None]]]

Piovono coriandoli:

DynamicModule[{l={}},Dynamic[Graphics[{PointSize[Large],AppendTo[l,{Hue[RandomReal[]],Point@RandomReal[{0,1},2]}]},PlotRange->{{0,1},{0,1}},Frame->True,FrameTicks->None]]]

Moto browniano nel piano:

DynamicModule[{brown={0,0}},
Framed@Graphics[Dynamic[Point[brown+=RandomReal[NormalDistribution[0,1/300],2]]],PlotRange->1]]

Un batterio browniano che si riproduce:

DynamicModule[{batteri={{0.,0.}},riproduci,generazione,estrazioni},
riproduci[0,punto_]=punto;
riproduci[1,punto_]:=Sequence@@{punto,punto};
generazione[pts_,prob_]:=(estrazioni=RandomInteger[BinomialDistribution[1,prob],Length@pts];
MapThread[riproduci,{estrazioni,pts}]);
Dynamic[
Graphics[Point[batteri=generazione[batteri,1/50];batteri+=RandomReal[NormalDistribution[0,1/100],{Length@batteri,2}]],
PlotRange->1,PlotLabel->Row[{"popolazione: ",Length@batteri}]]]]

Moto browniano con traiettoria opzionale:

brown={1,1}/2;
recentTraj={brown};oldTrajs={};
Manipulate[
Dynamic[increment=RandomReal[NormalDistribution[0,σ],2];
nextBrown=Mod[brown+increment,1];
If[nextBrown===brown+increment,
AppendTo[recentTraj,nextBrown],
AppendTo[oldTrajs,recentTraj];recentTraj={nextBrown}];
brown=nextBrown;
Graphics[{Point[brown],If[shwTraj,{GrayLevel[.5],Map[Line,oldTrajs],Line@recentTraj},Sequence@@{}]},PlotRange->{{0,1},{0,1}},Frame->True,FrameTicks->None,PlotLabel->"Moto browniano"]],
{{σ,1/200},1/1000,1/100},
{{shwTraj,False,"Mostra il cammino"},{False,True}},SaveDefinitions->True]

Esercizi

Trovare l'espansione decimale, con periodo e antiperiodo, di (120/7).

A che numero razionale corrisponde l'espansione decimale (Row["6", ",", (Row[6]), (OverBar["684210526315789473"])])?

Fare un output dinamico che mostri in successione le potenze intere di i.

Verificare, usando Expand, che il seguente numero è intero:

(1+Sqrt[2])^2-2Sqrt[2]

Che cosa ci aspetteremmo dal conto seguente?

Element[(1+Sqrt[2])^2-2Sqrt[2],Integers]

Per avere il risultato True inserire un Expand al posto giusto.

Se si eleva al quadrato e poi si estrae la radice quadrata, si ritorna al numero di partenza. O no? Che cosa ci si aspetta da (Sqrt[(((-2))^2)])? Far eseguire il conto da Mathematica.

Che numero potrebbe essere (((-8))^(2/3))? Più in generale, cosa sarà una potenza a esponente razionale (x^(n/m))? Cercare di indovinare la regola facendo esperimenti. Guardare la documentazione soltanto alla fine, per la verifica.

Si è detto che i nomi dei simboli cominciano sempre con la lettera alfabetica. Cosa succede se scrivo 3Sqrt[4]? E se scrivo Sqrt3[4]? Uno dei due oggetti è equivalente a 3*Sqrt[4], e l'altro alla funzione (non meglio precisata) di nome "Sqrt3" applicata al numero 4. Morale: posso formare dei simboli mescolando lettere e cifre, basta che il primo carattere sia alfabetico. Inoltre: se il primo carattere è minuscolo sono sicuro che non è un oggetto predefinito in Mathematica.

Tradizionalmente il quadrato del seno di x si scrive (sin^2)x. Questa sintassi è accettata da Mathematica? Provare…

Separare parte reale e immaginaria dei numeri ((3+2i)/(4i-3(i^2)+2)), (e^(π i/3)), Sin[i].

Provare a dividere per zero: 1/0, o 0/0 e vedere cosa succede.

Trovare "manualmente" un polinomio a coefficienti interi di cui (((Sqrt[2])-(Sqrt[3]))/((Sqrt[2])+1)) sia radice. Confrontare col risultato di MinimalPolynomial.