Manipolazioni di base

(1)  Ancora qualche esempio:
> a:=7+3:
> a;

                                  10
> a*b+c=7;
                             10 b + c = 7
> restart;
> a:='a';
                                a := a
> solve(a*b+c=7,{c});
                            {c = -a b + 7}
> solve(a*b+c=7,{a});
                                   c - 7
                            {a = - -----}
                                     b
> 7/3; evalf(7/3); Digits;
                                 7/3
                             2.333333333
                                  10
> Digits:=40; evalf(Pi); evalf(Pi,18);
                             Digits := 40
              3.141592653589793238462643383279502884197
                         3.14159265358979324
> Digits:=10;
                             Digits := 10
Soluzione di un sistema di due equazioni e di un'equazione e una disequazione rispetto a due variabili:
> solve({5*x+2*t=7, 2*t-x-1=0}, {t,x});
                            {x = 1, t = 1}
> solve({5*x+2*t=7, 2*t-x-1>0}, {t,x});
                      {x < 1, t = - 5/2 x + 7/2}
Risoluzione dello stesso sistema rispetto alla sola variabile x:
> solve(5*x+2*t=7,t) = solve(2*t-x-1=0,t);
> solve( solve(5*x+2*t=7,t) = solve(2*t-x-1=0,t), {x});
                     - 5/2 x + 7/2 = 1/2 x + 1/2
                               {x = 1}
Risoluzione della stessa equazione graficamente:
> f := x -> -5/2*x+7/2; g := x -> 1/2*x+1/2;
                       f := x -> - 5/2 x + 7/2
                        g := x -> 1/2 x + 1/2
> plot({f,g}, 0.5..1.5,0.5..1.2, scaling=CONSTRAINED, color=[blue,red]);
 
Il rapporto incrementale della stessa f e di un'altra f:
> R := h -> (f(1+h)-f(1))/h; R(-7); R(h);
                                f(1 + h) - f(1)
                      R := h -> ---------------
                                       h
                                 -5/2
                                 -5/2
> f:= x -> x^2; R(1); R(0.1); R(0.01); R(0.001);
                                        2
                             f := x -> x
                                  3
                             2.100000000
                             2.010000000
                             2.001000000
> 'limit (R(h),h=0)' = limit (R(h), h=0);
                            lim    R(h) = 2
                           h -> 0
L'iniziale maiuscola spesso rappresenta il calcolo senza eseguirlo:
> Limit (R(h), h=0) = limit (R(h), h=0);
                                      2
                               (1 + h)  - 1
                        lim    ------------ = 2
                       h -> 0       h
Diversi modi di rappresentare la derivata prima:
> D(f); D(f)(x); diff(x^2,x); diff(f(x),x);
                               x -> 2 x
                                 2 x
                                 2 x
                                 2 x
e la derivata seconda:
> D(D(f)); diff(f(x),x,x);
                                  2
                                  2
Diversi modi di rappresentare la derivata N-esima:
> (D@@1)(f);(D@@2)(f);(D@@3)(f); (D@@4)(x->x^6);
                               x -> 2 x
                                  2
                                  0
                                       2
                             x -> 360 x
Per indicare il limite da destra o da sinistra occorre usare "right" e "left"; se non lo si usa, quando è necessario, si ha un messaggio undefinined.
> limit (abs(x)/x, x=0, right); limit (abs(x)/x, x=0, left);
       1       -1
Fattorizzare in ambienti diversi:
> factor(x^2+2*x+1); factor(x^2+x/2-1/2); factor(x^2+2*x-5); factor(x^2+2*x-5,real);
                                      2
                               (x + 1)
                        1/2 (x + 1) (2 x - 1)
                              2
                             x  + 2 x - 5
                 (x + 3.449489743) (x - 1.449489743)
> expand((x+3)*(x-1));
                              2
                             x  + 2 x - 3
> factor(x^2+1,real); factor(x^2+1,complex);
                                2
                               x  + 1.
                        (x + 1. I) (x - 1. I)
> sqrt(x^2*y);
                                2   1/2
                              (x  y)
> assume(x>0); sqrt(x^2*y);
                                   1/2
                               x~ y
> about(x);
    Originally x, renamed x~: is assumed to be: RealRange(Open(0),infinity)
> x:='x': about(x); sqrt(x^2*y);
    x: nothing known about this object

                                2   1/2
                              (x  y)
----------------------------------

Integrazione

(2)  Vedi   qui  (in fondo) e  qui .
Vedi http://macosa.dima.unige.it/om/prg/js/integr.htm per un programma per il calcolo dell'integrale definito di una funzione continua in un intervallo [a,b] con il metodo dei punti medi mediante uno script (si tratta del tipo di programma per computer largamente più diffuso).
La funzione predefinita inizialmente è x -> x^2.
Esame del programma (clicca il pulsante destro su come si presenta lo "script" per vederne il "sorgente"); al centro compaiono le istruzioni:
  s=0; h=(b-a)/n;
  for (var j=0; j < n; j=j+1) {s = s + F(a+(j+1/2)*h)}
  i=s*h;

Provare ad usarlo con n = 1, 10, 100, 1000, ... osservare le varie uscite e valutare la velocità di convergenza del programma.


