Professional Documents
Culture Documents
7
2
NB: non viene eseguita la divisione in modo numerico per non perdere
precisione negli eventuali calcoli successivi. Per Maple, 7/2 e 3.5 sono oggetti
diversi: il primo è un numero razionale, il secondo è un numero in virgola
mobile (floating point). Per chiarire la differenza consideriamo uno stesso
calcolo eseguito con Maple utilizzando la notazione razionale e con virgola:
> (1/3.0)*3;
.9999999999
> (1/3)*3;
1
NB: il simbolo ’*’ indica la moltiplicazione e non puù essere sottinteso.
Si noti che il primo calcolo viene effettuato in virgola mobile anche se un solo
numero (3.0) è di tipo floating point. Il secondo calcolo è esatto perchè 1/3 è
riconosciuto e trattato come numero razionale. Vediamo che pasticci possono
accadere: consideriamo un calcolo in cui siano utilizzate le due notazioni
appena viste
> (1/3.0)*3-(1/3)*3;
−.1 10−9
cioè -0.1 per un miliardesimo ovvero -0.0000000001 mentre, ovviamente,
dovrebbe risultare 0.
Possiamo chiedere un calcolo numerico più accurato chiedendo a Maple di
utilizzare un maggior numero di cifre (digits) decimali:
> Digits:= 10;
Digits := 10
> (1/3.0)*3-(1/3)*3;
−.1 10−24
ora gli zeri che precedono la cifra 1, dopo la virgola, sono 24: si tratta di un
numero molto vicino allo zero ma non è esattemente zero.
1.1.2 Arrotondamenti, troncamenti ed errori
Diam := 9.31
per l’altezza usiamo un metro con precisione di un millimetro:
> Altezza:= 19.4 ; # cm
Altezza := 19.4
Calcoliamo il volume:
> Volume:=(Diam/2)^2*Pi*Altezza; # il risultato è in cm^3
Volume := 420.3790850 π
> evalf(%);
1320.659845
AnzichÈ considerare l’intera cifra decidiamo di considerare solo le quattro cifre
a sinistra della virgola.
E’ una bella cifra che ci spinge ad effettuare una valutazione più precisa.
Tornando al calcolo del volume prendiamo subito qualche cifra in più, anzi
teniamo tutte quelle che vediamo scritte, non ci costa più fatica:
> Costo_totale:=1.320659845*0.51*19800;
er Diam := .001072961373
er Volume := .007300561921
L’errore relativo nel calcolo del volume è dunque del 7 per mille (perchÈ
sommiamo due volte l’errore relativo del diametro?). Lo stesso errore relativo
si ripercuote sul calcolo del costo totale. Si noti che gli altri fattori che
compaiono nel calcolo del costo totale sono il numero 1/2, che è esatto cioè con
errore assoluto nullo, e π, che Maple tiene in memoria con un numero di cifre
significative sufficientemente elevato da poter essere considerato con errore
relativo trascurabile.
ea Volume := 3.069003540 π
> evalf(%);
9.641558976
2a−ba
−a (−2 + b)
NB: per indicare la riga di calcolo (execution group) appena eseguita si utilizza
il simbolo di percentuale (%), nelle versioni di Maple meno recenti lo stesso
effetto si ha utilizzando il doppio apice (”).
> 3*x*(x^2-y^2)^2/((x+y)*9*x);
1 (x2 − y2 )2
3 x+y
NB: l’elevamento a potenza viene indicato dal simbolo ’ˆ’.
1
(x − y) (x2 − y2 )
3
Vediamo qualche altra semplificazione:
> root(x^2,2);
√
x2
> simplify(%);
csgn(x) x
Ancora un esempio:
> (x+2)*(x^2-1)/(x+1);
(x + 2) (x2 − 1)
x+1
cerchiamo di riscrivere l’espressione in modo più semplice:
> factor(%);
(x − 1) (x + 2)
x2 + x − 2
(x − 1) (x + 2)
(x + 2) (x2 − 1)
x+1
proviamo prima ad espandere
> expand(%);
x3 x 2 x2 2
− + −
x+1 x+1 x+1 x+1
un disastro! Proviamo a vedere se si semplifica qualcosa
> simplify(%);
x2 + x − 2
(x − 1) (x + 2)
Dagli esempi fin qui visti simplify puù apparire come il comando più utile; in
realtà il comando più flessibile è expand che consente, ad esempio, di stabilire
quale fattore raccogliere:
> expand((x+2)*(x+3)*(y+z),x);
x2 y + x 2 z + 5 x y + 5 x z + 6 y + 6 z
> expand((x+2)*(x+3)*(y+z),x+2);
(x + 2) x y + (x + 2) x z + 3 (x + 2) y + 3 (x + 2) z
> expand((x+2)*(x+3)*(y+z),y+z);
(y + z) x2 + 5 (y + z) x + 6 y + 6 z
> factor(%);
(x + 2) (x + 3) (y + z)
Maple consente operazioni sui numeri interi quali la divisione con resto, il
fattoriale, la fattorizzazione..., sui numeri complessi, su insiemi, vettori,
matrici,...
e
> Pi;
fattore1 := x y
ora fattore1 è una variabile che vale xy. Consideriamo una seconda variabile
> fattore2:=x*z;
fattore2 := x z
e moltiplichiamo
> prodotto:=fattore1*fattore2;
prodotto := x2 y z
f := x → x2 − 1
antonio 2 − 1
o componendola
> f(y-1);
(y − 1)2 − 1
Combiniamo una variabile di tipo numero con la funzione f
> alfredo:=3;
alfredo := 3
> f(alfredo);
8
E’ poi semplicissimo disegnare grafici mediante il comando plot:
> plot(f,-2..4,-2..5);
–2 –1 0 1 2 3 4
–1
–2
2.1 Equazioni
{x = 2}, {x = −2}
Maple commette errori nel caso di calcoli letterali, anche semplici, se ci sono
parametri
> solve({a*x+b=0},{x});
b
{x = − }
a
(cosa succede se a=0?) e non risponde in alcuni casi numerici ”proibiti”
> solve({0*x+3=0},{x});
{x = I}, {x = −I}
1 1√ 1 1√
{x = 0}, {x = − + 21}, {x = − − 21}
2 2 2 2
> solve({x^3-13*x+12=0},{x});
In genere siamo perù più interessati alla risoluzione numerica di una equazione
come la precedente. Il comando da usare è in tal caso fsolve, con la stessa
sintassi di solve
> fsolve({exp(x)*x^2-3 = 0},{x});
{x = 1.033230904}
f := sin(x)
> sol1:=solve({f=0.3},{x});
sol1 := {x = .3046926540}
> sol2:=fsolve({f=0.3},{x});
sol2 := {x = .3046926540}
Quale soluzione è corretta? In realtà queste sono solo due delle infinite
soluzioni dell’equazione considerata. Maple non è in grado, in questo caso, di
avvisarci della presenza di altre soluzioni.
sin(.3046926540)
chiedendo il calcolo del valore della funzione nel punto mediante il comando
evalf
> evalf(%);
.3000000000
> subs(sol2,f);
sin(.3046926540)
> evalf(%);
.3000000000
2.2 Sistemi di equazioni
eq1 := 3 x + 2 y = 2
> eq2:=x-y=4;
eq2 := x − y = 4
> solve({eq1,eq2},{x,y});
{x = 2, y = −2}
Vediamo un caso in cui il sistema presenta infinite soluzioni
> eq3:=x+2*y=1;
eq3 := x + 2 y = 1
> eq4:=2*x+4*y=2;
eq4 := 2 x + 4 y = 2
> solve({eq3,eq4},{x,y});
{y = y, x = −2 y + 1}
Mettiamo ora alla prova Maple su di un sistema di due equazioni non lineari.
Sia
> primo1:=3*x^3-exp(y);
primo1 := 3 x3 − ey
il primo membro della prima equazione e
> primo2:=y^2+x;
primo2 := y2 + x
il primo membro della seconda equazione e risolviamo il sistema primo1=0,
primo2=3 dando anche un nome all’insieme delle soluzioni
> soll:=fsolve({primo1=0,primo2=3},{x,y});
.1997260023 − e(−1.610808840)
> evalf(%);
0.
> subs(soll,primo2);
3.000000000
Si noti che la soluzione trovata non è unica (anche se Maple non lo dice):
> subs({x=1.098015136,y=1.379124673},primo1);
3.971423811 − e1.379124673
> evalf(%);
0.
> subs({x=1.098015136,y=1.379124673},primo2);
3.000000000
Definiamo una funzione della quale andremo poi a cercare alcuni limiti
> g:= x-> (x+1)*(x+2)*(x-3)/(x-1);
(x + 1) (x + 2) (x − 3)
g := x →
x−1
Proviamo a calcolare il limite per x - > 1. Prima definiamo il limite che ci
interessa
> Limit(g(x),x=1);
(x + 1) (x + 2) (x − 3)
lim
x→1 x−1
e adesso cerchiamone il valore
> value(%);
undefined
La risposta è corretta infatti calcolando i limiti da sinistra e da destra troviamo
> Limit(g(x),x=1,left);
(x + 1) (x + 2) (x − 3)
lim
x→1− x−1
> value(%);
∞
Per il limite destro utilizziamo la lettera minuscola nel comando limit , questo
consente di ottenere subito il valore numerico del limite
> limit(g(x),x=1,right);
−∞
Se gli ultimi due limiti calcolati da Maple sono giusti (e lo sono) allora il primo
limite cercato non esiste. Vediamo come si calcolano i limiti a + e - infinito.
Ad esempio
> Limit(g(x),x=-infinity);
(x + 1) (x + 2) (x − 3)
lim
x→(−∞) x−1
> value(%);
∞
f := x → x cos(k x)
> diff(f(x),x);
cos(k x) − x sin(k x) k
In realtà il fatto che f sia definita come funzione di x a Maple interessa poco.
Possiamo infatti derivare anche rispetto a k:
> diff(f(x),k);
−x2 sin(k x)
h := x → x3 − 2 x2 − 4 x
−2
staz := 2,
3
Più in generale possiamo studiare la monotonia della funzione determinando
gli intervalli nei quali la derivata si mantiene non negativa:
> solve(diff(h(x),x)>=0,x);
−2
RealRange(−∞, ), RealRange(2, ∞)
3
Otteniamo cosı̀ che -2/3 è un punto di massimo locale mentre è di minimo
locale il punto 2.
Vediamo come classificare i punti stazionari utilizzando la derivata seconda.
Anzitutto calcoliamola nel generico punto x:
> diff(h(x),x,x);
6x−4
Speghiamo ora a Maple di considerare l’espressione appena trovata come
immagine di x tramite la funzione derivata seconda di h, che chiameremo
DDh; per far questo usiamo il comando unapply
> DDh:=unapply(%,x);
DDh := x → 6 x − 4
Adesso possiamo valutare la derivata seconda nei due punti stazionari. Nel
primo punto si ha
> DDh(staz[1]);
8
perciù si tratta di un massimo. Nel secondo punto stazionario si ha
> DDh(staz[2]);
−8
che ci conferma che il punto 2 è di minimo per h. Vediamo il grafico
(numerico) di h fornito da Maple:
> plot(h(x),x=-3..5,-10..10);
10
8
6
4
2
–3 –2 –1 0 1 2 3 4 5
–2 x
–4
–6
–8
–10
3.3 3.3 Uno studio di funzione
x3 (x + 1)
f := x →
x2 + 2
Proviamo a farci disegnare il grafico da Maple:
> plot(f(x),x=-10..10);
100
80
60
40
20
–10 –8 –6 –4 –2 0 2 4 6 8 10
x
∞
> limit(f(x),x=+infinity);
Studiamo il segno di f:
> solve(f(x)>=0,x);
x2 (2 x3 + 8 x + x2 + 6)
(x2 + 2)2
47
1 (1/3) 6 1
staz := 0, 0, − %1 + (1/3)
− ,
6 %1 6
1 (1/3) 47 1 1 1 √ 1 (1/3) 47 1
%1 − − + I 3 (− %1 − ),
12 12 %1(1/3) 6 2 6 6 %1(1/3)
1 (1/3) 47 1 1 1 √ 1 (1/3) 47 1
%1 − − − I 3 (− %1 − )
12 12 %1(1/3) 6 2 6 6 %1(1/3)
√
%1 := 253 + 18 518
Si leggono proprio male! Prima di tentare di scrivere meglio i punti stazionari
vediamo cosa si puù dire riguardo alla monotonia fornendo a Maple solo il
fattore che determina il segno della derivata
> solve(2*x^3+8*x+x^2+6>=0,x);
47
1 √ 6√ 1
RealRange − (253 + 18 518)(1/3) + − , ∞
6 (253 + 18 518)(1/3) 6
s1 := 0.
> s2:=evalf(staz[2]);
s2 := 0.
> s3:=evalf(staz[3]*1.);
s3 := −.7212304534
> s4:=evalf(staz[4]);
s4 := .1106152263 − 2.036497585 I
> s5:=evalf(staz[5]);
s5 := .1106152263 + 2.036497585 I
Valutiamo f nel terzo punto stazionario:
> f(s3);
−.04149894724
x (x + 1) 6 x2 14 x3 (x + 1) 4 x4 8 x5 (x + 1)
DDf := x → 6 2
+ 2 − 2 2
− 2 2
+
x +2 x +2 (x + 2) (x + 2) (x2 + 2)3
x+1 18 x 54 x2 (x + 1) 42 x3 96 x4 (x + 1) 24 x5
DDDf := x → 6 + − − + +
x2 + 2 x2 + 2 (x2 + 2)2 (x2 + 2)2 (x2 + 2)3 (x2 + 2)3
48 x6 (x + 1)
−
(x2 + 2)4
> evalf(DDDf(staz[1]));
3.
0.5
0.4
0.3
0.2
0.1
–1 –0.5 0 0.5 1
x
f := x → x e(x+1)
e(x+1) (x + 1) − 2 e(x+1)
e(x+1) (x + 1) − e(x+1)
e semplificando
> simplify(%);
x e(x+1)
ottenendo la conferma della correttezza del calcolo dell’integrale.
1√
π
2
che è corretto. Se vogliamo calcolare lo stesso integrale tra 0 e 1, ad esempio,
Maple ovviamente non puù far molto:
> int(g(x),x=0..5);
1 √
erf(5) π
2
dove erf ( x ) = 2/sqrt(Pi) * int ((exp(-xˆ2), t = 0..x ). Quindi Maple si mangia
la coda, e non poteva che
Vediamo molto velocemente come quanto visto per le funzioni di una sola
variabile reale si estenda al caso di due variabili; l’estensione a più variabili
risulterà poi del tutto ovvia. Cominciamo definendo una funzione nelle
variabili x e y:
> f:=(x,y)->x^2*y-3*y/x;
3y
f := (x, y) → x2 y −
x
Proviamo a calcolare due limiti (facili)
> limit(f(x,y),{x=2,y=3});
15
2
> limit(f(x,y),{x=0,y=3});
undefined
Se tentiamo con altre funzioni facciamo presto a mettere in difficoltà Maple.
La funzione
> g:=(x,y)->x^2*y^2/(x^2*y^2+(x-y)^2);
x2 y 2
g := (x, y) →
x2 y 2 + (x − y)2
non ha limite in (0,0), Maple non risponde:
> limit(g(x,y),{x=0,y=0});
x2 y 2
limit( , {x = 0, y = 0})
x2 y2 + (x − y)2
Ma anche nel caso di una funzione con limite 0 in (0,0) Maple si arena
> limit(x^3/(x^2+y^2),{x=0,y=0});
x3
limit( , {x = 0, y = 0})
x2 + y 2
Non ci sono ovviamente problemi nel calcolo delle derivate parziali:
> diff(g(x,y),x);
x y2 x2 y2 (2 x y2 + 2 x − 2 y)
2 −
x2 y 2
+ (x − y) 2 (x2 y2 + (x − y)2 )2
> simplify(diff(g(x,y),y));
x3 y (x − y)
2
(x2 y2 + x2 − 2 x y + y2 )2
Ed ecco una derivata seconda mista
> simplify(diff(g(x,y),x,y));
x2 y2 (6 x y − 3 x2 + x2 y2 − 3 y2 )
2
(x2 y2 + x2 − 2 x y + y2 )3
x2 y2 (6 x y − 3 x2 + x2 y2 − 3 y2 )
DDXY := (x, y) → 2
(x2 y2 + x2 − 2 x y + y2 )3
−22
125
Le possibilità grafiche sono uno dei punti forti dei programmi tipo Maple.
Analizziamo prima alcune possibilità non ancora esplorate riguardo alle
funzioni di una sola variabile. Passeremo poi alle funzioni di due variabili.
4.2.1 4.2.1 Alcune potenzialità grafiche per funzioni di una sola vari-
abile
0.5
0 1 2 3 4 5 6
x
–0.5
–1
Possiamo anche tentare una compressione dell’asse delle x per avere un’idea
del comportamento della funzione per valori molto grandi dell’argomento
> plot(sin(x),x=0..infinity);
0 infinity
x
0 infinity
x
-infinity
Possiamo ora utilizzare tutti i comandi elencati sopra. Per esempio possiamo
utilizzare le coordinate polari
> polarplot(1,theta=0..2*Pi);
1
0.5
–1 –0.5 0.5 1
–0.5
–1
–6 –4 –2 0 2 4 6
–2
–4
–6
–2
–3
–4
1e+10
1e+09
1e+08
1e+07
1e+06
1e+05
.1e5
.1e4
.1e3
.1e2
1. 2 4 6 8 10
x
y 0.5
–1 –0.5 0 0.5 1
x
–0.5
–1
senza protestare
> implicitplot(exp(x^2*y)-exp(y)=sin(4*x),x=-2..2,y=-5..5);
y
2
–4
4.2.2 4.2.2 Grafici per funzioni di due variabili
paraboloide
30
25
20
15
10
5
–4 2 0
–2 y –2 –4
0 0
4 2 x
> contourplot(x^2+y^2,x=-5..5,y=-5..5,contours=25);
y
2
–4 –2 0 2 4
x
–2
–4
> plot3d(y^2-x^2,x=-4..4,y=-4..4,style=contour,contours=50,grid=[50,50]
> ,orientation=[200,60],color=black,axes=boxed,title=‘sella‘);
sella
15
10
5
0
–5 4
–10 2
–15 0 x
4 –2
2 0
y –2 –4
–4
> densityplot(x^2+y^2,x=-5..5,y=-5..5);
4
y
2
–4 –2 0 2 4
x
–2
–4
5 5. Algebra delle matrici
Esaminiamo ora alcune delle possibilità che Maple offre nel calcolo matriciale.
Anzitutto vi sono due pacchetti che possiamo richiamare per operare sulle
matrici e, più in generale, su probelmi di algebra lineare: linalg eLinearAlgebra .
Qui esamineremo solo alcune delle possibilità offerte dal primo che andiamo a
caricare:
> with(linalg);
Warning, the protected names norm and trace have been redefined and
unprotected
v+w
38
> evalm(A+C);
1 8 4
−4 16 8
> evalm(2*A);
2 6 4
−10 28 18
> BINV:=inverse(B);
5 1 −3
2 8 4
1
BINV := −1 0
2
−5 −1 5
2 8 4
Ha fatto bene i conti? Controlliamo:
> evalm(B&*BINV);
1 0 0
0 1 0
0 0 1
OK!
b := [1, 2]
5 1
+ t1
19 19
che in corrispondenza di un fissato valore del parametro
> _t[1]:=1;
t 1 := 1
diviene
> x[1];
6
19
Vediamo ora come ottenere la matrice inversa della matrice B in base alla
definizione: l’inversa, se esiste, risolve l’equazione tra matrici BX=I dove I è la
matrice identità. Definiamo la matrice identità come una matrice diagonale :
> ID:=diag(1,1,1);
1 0 0
ID := 0 1 0
0 0 1
Quindi risolviamo il sistema
> BINVbis:=linsolve(B,ID);
5 1 −3
2 8 4
1
BINVbis := −1 0
2
−5 −1 5
2 8 4
che è l’inversa trovata prima da Maple, possiamo farlo controllare a Maple:
> evalm(BINV-BINVbis);
0 0 0
0 0 0
0 0 0
la loro differenza è zero quindi coincidono.
Spesso nella risoluzione dei problemi accade di dovere eseguire più volte una o
più istruzioni in un ordine stabilito. Si supponga ad esempio di dover calcolare
il montante di una operazione finanziaria oppure un tasso di interesse: per
risolvere diversi problemi del genere cambiano i dati, ma le formule rimangono
sempre le stesse. Sarebbe quindi opportuno evitare di dovere riscrivere le
formule ogni volta, ma memorizzarle una volta per tutte e riutilizzarle quando
servono (risparmiando tempo e fatica). Questa opportunità è offerta dalle
procedure, vediamo come realizzarla.
M = C*(1 + i*t)
Dichiarazione di un procedura
Per poter riutilizzare più volte la formula senza avere la necessità di riscriverla
ogni volta, possiamo dichiarare una procedura che esegua la formula del calcolo
del montante comunque vengano specificati i dati in ingresso.
• ”proc” è una parola chiave: serve ad avvisare MAPLE che si tratta di una
procedura;
Per indicare la fine della dichiarazione della procedura si scrive end oppure
end proc. Se nella dichiarazione non ci sono errori di sintassi, MAPLE
riscrive la procedura (in blu) dopo l’end finale.
Una volta dichiarata una procedura, per eseguirla basta scriverne il nome
seguito dai valori che intendiamo assegnare agli argomenti: un’istruzione di
questo genere è detta chiamata della procedura ed i valori passati sono
detti parametri (o argomenti) attuali della chiamata.
1400.00
5075.00
1584.00
è data una segnalazione d’errore perchÈ nella dichiarazione della procedura gli
argomenti formali erano 3, mentre in questa chiamata gli argomenti attuali
sono solo 2 (in questo caso MAPLE non sa quanto vale il tasso i); dunque:
il numero degli argomenti attuali deve corrispondere al numero degli argomenti formali.
1380.00
montante := 1380.00
> end;
“ciao a tutti”
M = C*(1 + i)ˆt
C = M / (1 + i)ˆt
I=M-C.
> M/(1+i)^t;
> M-C
> end;
capInter IntComp := proc(M, t, i) M (i + 1)t ; M − C end proc
nessuna segnalazione d’errore, ma ciù non significa che la procedura (quando
eseguita) fornisca i risultati corretti; infatti, se proviamo ad effettuare una
chiamata della procedura (con M = 2000 euro, t = 3 anni e i = 11 %):
> capInter_IntComp(2000,3,0.11);
2000 − C
C’è qualcosa che non va: la procedura dovrebbe stampare 2 numeri e invece
stampa un’espressione con una C di troppo: come mai ? L’espressione
rappresenta il montante (che è 2000, giusto) e corrisponde all’ultima istruzione
(prima dell’end), ma al posto della variabile C dovrebbe esserci il valore del
capitale calcolato nell’istruzione che precede. Già, ma noi non abbiamo
specificato che il risultato di tale istruzione sia memorizzato in C; per farlo
aggiungiamo una assegnazione nella seconda riga e torniamo a dichiarare la
procedura:
> capInter_IntComp := proc(M, t, i)
> C := M/(1+i)^t;
> M-C;
> end;
> M-C
> end;
capInter IntComp := proc(M, t, i) local C; C := M (i + 1)t ; M − C end proc
537.617237
> C:=M/(1+i)^t;
> print(C);
> M-C
> end;
capInter IntComp := proc(M, t, i) local C; C := M (i + 1)t ; print(C) ; M − C end proc
1462.382763
537.617237
> C:=M/(1+i)^t;
> return(C,M-C);
> end;
capInter IntComp :=
proc(M, t, i) local C; C := M (i + 1)t ; return C, M − C end proc
1462.382763, 537.617237
ricalcoliamo il montante M.
> print(C);
> M-C
> end;
capInter IntComp := proc(M, t, i) local C; C := M (i + 1)t ; print(C) ; M − C end proc
> log[1+i](M/C);
> end proc;
tempo IntComp := proc(M, C, i) logi+1 (M C) end proc
- se C <= 0 allora:
- altrimenti:
> else
> log[1+i](M/C)
> end if
56.63207933
else
end if
- altrimenti:
> log[1+i](M/C)
> else
> end ;
56.63207933
> tempo2_IntComp(8000, 0, 0.03);
> log[1+i](M/C)
> end if
> end;
tempo3 IntComp := proc(M, C, i) if 0 < C then logi+1 (M C) end if end proc
end if
e lavora nel seguente modo:
> log[1+i](M/C)
> end if
> end;
tempo3 IntComp := proc(M, C, i) if 0 < C then logi+1 (M C) end if end proc
M>0eC>0
> log[1+i](M/C)
> end if
> end;
tempo4 IntComp :=
proc(M, C, i) if 0 < M and 0 < C then logi+1(M C) end if end proc
Gli operatori or (somma logica) e and (prodotto logico) sono detti
operatori boolean e lavorano in modo simile agli usuali operatori aritmetici
+ e *, salvo che se scriviamo x + y, le variabili x ed y devono rappresentare
dei numeri, mentre se scriviamo x or y, le variabili x ed y devono assumere
solo i valori true (VERO) oppure false (FALSO).
L’opertore or dà come risultato FALSO solo se entrambi gli operandi sono
falsi, quindi la sua tabella di verità è:
x y x or y
invece l’opertore and dà come risultato VERO solo se entrambi gli operandi
sono veri e la sua tabella di verità è:
x y x and y
x not x
false true
true false
Gli operatori boolean or, and e not insieme con i valori false e true
costituiscono un’algebra (analoga a quella usuale sui numeri reali) detta
algebra di Boole.
Nell’algebra di Boole si possiamo valutare espressioni in cui si utilizzano solo
gli operatori boolean e le variabili possono assumere solo i valori true e false;
espressioni di questo tipo sono dette espressioni boolean. Un esempio di
espressione boolean è:
x or y and not x
• dati in uscita: i montanti dopo 1 anno, 2 anni, 3 anni, ... finchÈ C*(1+i)ˆn
< Mfin
Per effettuare la stampa dobbiamo perciù riutilizzare sempre la stessa formula
ma per valori diversi del numero di anni, che indicheremo con n; i passi da
eseguire sono perciù:
Si tratta ora di tradurre questi passi in istruzioni MAPLE tenendo conto che:
• il comando ”finchÈ ... esegui” si traduce con l’istruzione ”while ... do”
di Maple; anche con questa istruzione sarà necessario indicare la fine delle
istruzioni da ripetere con end do (oppure anche semplicemente con end);
Vediamo ad esempio quali sono i montanti anno dopo anno che consentono ad
un capitale C = 1000 Ä di raddoppiare al tasso annuo del 4 %:
> montanti_IntComp(1000, 0.04, 2000);
1040.00
1081.6000
1124.864000
1169.858560
1216.652902
1265.319018
1315.931779
1368.569050
1423.311812
1480.244285
1539.454056
1601.032219
1665.073507
1731.676448
1800.943506
1872.981246
1947.900496
18
end do
- altrimenti termina
Spesso quando alcune istruzioni devono essere ripetute più volte si conosce
preventivamente il numero esatto di ripetizioni richieste. In questi casi
conviene utilizzare l’istruzione for anzichè la while.
• dato in ingresso: n
• dato in uscita: il fattoriale di n
fattoriale := proc(n)
local m, fatt;
fatt := 1 ; if 0 < n then for m to n do fatt := m ∗ fatt end do end if ; return fatt
end proc
> fattoriale(6);
720
end do
noti gli estremi di integrazione a e b. Non esiste in questo caso alcun modo di
scrivere una primitiva della funzione integranda utilizzando composizioni di
funzioni elementari, possiamo perù calcolare un valore approssimato
dell’integrale applicando la definizione: approssimiamo cioè l’area
rappresentata dall’integrale con l’area di un plurirettangolo.
Di seguito sono descritti i passi da eseguire per ottenere una soluzione del
problema:
plurirettangolo
attuale di area
> area := 0;
> delta := (b - a) / m;
> x := a;
> for n from 1 to m do
> x := x + delta;
> od;
> return(evalf(area))
> end;
integrale := proc(a, b, m)
local n, area, x, δ;
area := 0 ;
δ := (b − a) m ;
x := a ;
for n to m do x := δ + x ; area := area + δ ∗ exp(x2 ) end do ;
return evalf(area)
end proc
Osservazioni:
• al solito le variabili che non sono argomenti formali della procedura (n,
area, x e delta) sono dichiarate come variabili locali per evitare la seg-
nalazione di Warning
1451.199053
1447.136700
1445.784397
1443.082472