|
26/10/2004
gioca con le isometrie di base
21/10/2004
derivate e antiderivate (primitive)
17/10/2004
matematica di base
Nella mappa sono presenti esclusivamente collegamenti
interni a file presenti sullo stesso sito "informatematica".
Per questo motivo non sono "linkate" tutte le voci.
Per "escursioni" riguardanti tali argomenti non linkati (e, ovviamente,
anche per approfondimenti di vario genere sulle voci già linkate nella
mappa) fai riferimento ai collegamenti presenti sul lato sinistro della
pagina di informatematica.
COME PER TUTTO IL RESTO DEL SITO, E' NECESSARIO ABILITARE IL BROWSER
ALL'USO DI JAVA.
13/10/2004
approssimazione dell'esponenziale
immaginario exp(it) nell'intervallo t ∈
[0,1]
(
premi Step per aumentare il numero naturale n e Clear per ripristinarlo a 1
)
approssimazione di exp(at), con
a complesso, nell'intervallo t ∈ [0,1]
(
fissa a e premi Step per aumentare il numero naturale n e Clear per
ripristinarlo a 1 )
11/10/2004
approssimazione dell'esponenziale
naturale nell'intervallo [0,1]
(
premi Step per aumentare il numero naturale n e Clear per ripristinarlo a 1
)
Notare che la funzione esponenziale che passa per tutti i punti della
"gradinata" in figura è: f(x) = ( 1 + 1/n )^(n x), ossia ( (1+1/n)^n
)^x .
Prova a digitare, nel pannello della figura, come valore di f, al posto di
e^x l'espressione (1+1/n)^(n*x .
Quindi abbiamo una successione di funzioni esponenziali, ognuna di base
(1+1/n)^n, che converge alla funzione exp(x) = e^x .
10/10/2004
|
ancóra
sull'esponenziale naturale |
|
clicca
sul pulsante :
|
| prendiamo un punto a = ( ax
, ay ) = ( h , k ) "vicino" al punto (0,1) |
| suddividiamo l'asse delle ascisse con
i punti n h (con n interi) |
| indichiamo con Zh l'insieme dei
numeri della suddetta suddivisione |
| ipotizziamo che una funzione f
definita su Zh sia tale che : |
|
f( 0 ) = 1 ; f( h ) = k ; f( x+h ) = f( x ) k , per
ogni x in Zh |
a parole: f passa per (0,1) e (h,k) e
all'incrementare la x di h
f(x) viene moltiplicata per k |
| ne deriva che f( n h ) = k n
. Posto x = n h , si ha f( x ) = k x / h . |
| Poniamo 1 + p = ay = k :
si ha f( x ) = [ (1 + p) 1 / h ] x |
| quindi f è l'esponenziale di base
(1+p) 1 / h . |
Se avviciniamo il punto a al punto
(0,1) l'esponenziale f varia
secondo il tipo di avvicinamento di a al punto (0,1) e "intorno" a
(0,1) f diventa "instabile" . |
| Proviamo a far tendere a al punto
(0,1) con a sulla retta y = 1+x |
| Ciò significa che ay = 1 +
ax , ossia k = 1 + h .
|
| in tal caso si ha f( x ) = [ (1 + h)
1 / h ] x e ... |
| ... se prendiamo h = 1/n otteniamo (1
+ h) 1/h = (1 + 1/n) n |
| Quando h tende a 0, a, vincolato alla
retta, tende a (0,1) ... |
|
... e f( x ) tende a e x ; il segmento
verticale in figura è (1,0)_(1,e) |
| Cosa accade se l'avvicinamento è
effettuato sulla retta y=1+m x ? |
L'esponenziale naturale nasce quindi nel momento in cui, invece di partire
da (0,1) e da un punto "distante" tipo (1,2) per "estrapolarne" una
funzione (ossia determinarne una che passi per i due punti dati) che porti
somme in prodotti (nel caso dei punti detti essa è y=2^x), partiamo da
(0,1) e da un punto (h,1+h) "infinitamente vicino" a (0,1) e procediamo a
estrapolare una funzione passante per tali due punti e che porti somme in
prodotti.
"Infinitamente vicino" significa che con h tendente a 0 la funzione
trovata, che è un'esponenziale, ma non l'esponenziale naturale esatta,
tende all'esponenziale naturale esatta.
Vedi anche gli ulteriori documenti :
figura
esponenziale
naturale e capitalizzazioni
09/10/2004
08/10/2004
|
I
t e r a z i o n e " p e r v e r o " ( ciclo " w h i l e " )
Nell'algoritmo per
l'implementazione del costrutto VECTOR abbiamo visto che uno stesso
gruppo I di istruzioni viene ripetuto ciclicamente per tutto il tempo
in cui una condizione C viene trovata vera. Questo ciclo è detto
"iterazione per vero" oppure "iterazione con uscita per falso". Il
diagramma è :
:
:
_|_
/ \ falso
*->-/ C \--->*
| \ / |
| \_ _/ |
| vero| |
| __|__ |
| | | |
*-<-| I | |
|_____| |
|
*<------*
|
:
:
un altro possibile diagramma, perfettamente equivalente, è :
:
:
|<----------*
_|_ |
/ \ vero |
/ C \--->* |
\ / | |
\_ _/ __|__ ^
| | ||
falso | I ||
| |_____||
: | |
: *->-*
|
|
La versione testuale di
tale ciclo iterativo è :
mentre C esegui I
( while C do I )
La naturale definizione
sarebbe teoricamente:
(1) mentre(C,I) := IF( C , mentre(C,I) , "fine ciclo" )
Però Derive quando valuta una funzione definita dall'utente per
prima cosa cerca di valutarne gli argomenti (ossia gli input; in
questo caso C e I) e solo dopo applica la definizione della
funzione; pertanto la valutazione della espressione mentre(C,I) di
sopra verrebbe effettuata con i valori trovati per C e per I la
prima volta che tale valutazione è eseguita e, se C risulta vera
si entra in un loop senza uscita, mentre se C risulta falsa si
accede subito
alla stringa "fine ciclo".
Esiste però un operatore (operatore "apice", con simbolo ' ) ,
detto operatore di "citazione" ("quote operator") o di
"differimento di valutazione", che anteposto a una espressione
produce un'espressione "citante" la cui valutazione è
l'espressione "citata". Ad esempio se, dopo aver posto x := 4 ,
valutiamo (col pulsante "=") x+2 , il risutato della valutazione è
6 , mentre se valutiamo '(x+2) oppure 'x + 2 il risultato è x+2,
in quanto nel primo caso rimane inalterata (quindi non valutata)
l'intera espressione (x+2) , mentre nel secondo rimane non
valutata la variabile x (che è un tipo elementare, o "atomico", di
espressione).
Nelle espressioni funzionali con argomenti "apiciati" (ossia
she sono espressioni sottoposte all'operatore ' ) Derive non
effettua la preventiva valutazione di tali argomenti.
Perciò potremmo usare nell'espressione mentre(C,I) espressioni con
apici; ad esempio: C := '(x<=10) e I := '[v := APPEND(v, [x^2]); x
:= x + 1] e in tal caso Derive non valutando C e I produce
internamente, tramite la definizione di sopra
(2) IF( '(x<=10)
, mentre('(x<=10),'[v := APPEND(v, [x^2]); x := x + 1]) , "fine
ciclo" )
poi semplifica ciò che può valutare e produce:
(2bis) IF( x<=10 , mentre(x<=10,[v := APPEND(v, [x^2]); x :=
x + 1]) , "fine ciclo" )
quindi non effettua alcun ciclo; e, del resto, se continuassimo
con la valutazione della espressione (2) ricadremmo nel loop senza
termine (dal momento che adesso gli apici non ci sono più).
Esiste però un modo per costringere Derive a valutare direttamente
un'espressione con apice. Uno possibile e definire le seguenti
funzioni :
testa(L) := L SUB 1
valuta(E) := testa([E])
La prima prende il primo elemento (detto "la testa") di una lista,
ad esempio:
testa([1,2,3,4]) viene valutato :
1
La seconda prende una espressione E, la valuta, usa il risultato r
per costruire una lista [r] costituita solo da tale risultato e
poi valuta testa([r]), per la quale cosa valuta r nell'espressione
[r] per poi applicare la definizione della funzione testa.
Pertanto se partiamo dall'espressione (un numero è una particolare
espressione, costante) 5 l'espressione valuta(5) viene valutata
seguendo i seguenti passi :
- si valuta il 5 e il risultato è ... 5 ;
- si segue la definizione della funzione "valuta" e quindi si
ottiene testa([5]) ;
- si valuta l'input ("argomento") presente nell'espressione
testa([5]) , ossia [5], e si ottiene testa([5]) ;
- si applica la definizione della funzione "testa" pervenendo a
[5] SUB 1, ossia 5.
Proviamo, dopo aver gia definito x:=4 come già fatto, a valutare
l'espressione
valuta(x) seguendo gli stessi passi di sopra :
- si valuta x e il risultato è 4 ;
- si segue la definizione della funzione "valuta" e quindi si
ottiene testa([4]) ;
- si valuta l'input ("argomento") presente nell'espressione
testa([4]) , ossia [4], e si ottiene testa([4]) ;
- si applica la definizione della funzione "testa" pervenendo a
[4] SUB 1, ossia 4.
Proviamo adesso a valutare l'espressione valuta('x) :
- non si valuta subito l'argomento 'x (in quanto è sotto la
"protezione" dell'apice);
- si segue la definizione della funzione "valuta" e quindi si
ottiene testa(['x]) ;
- si valuta l'input ("argomento") presente nell'espressione
testa(['x]) , ossia ['x], e si ottiene testa([x]) ;
- si applica la definizione della funzione "testa" pervenendo a
[x] SUB 1, ossia x ;
- l'ultima fase della valutazione di una funzione è la
semplificazione, perciò l'espressione x viene valutata 4 .
Come vediamo, così facendo partiamo da 'x e otteniamo non x ma il
valore 4 della variabile x
Altro esempio: valutiamo l'espressione (apiciata) '(x>0) :
- non si valuta '(x>0) ;
- si segue la definizione della funzione "valuta" e quindi si
ottiene testa(['(x>0)]) ;
- si valuta (semplifica) tale ultima espressione, ottenendo
testa([x>0]) ;
- si valuta testa([x>0]), quindi si provvede anzitutto a valutare
[x>0] in [true] ;
- si applica la definizione della funzione "testa" pervenendo a [true]
SUB 1, ossia true.
Un'altra osservazione sulla valutazione delle espressioni: se si è
definita una funzione di due argomenti, ad esempio
potenza(base,esponente) := base ^ esponente
e la si applica a più argomenti di quelli usati nella definizione,
ad esempio :
(3) potenza(3,2,x:=3)
la definizione usa solo i primi argomenti che effettivamente le
servono in base alla definizione pur però valutando tutti gli
argomenti presenti in (3). Quindi, valutando la (3) si ottiene
l'atteso 9 (ossia 3^2), ma ... x è diventato 3
(ricordiamoci che prima era stato definito come 4).
Applichiamo quanto visto alla definizione della funzione "mentre".
Definiamo:
mentre(C,I) := IF( valuta(C) , mentre( C , I ,
valuta(I) ) , "fine ciclo" )
Poniamo preliminarmente le due definizioni ("assegnamenti")
x:=0 e v:=[ ] e supponiamo che C sia '(x <= 10) e
che I sia '[v := APPEND(v, [x^2]); x := x + 1].
In quanto apiciate, C e I vengono passate non valutate, ma poi IF
determina la valutazione dell'espressione valuta(C), la quale
risulta true per cui si procede a valutare l'espressione
mentre(C,I,valuta(I)), il che comporta come effetto collaterale la
valutazione dell'espressione valuta(I) ( cosa che fa eseguire I
stessa ), prima di passare alla esecuzione di mentre(C,I), il che
fa ricominciare il tutto, ma dopo la valutazione di I ( che ha
modificato il valore della variabile x ) |
In definitiva:
digitiamo in Derive (riga di editing):
testa(L) := L SUB 1
valuta(E) := testa([E])
mentre(C,I) := IF(valuta(C),mentre(C,I,valuta(I)),"fine ciclo")
Verifichiamo il funzionamento digitando, e poi valutando :
[v := []; x := 0; mentre('x <= 10, '[v := APPEND(v, [x^2]); x := x
+ 1]); v; x] |
l'output sarà :
¦ [] ¦
¦ ¦
¦ 0 ¦
¦ ¦
¦ fine ciclo ¦
¦ ¦
¦ [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] ¦
¦ ¦
¦ 11 ¦
|
|
Lo scopo di questo post è quello di mostrare come il ciclo
iterativo per vero sia definibile solo con l'uso di IF e della "ricorsione
in coda".
Volendo invece approfittare del costrutto ITERATE di Derive possiamo usare
le seguenti due definizioni:
ripeti(a) := ITERATE(a, x__)
mentre(C, I) := ripeti(IF(C,I, "stop"))
Volendo usare la funzione "ripeti" anche un numero prefissato di volte,
possiamo usare la definizione alternativa:
ripeti(a, n) := ITERATE(a, x__, "", n)
A proposito di ITERATE, possiamo definire la funzione "valuta" non usando
le testa di una lista ma come:
valuta(t) := ITERATE(x__, x__, t, 1)
Un'applicazione
di esempio: poligoni regolari tracciati nello stile del LOGO.
il testo da digitare in derive è:
testa(t):=t SUB 1
val(t):=testa([t])
mentre(c,i):=IF(val(c),mentre(c,i,val(i)),"ciclo eseguito")
output(u):=u SUB DIMENSION(u) SUB 1
poligono(n,L):=output([[[a:=0,p_:=[0,0],i_:=1,a_:=2*pi/n,v_:=[p_]]],~
[mentre('(i_<=n),'[[p_:=p_+[COS(a),SIN(a)]*L],[v_:=APPEND(v_,[p_])],[a:=a+a_],[i_:=i_+1]])],[v_]])
poligono(60,0.1)
valuta e poi rappresenta l'ultima espressione.
07/10/2004
|
Valutando ( mediante il
pulsante "=" ) con Derive 5 il programma :
¦ 2 ¦
¦ espressione(x) := x ¦
¦ ¦
¦ inizio := 0 ¦
¦ ¦
¦ fine := 10 ¦
¦ ¦
¦ passo := 2 ¦
¦ v := [] ¦
¦ ¦
¦ x := inizio ¦
¦ ¦
¦ / ¦ v := APPEND(v, [espressione(x)]) ¦ \ ¦
p := ¦ | ¦ ¦ | ¦
¦ | ¦ x := x + passo ¦ | ¦
¦IF|x <= fine,¦ ¦, v | ¦
¦ | ¦ p ¦ | ¦
¦ \ ¦ 3,1 ¦ / ¦
|
l'output ottenuto è :
¦ [] ¦
¦ ¦
¦ 0 ¦
¦ ¦
¦ ¦ [0] ¦ ¦
¦ ¦ ¦ ¦
¦ ¦ 2 ¦ ¦
¦ ¦ ¦ ¦
¦ ¦ ¦ [0, 4] ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ 4 ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ [0, 4, 16] ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ 6 ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ [0, 4, 16, 36] ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ 8 ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ [0, 4, 16, 36, 64] ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ 10 ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ [0, 4, 16, 36, 64, 100] ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ 12 ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦ ¦ ¦ [0, 4, 16, 36, 64, 100] ¦ ¦ ¦ ¦ ¦ ¦ ¦
|
( la forma delle espressioni data qui sopra è
simile a quella usata da Derive 5 per la rappresentazione sul foglio di
lavoro, quindi qui non si può effettuare il "copia e incolla" con la
riga di editing ) |
Ovviamente il programma p traccia proceduralmente il processo
effettuato dal costrutto VECTOR ed è utile per capire l'algoritmo nel caso
di valori bassi della variabile "fine" (altrimenti le matrici di traccia
sono enormi).
Inoltre, dopo la prima valutazione dell'espressione che definisce il
programma p, la variabile p resta associata alla matrice di traccia che
risulta come output, per cui per far girare il programma nuovamente
(eventualmente con altri valori ed espressione) bisogna fare un "refresh"
della definizione di p tramite doppio clic e INVIO sull'espressione stessa
che definisce p.
05/10/2004
|
inseriamo in Derive le seguenti espressioni |
|
espressione(x) := x^2
inizio := 0
fine := 10
passo := 2
lista := VECTOR(espressione(x) , x , inizio , fine , passo)
lista
|
|
la valutazione della variabile "lista" tramite il
pulsante "=" da' :
[0, 4, 16, 36, 64, 100] |
|
lo "schema di flusso" del processo effettuato
dall'espressione
VECTOR(espressione(x) , x , inizio , fine , passo)
e' il seguente :
|
v := [ ] |
|
x := inizio |
|
(1) condizione : x <= fine ? |
|
sì |
no |
|
v := append(v,[espressione(x)]) |
l'output del processo e' : v |
|
x := x + passo |
|
torna a (1) |
|
| Un modo per realizzare
("implementare") tale processo (algoritmo) in DERIVE 5 e' digitare nella
riga di editing (ovviamente dopo aver inserito le espressioni che
definiscono espressione(x), inizio, fine e passo) l'espressione :
p := [v := [ ] ; x := inizio ; IF(x <= fine, [v := APPEND(v,
[espressione(x)]) ; x := x + passo ; pSUB3SUB1], v)]
(seleziona tutta l'espressione e dopo averla copiata con CTRL+C
incollala con CTRL+V nella riga di editing di DERIVE, quindi premi
INVIO)
con tale espressione selezionata, valutarla tramite il
pulsante "=" ; si otterra' la "traccia" dell'algoritmo. |
|
Un altro modo, piu' elegante e veloce, per
implementare l'algoritmo e' definire la seguente funzione ciclo(v,x) :
ciclo(v, x) := IF( x <= fine , ciclo( APPEND(v,
[espressione(x)]) , x + passo ) , v )
e quindi valutare con il pulsante "=" l'espressione :
ciclo( [ ] , inizio )
Prova a inserire tali due espressioni nella riga di
editing di DERIVE e a valutare la seconda con "=".
Questo secondo procedimento non richiede di dare un
nome all'intero programma (sopra era chiamato p) per indirizzarne una
parte a cui ritornare ciclicamente, ma isola la parte del processo che
si ripete ciclicamente e la definisce come funzione degli ingressi
("input") che tale ciclo deve elaborare, ingressi che vengono
automaticamente modificati dalla funzione stessa nel suo "corpo" senza
riassegnamento di variabili. Infine tale funzione viene applicata agli
input di partenza che sono la lista vuota [ ] e il numero contenuto
nella variabile "inizio" .
|
E' possibile e comodo inserire le definizioni tutte insieme in una lista:
basta digitare nella riga di editing di DERIVE il "vettore":
[espressione(x) := x^2, inizio := 0, fine := 10, passo := 2]
oppure, in colonna (nota i ";" al posto delle virgole):
[espressione(x) := x^2; inizio := 0; fine := 10; passo := 2].
01/10/2004
facciamo il punto sulle applet PGC finora viste :
ciclotomia e radici dell'unità
triangolo rettangolo e
circonferenza circoscritta
rotazioni intorno all'origine
prodotto di numeri complessi
somma di angoli
esponenziale naturale di un
numero immaginario
funzioni a scala
come render giustizia ( "orthòs"
= "giusto" -> ortogonale ) all'obliquità
parabola e moltiplicazione
grafica
parabole, traslazioni,
equazioni quadratiche
funzioni lineari e progressioni
aritmetiche
funzioni esponenziali e
progressioni geometriche
incrementi di una funzione
funzioni elementari
mettere la freccia ad un
vettore
esponenziale naturale e numero
di Nepero
facciamo la TAC alla
moltiplicazione !
interpolazione e combinazioni
lineari
vettori e traslazioni "versus"
flettori e rotoomotetie
le 8 ( ma in fondo solo 2 )
isometrie fondamentali del piano
CABRI = CAhier de BRouillon
Interactif (quaderno di brutta interattivo)
... ne consegue che CABRI in italiano si chiama ... QUABRI !!!
|
