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

 

matematica con DERIVE

 

usa o scarica l'applet PGC ( plane graphic calculator = calcolatrice grafica nel piano )

decomprimi il file zip in una cartella e avvia uno dei due file in formato HTML :

PGC.html oppure index.html

 

Matematica per il biennio delle scuole superiori (con Derive e Cabri)

Seleziona e copia il testo sottostante compreso fra le righe di asterischi, quindi apri il blocco note (notepad) e incolla quanto copiato; salvalo scegliendo l'opzione "salva come: tutti i file", dandogli il nome esercitazione.mth, quindi aprilo con DERIVE 5 (o DERIVE 6). Buon lavoro ! ********************************************************************************* " Primo approccio alla grafica con DERIVE 5 " punto(a,b):=[a,b] "clicca sul pulsante ''finestra grafica 2D'' e poi scegli: finestra > affianc~ a (o disponi) verticalmente " "dopo aver selezionato la finestra grafica, scegli: opzioni > semplifica prim~ a di tracciare il grafico" "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' " punto(2,3) "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' " punto(3,2) " cancella la figura con la combinazione di tasti Ctrl+D " fig(a,b):=[punto(a,b),punto(-a,b),punto(a,-b),punto(-a,-b)] "seleziona l'espressione di qui sotto, poi clicca sul pulsante ''='' osserva ~ come DERIVE sviluppa l'espressione, quindi ritorna su fino alla prossima istr~ uzione " fig(a,b) "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' " fig(3,2) " cancella la figura con la combinazione di tasti Ctrl+D " figsim(a,b):=APPEND(fig(a,b),fig(b,a)) figsim(a,b) ;Sempl(#17) [[a,b],[-a,b],[a,-b],[-a,-b],[b,a],[-b,a],[b,-a],[-b,-a]] "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' " figsim(2,3) " cancella la figura con la combinazione di tasti Ctrl+D " punto_su_arco(t):=punto(COS(t),SIN(t)) "seleziona una dopo l'altra le espressioni di qui sotto e ogni volta selezion~ a la finestra grafica, quindi clicca sul pulsante ''Traccia il grafico dell'e~ spressione'' " punto_su_arco(1) punto_su_arco(1/2) punto_su_arco(1/3) punto_su_arco(2/3) punto_su_arco(1/4) punto_su_arco(3/4) VECTOR(punto_su_arco(t),t,0,1,0.1) VECTOR(punto_su_arco(t),t,0,1,0.01) VECTOR(punto_su_arco(t),t,0,pi,0.01) " cancella la figura con la combinazione di tasti Ctrl+D " "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' " VECTOR(punto_su_arco(t),t,0,pi,pi/15) " cancella la figura con la combinazione di tasti Ctrl+D " "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' " VECTOR(punto_su_arco(t),t,0,2*pi,pi/15) " cancella la figura con la combinazione di tasti Ctrl+D " stella:=VECTOR(r*punto_su_arco(t),t,0,2*pi,pi/15) "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' ; si aprira'~ una finestra che chiede i valori minimo e massimo; imposta rispettivamente ~ a 0 e a 1 tali valori e spunta la voce ''applica i parametri anche agli altri~ grafici''" stella " cancella la figura con la combinazione di tasti Ctrl+D " stelle(a,b):=VECTOR(VECTOR(r*punto_su_arco(t)+p,t,0,2*pi,pi/15),p,figsim(a,b)~ ) "seleziona l'espressione di qui sotto, poi seleziona la finestra grafica, qui~ ndi clicca sul pulsante ''Traccia il grafico dell'espressione'' ; si aprira'~ una finestra che chiede i valori minimo e massimo; tali valori sono gia' i~ mpostati rispettivamente a 0 e a 1 ed e' gia' spuntata la voce ''applica i pa~ rametri anche agli altri grafici''; quindi clicca solo su OK" stelle(2,3) " cancella la figura con la combinazione di tasti Ctrl+D " fuochi(a,b,n):=VECTOR(stelle(a*s,b*s),s,0,1,1/n) " rappresenta, come prima indicato, nella finestra grafica l'espressione segu~ ente : " fuochi(6,3,3) " clicca sul pulsante ''riduci'' " " clicca nuovamente sul pulsante ''riduci'' " " clicca sul pulsante ''ingrandisci'' " " clicca nuovamente sul pulsante ''ingrandisci'' " " cancella la figura con la combinazione di tasti Ctrl+D " fascio(a,b):=APPEND(figsim(a,b),VECTOR(p SUB 2/p SUB 1*x,p,figsim(a,b))) " rappresenta nella finestra grafica l'espressione seguente : " fascio(3,2) " cancella la figura con la combinazione di tasti Ctrl+D " ott(a,b):=[[a,b],[b,a],[-b,a],[-a,b],[-a,-b],[-b,-a],[b,-a],[a,-b],[a,b]] "dopo aver selezionato la finestra grafica, scegli: opzioni > visualizzazione~ > punti e imposta su si' l'opzione ''collega'' " " rappresenta nella finestra grafica l'espressione seguente : " ott(3,2) " cancella la figura con la combinazione di tasti Ctrl+D " " rappresenta nella finestra grafica l'espressione seguente : " ott(2,3) " cancella la figura con la combinazione di tasti Ctrl+D " ottagono(a,b):=IF(a>=b,ott(a,b),ott(b,a)) " rappresenta nella finestra grafica l'espressione seguente : " ottagono(2,3) " cancella la figura con la combinazione di tasti Ctrl+D " le_8_isometrie(a,b):={ottagono(a,b),fascio(a,b)} " rappresenta nella finestra grafica l'espressione seguente : " le_8_isometrie(2,3) " fine dell'esercitazione " *********************************************************************************

 

Rappresentazione della conoscenza e tecnologie Web

 

 

rappresentazione della conoscenza

 

	Maria Luisa Dalla Chiara Roberto Giuntini Francesco Paoli Sperimentare la logica Editore: Liguori (NA) ISBN: 88-207-3684-5 ed.: 2004 pp.: 180

Sperimentare la logica è un manuale introduttivo di logica pensato per l’utilizzo nella didattica universitaria triennale ed esplicitamente indirizzato non solo agli studenti di Filosofia, ma anche agli studenti di Scienze e Tecniche Psicologiche, Scienze dell’Educazione, Scienze della Comunicazione o Scienze della Formazione Primaria. La scelta dell’impostazione e dei contenuti del manuale è stata dettata da un’attenta considerazione dei mutamenti intervenuti nell’insegnamento della logica con l’entrata in vigore della legge di riforma universitaria. In quest’ottica si è privilegiato, da un lato, un approccio alla logica di tipo informale, semantico, e, dall’altro, ci si è impegnati a evitare il più possibile le astrazioni filosofico-matematiche a vantaggio delle esemplificazioni concrete, dell’aderenza al linguaggio ordinario e al ragionamento quotidiano, dell’esplorazione di possibili intersezioni con la psicologia, la didattica, le scienze cognitive, la pragmatica della comunicazione.