0.6666666666659892  se a=-1 b=1 n=1000000 [6.598310786642969e-11]
0.6666666666000061  se a=-1 b=1 n=100000 [6.6000053200454545e-9]
0.6666666600000007  se a=-1 b=1 n=10000 [6.600000005407836e-7]
0.6666660000000002  se a=-1 b=1 n=1000 [0.00006600000000012152]
0.6666000000000001  se a=-1 b=1 n=100 [0.006599999999999939]
0.6600000000000001  se a=-1 b=1 n=10 [-0.006666666650013808]
Con n = 2, 4, 8, 16, … invece si ha:
0.6666665077209473  se a=-1 b=1 n=2048 [4.76837158203125e-7]
0.6666660308837891  se a=-1 b=1 n=1024 [0.0000019073486328125]
0.6666641235351562  se a=-1 b=1 n=512 [0.00000762939453125]
0.666656494140625  se a=-1 b=1 n=256 [0.000030517578125]
0.6666259765625  se a=-1 b=1 n=128 [0.0001220703125]
0.66650390625  se a=-1 b=1 n=64 [0.00048828125]
0.666015625  se a=-1 b=1 n=32 [0.001953125]
0.6640625  se a=-1 b=1 n=16 [0.0078125]
0.65625  se a=-1 b=1 n=8 [0.03125]
0.625  se a=-1 b=1 n=4 [0.125]
0.5  se a=-1 b=1 n=2 [0.5]
(come mai si hanno uscite con le ultime cifre delle approssimazioni meglio approssimate? il computer lavora in base 2)
----------------------------
(3) 
> restart;
> f:= x-> 2; plot (f,-1..3);
                                f := 2
 
Con int si ha il calcolo, con Int o 'int ...' la visulizzazione dell'impostazione del calcolo
> Int(f,x=-1..3); 'int(f,x=-1..3)'=int(f(x),x=-1..3);
                                 3
                                /
                               |
                               |   2 dx
                               |
                              /
                                -1

                               3
                              /
                             |
                             |   f dx = 8
                             |
                            /
                              -1
Funzione integrale:
> A:= x -> int(f(t),t=-1..x);
                                     x
                                    /
                                   |
                        A := x ->  |   f(t) dt
                                   |
                                  /
                                    -1
> plot (A,-1..3);
 
Integrale indefinito (Maple indica una possibile primitiva; sta all'utente eventualmente aggiungere la "costante"):
> int(f(x),x);
                                 2 x
Uso del teorema fondamentale (che Maple cerca di fare automaticamente quando si comanda il calcolo di un integrale definito; vedi sopra):
> subs(x=3,int(f(x),x))-subs(x=-1,int(f(x),x));
                                  8
-----------------------
(4) 
Caso più complesso:
> F := x -> abs(x-4)-1: plot (F,-1..8);
 
Il grafico di una funzione integrale e' formato da due archi di parabola che si raccordano per x=4 e che sono simmetrici rispetto al punto comune. Tracciamo quello della funzione integrale che in -1 vale 0.
> plot (x -> int(F(t),t=-1..x), -1..8);
 
Controllo (ho fatto, a mano, l'integrale delle due funzioni integrale imponendo che in -1 la prima valesse 0 e che la seconda in 4 valesse quanto la prima):
> plot ([x -> 3-x, x -> x-5, x -> 3*x-x*x/2+3.5, x -> x*x/2-5*x+7.5+12],-1..8,color=[red,orange,blue,black]);
 
> int(F(x),x);
                      1/2 (x - 4) | x - 4 | - x
Il grafico della funzione integrale fornita da Maple (differsice per una costante dalla funzione integrale ottenuta prima, imponendo che valesse 0 in -1):
> plot (x -> 1/2*(x-4)*abs(x-4)-x, -1..8);
 
---------------------------------
(5) 
> int(1/x,x);
                                ln(x)
Attenzione: Maple non è detto che trovi tutte le primitive. Ad es. nel caso precedente log(x) è una primitiva solo per x>0.
Per x<0 la primitiva è log(-x)
> diff(log(x),x); diff(log(-x),x);
                                 1/x
                                 1/x
-----------------------
(6)  Calcoli riferiti ad esempi ed esercizi richiamati nel file "integrazione-0" (vedilo prima). Riferiamoci all'es. 8.10 visto ora (rivedi la soluzione).
> int(-(x+1)^2+2-x^2,x);
                                 3              3
                    - 1/3 (x + 1)  + 2 x - 1/3 x
> solve(-(x+1)^2+2-x^2=0,x);
                               1/2               1/2
                  - 1/2 + 1/2 3   , - 1/2 - 1/2 3
> int(-(x+1)^2+2-x^2,x=-1/2-1/2*3^(1/2)..-1/2+1/2*3^(1/2));
                                  1/2
                                 3
In qualche versione di Maple il risultato viene semplificato, in altre no. Comunque puo' sempre essere utile manipolare il risultato per vedere se si ottiene qualcosa di piu' comprensibile (col comando simplify o col comando expand, a seconda dei casi).
> simplify (int(-(x+1)^2+2-x^2,x=-1/2-1/2*3^(1/2)..-1/2+1/2*3^(1/2)) );
                                  1/2
                                 3
-----------------------
(7)  Maple, nei casi in cui non si puo' trovare (o lui non riesce a trovare) una primitiva elementare, non viene visualizzato niente, o una espressione che corrsiponde a qualche funzione o precedimento incorporato in Maple (e che voi non siete in grado di interpretare):
> int(sin(x)/x,x);
                                Si(x)
Possiamo, comunque, calcolare integrali definiti in forma approssimata:
> evalf(int(sin(x)/x,x=1..2));
                             .6593299066
e tracciare il grafico di funzioni integrali
> g := t -> evalf( int(sin(x)/x,x=1..t)); plot (g, 0..15);
                                      t
                                     /
                                    |   sin(x)
                   g := t -> evalf( |   ------ dx)
                                    |     x
                                   /
                                     1
 
Per funzioni come x -> sin(x)/x vedremo, più avanti, che potremo calcolare gli integrali anche usando sviluppi in serie di potenze.