gioca con le isometrie di base

 

 

derivate e antiderivate (primitive)

 

 

matematica di base

 

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 )

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 ?

Che cos'è un algoritmo Informazioni, dati e strutture dati Rappresentazione degli algoritmi Alcuni esempi di algoritmi Imparare a programmare Introduzione a Javascript

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 ¦

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

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