Introduzione a Mathematica

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

Numeri:
 interi, razionali, reali esatti, reali approssimati, complessi, algebrici, casuali

Ultima modifica: 11 maggio 2007

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

Inizializzazione

Inizializzazione consigliata:

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

Numeri interi

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. La potenza si fa con ^:

2^10

oppure con la notazione bidimensionale (2^10), che si può ottenere in diversi modi:

con la tavolozza File>Palettes>BasicInput, 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).

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

battere 2 e poi  Ctrl[^]  oppure  Ctrl[6]. Il 2 diventa (2^■). Battere 10 e si ha finalmente (2^10).

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!

La radice quadrata con Sqrt[ ]:

Sqrt[1024]

Si può anche scrivere (Sqrt[1024]), usando la tavolozza, oppure riempendo lo schema (Sqrt[■]), che a sua volta si può far comparire con la tavolozza File>Palettes>BasicInput, oppure col menu Edit>Expression Input>Radical, oppure ancora con Ctrl[2] oppure Ctrl[@] .

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 Edit>Expression Input>Radical seguito da Edit>Expression Input>Opposite Position, oppure ancora con Ctrl[2]Ctrl[5]

(8^(1/3))

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]

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]

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 File>Palettes>BasicInput (colonna di destra verso metà), oppure con EscelemEsc.

Che differenza c'è fra IntegerQ[] e Element[,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]

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 ℤ.

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:

Log[5] + Cos[4] // TraditionalForm

Si raccomanda di non scrivere mai input nella sintassi tradizionale, perché spessisimo manda 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 è seghettato:

cos(4) + log(5)

Numeri razionali

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 File>Palettes>BasicInput e cliccando sulla frazione, e poi riempiendo i quadrati;

(lunghetto) scrivendo il numeratore n e poi scegliendo dal menu Edit>Expression Input>Fraction;

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

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

(1825/105)

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.

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

Numeri reali esatti (simbolici)

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

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 File>Palettes>BasicInput, 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 File>Palettes>BasicInput  accanto a π, oppure con EsceeEsc (attenzione alle due "e")

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.

Reali approssimati in virgola mobile

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

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:

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]

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]

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

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

I due oggetti 1/2 e 0.5 sono distinti:

.5∈Rationals

(1/2)∈Rationals

Se non specifichiamo la precisione, N[] lavora con numeri macchina. Sui computer con processore a 32 bit la precisione macchina è di circa 16 cifre decimali, coi processori a 64 bit il doppio:

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

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

Consideriamo questo numero esatto:

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

Applichiamogli N[]:

N[x]

Chiediamo invece il valore con 16 cifre decimali:

N[x, 16]

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

N[x] // FullForm

Invece chiedendo N[x,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[x, 16] // FullForm

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

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 File>Palettes>BasicInput, oppure battendo EsciiEsc.

Attenzione: per Mathematica la radice cubica dei numeri negativi 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))]

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

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

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

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.

Mathematica segue la regola del tergicristallo: se si chiede la radice quadrata, cubica ecc. aritmetica di qualcosa, Mathematica prende un tergicristallo incardinato nell'origine e appoggiato sull'asse reale positivo, e lo fa girare in senso antiorario. La prima radice algebrica che si incontra sarà la radice aritmetica.
Per esempio con la radice cubica di -8:

Show[
      Graphics[{Circle[{0, 0}, 2], 
          PointSize[ .03], {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 -2"];

Per le radici quadrate di 1 + i:

\(With[{z0 = 1 + I}, 
sol = Solve[z\^2 == z0, z]; 
      Show[Graphics[{Circle[{0, 0}, Sqrt[Abs[z0]]], 
            PointSize[ .03], {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"]]; \)

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

I ∈ Complexes

3.14 ∈ 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) - 2  x - 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) - 3  x + 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) - 3  x + 1 si può scrivere così:

Root[(x^4) + 2  (x^3) - 3  x + 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]]

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

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 programmino (per un principiante non è da leggere, ma solo da usare) mostra le posizioni delle varie radici col loro numero d'ordine:

mostraRadici[polinomio_, 
        variabile_] := 
Module[{grado, sol, xmin, xmax, 
          ymin, ymax}, 
grado = 
          Exponent[polinomio, variabile]; 
sol = 
          Table[Root[polinomio, variabile, n], {n, 
              grado}]; 
{xmin, xmax} = {Min[Re[sol]], 
            Max[Re[sol]]}; 
{ymin, ymax} = {Min[Im[sol]], 
            Max[Im[sol]]}; 
Show[
          Graphics[
            Table[Text[
                n, {Re[sol[[n]]], Im[sol[[n]]]}], {n, 
                grado}]], Frame -> True, 
          PlotRange -> {{(5  xmin - xmax)/
                  4, (-xmin + 5  xmax)/4}, {(5  ymin - ymax)/
                  4, (-ymin + 5  ymax)/4}}]];

Mettiamolo all'opera:

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

mostraRadici[(x^5) + 3  (x^4) - 2  (x^3) + x + 3, x];

mostraRadici[(x^3) - 2, x];

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.

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

Root[2  x - 3, x, 1]

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

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

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

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

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

Per questo c'è il comando RootReduce:

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

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

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

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

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:

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!

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

Mathematica ha nel suo repertorio le lettere \(TraditionalForm\`ℕ, \ ℤ, \ ℚ, \ ℝ, \ ℂ\) ecc. Si possono scrivere con le tavolozze File>Palettes>Basic Typesetting e File>Palettes>Basic Typesetting (nella sezione Letters>Double-Struck), 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; 
ℂ = 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_?NumericQ, Naturals] := 
      Element[n, Integers] && 
        n ≥ 0; 
ℕ = Naturals;

Ecco che funziona:

3 ∈ ℕ

-5 ∈ ℕ

I ∈ ℕ

(2/3) ∈ ℕ

Numeri casuali

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

Random[]

Ogni volta che si chiama Random[] viene un numero nuovo:

Random[]

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

Random[Real, {2, 3}]

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

Random[Integer, {0, 10}]

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

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

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

Needs["Statistics`ContinuousDistributions`"]

Random[NormalDistribution[0, 1]]

Le distribuzioni non uniformi sono definite nei pacchetti standard Statistics`ContinuousDistributions` e Statistics`DiscreteDistributions`. Dei pacchetti e di come li si carica parleremo più avanti.

Esercizi

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

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

Che cosa ci aspetteremmo dal conto seguente?

Element[(1 + Sqrt[2])^2 - 2  Sqrt[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.

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.

Separare parte reale e immaginaria dei numeri \(TraditionalForm\`\(3 + 2  i\)\/\(4  i - 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 RootReduce.