Appunti di Freebasic (FBIde)

Transcript

Versione 0.011
Vladimiro Lelli
21 dicembre 2011
1
Copyleft: CC-BY-NC-SA 3.0
Indice
1 Primi passi
1.1 Ciao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Modalità grafica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.1 Come è strutturato un programma. . . . . . . . . . . . . . . . . . . . . . .
4
4
5
6
2 Programmi vari
2.1 Achille e la Tartaruga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 π . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
14
17
3 Grafici
3.1 Assi cartesiani . . . . . .
3.2 Rette . . . . . . . . . . . .
3.3 Circonferenze . . . . . . .
3.4 Funzioni trigonometriche .
.
.
.
.
19
19
20
20
21
4 Trasformazioni del piano
4.1 Traslazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
22
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduzione
La prima lezione di fisica per le classi di prima e terza liceo si svolge più o meno in questo modo:
... Le lezioni di quest’anno riguarderanno principalmente la cinematica e la dinamica, cioè lo studio del moto dei corpi. L’argomento può essere reso particolarmente
interessante se ogni studente, alla fine dell’anno, avrà costruito il proprio videogioco.
Per videogioco si intende una versione rudimentale di alcuni videogames apparsi negli
anni ’80, tipo Arkanoid, Space Wars, Pacman. Un prototipo di videogioco potrebbe
essere una pallina che viaggia in linea retta sullo schermo e che rimbalza un volta
giunta al bordo. Come è possibile realizzare un simile effetto? Come si fa a disegnare
una pallina e a dirle di spostarsi in linea retta? Occorre sapere un po’ di matematica
e di fisica e cercare in rete il seguente programma: FBIde. FBIde significa Free Basic
Ide, cioè Free Basic Integrated development environment: ambiente di sviluppo integrato per il Free Basic. Il Basic è un linguaggio di programmazione. Free significa
libero (in realtà è open source). Quello che occorre fare è collegarsi in rete, digitare
FBIde su un motore di ricerca (Google?), collegarsi al sito opportuno e scaricare il
programma. Il programma va installato (ci sono versioni per Windows e Linux). Se
tutto è andato a buon fine, all’avvio del programma comparirà una finestra. In quella
finestra scriveremo delle istruzioni che ci permetteranno di creare il videogioco.
Nelle prime pagine di un libro di testo per le classi prime o terze sono scritti un
sacco di discorsi su cosa è il metodo scientifico, cosa fa la scienza, come lavorano
gli scienziati. Scrivendo un programma e cercando di farlo funzionare commetterete molti errori che andranno corretti. Anche quando il programma funzionerà (cioè
farà “qualcosa”), è molto probabile che produrrà effetti molto lontano dalle vostre
aspettative: la pallina si deve spostare e invece sta ferma, deve rimbalzare e invece
scappa dallo schermo e non si fa più vedere. Imparare a gestire questi inconvenienti
provando, tirando a indovinare, cercando aiuto tra i compagni di classe, vedendo cosa
hanno fatto altre persone in rete significa fare attività di ricerca. Potrete saltare cosı̀
le prime pagine del libro di testo.
Diamo quindi per scontato che FBIde sia già installato sul pc. Chi ha Windows non dovrebbe
aver avuto problemi. In alcuni casi compare il messaggio “compiler path is corrupted or not
found” una volta che uno prova a compilare il primo programma. In questo caso ancora non so
quale sia la soluzione. Per gli utenti Linux la procedura di installazione è più laboriosa. Cercatela
in rete (es su youtube). Lavorerete con l’ambiente di sviluppo “Geany”. Per chi ha il Mac le cose
sono un po’ più complicate. Il Mac può simulare Windows. Provate cosı̀. Altrimenti conviene
fare una partizione dell’hard disk e installarci Linux o Windows.
Attenzione: questi sono solo appunti. Sono stati scritti avendo poco tempo a disposizione
e fungono solo da supporto a quanto viene spiegato in classe. È molto probabile che risultino
incomprensibili, poco dettagliati, scritti male. Pazienza, col tempo provvederemo.
2
Non sono dispense di un corso di programmazione (e un programmatore inorridirà ogni tre
righe per quello che legge). Servono a non perdere il filo con quello che abbiamo fatto in classe:
ci sono studenti arrivati a dicembre, altri che tendono ad “imboscarsi” tra i compagni più bravi
(ad ogni computer ci stanno due o tre persone) e a non provare a casa quello che imparano in
classe. Ci sono altri che tendono a capire il senso di quello che facciamo ma a perdersi i dettagli
e a non sperimentare autonomamente (e quindi non sanno riprodurre un programma che faccia
una qualsiasi cosa). Avendo una classe di 30 persone è impossibile seguire ogni studente se questi
non collabora e non lavora anche a casa.
3
V. Lelli
Capitolo 1
Primi passi
1.1
Ciao
Avviate FBIde. Una volta nell’ambiente di sviluppo aprite un nuovo file. Comparirà una
schermata bianca: qui vanno scritte le istruzioni del codice.
Il primo programma che scriveremo è il programma più semplice che esiste: scrive la parola
“ciao”, nel senso che una volta avviato, si aprirà una finestra con su scritto il saluto. Digitate il
seguente codice (è quello che inizia con “print” e finisce con “sleep”):
Programma 1.
Un programma che saluta.
print "ciao"
sleep
Occorre ora eseguire i seguenti passi:
1. Salvare il programma.
Salvatelo cliccando sulla barra in alto a sinistra o cercate in file, save as...
Al programma va dato un nome, per esempio “ciao.bas”. Attenzione: a volte capita di
salvare il programma senza avergli dato un nome. Il programma figurerà come “.bas”. In
questo caso troverete dei problemi in fase di compilazione. Il programma deve avere un
nome.
2. Compilare il programma.
Basta cliccare sulla barra in alto: lı̀ compare un quadratino. Se ci posizionate il mouse
compare la scritta “compile”. Se una volta cliccato non accade nulla, va bene: non ci sono
errori. Compilare il programma (tra le altre cose) serve proprio a questo: controllare di
non aver commesso errori ed eventualmente correggerli.
3. Eseguire il programma.
Sempre sulla stessa barra compare un quadratino. Posizionandoci sopra la freccia del mouse
appare la scritta “run”. Cliccate e guardate cosa succede.
4
Dovrebbe comparire una finestra e in alto a sinistra la scritta “ciao”. Premete un tasto
qualsiasi: la finestra si chiuderà.
Effettuate le seguenti prove:
1. Cancellate l’istruzione “sleep”. Salvate il programma (senza dargli un nome, ce l’ha già.
Basta cliccare in alto sull’icona con l’immagine di un dischetto), compilate e fatelo girare
(run). Provate più volte. Notate niente? Dovrebbe comparire sullo schermo una specie di
“flash”. Qualcosa che appare e subito dopo scompare, troppo veloce.
Senza il comando “sleep” quello che accade è che la finestra con la scritta “ciao” appare,
ma subito dopo scompare e non facciamo in tempo a vederla. Per questo motivo inseriamo
l’istruzione “sleep (dormi)”. Questo comando figurerà al termine di quasi tutti i programmi
scritti in freebasic.
2. Provate a scrivere “pront” al posto di “print”. Avete commesso un errore (pront non
significa niente). Salvate, compilate. Dovreste ricevere un messaggio dal compilatore: non
capisce cosa significa “pront”. Il compilatore in genere dice quale è l’errore e in quale riga
del codice sta.
ATTENZIONE: tutte le volte che modificate un programma, dovete salvare, compilare,
inviare.
Se saltate il primo o il secondo di questi passaggi, il programma in esecuzione non sarà quello
appena modificato ma l’ultimo per il quale avete effettuato questi tre passaggi.
1.2
Modalità grafica
Il freebasic è un linguaggio molto attraente perchè permette di utilizzare la modalità grafica in
maniera semplice e veloce. Grafica significa videogiochi, grafici, disegni, ...
Programma 2.
Apparizione di un cerchio.
screen 19
window (-10,-10)-(10,10)
print "ciao"
circle(3,2),1,4,,,,f
sleep
Fate girare il programma qui sopra. Siamo in modalità grafica: la scritta “ciao” è in caratteri
più gradevoli, la finestra dove compare più ampia e soprattutto compare un cerchio più o meno
al centro dello schermo. Con un po’ di fantasia il cerchio potrà diventare un pacman...
Il metodo che useremo è il seguente: non entreremo nei dettagli di ciascun programma. Se
ci sono problemi, potete chiedere a me direttamente o a qualche vostro collega. Inoltre potete
modificare i programmi per vedere cosa succede. Altro avvertimento: non c’è bisogno di imparare
tutti i comandi a memoria. Per chi usa Windows, sulla barra in alto, a destra compare un “Help”.
Per Linux esiste un manuale scaricabile (è un file .html) e navigabile. Basta ricordarsi che un
comando esiste e andarlo a cercare nell’ Help. Ad esempio io mi ricordo che per fare dei cerchi
si usa il comando “circle”. Come è strutturato me lo dice l’ help. Non solo: mi fornisce anche
l’esempio di programmi che utilizzano quel comando che sto cercando. Posso cosı̀ copiare il
codice che ho trovato nell’help, incollarlo all’interno del programma che sto scrivendo (oppure di
5
V. Lelli
un nuovo programma che ho creato apposta) e vedere quello che fa. Questi non sono dettagli.
Studiando cosa fanno i programmi che compaiono negli esempi dell’help si impara a programmare.
Per questa volta però entreremo abbastanza nei dettagli del codice.
1. Screen 19.
Questo è il comando che dice che siamo entrati in modalità grafica. Cercarlo nell’help.
Provate a cambiare il 19 con il 20 o un altro numero. Io mi ricordo solo “screen-grafica”.
2. Window...
Ci serve un piano cartesiano per poter collocare il nostro cerchio. window (-10,-10)-(10,10)
significa che nella finestra che compare, il punto che sta nell’angolo in basso a sinistra ha
coordinate (-10,-10), quello nell’angolo in alto a destra invece (10,10).
Attenzione: il comando window non produce alcun effetto grafico (non si vede differenza
sullo schermo se lo mettete nel codice oppure no). Provate però a cancellare tale comando
dal codice e provate a vedere se vedete ancora il cerchietto.
3. Circle...
È il comando che serve per fare i cerchi. I numeri tra parentesi sono le coordinate del
centro, seguono l’ampiezza del raggio, il colore, un po’ di virgole e una “F” che sta per
“full”, pieno. Sperimentate!
1.2.1
Come è strutturato un programma.
Conviene a questo punto fare qualche commento su come in genere è strutturato un programma.
Spero sia chiara la differenza tra usare un programma e programmare: quando usiamo un editor di
testo (notepad, word, ...), un foglio elettronico (excel, ...), ..., utilizziamo un programma (scritto
da altri) per un qualche scopo preciso e limitato. Con un editor di testo posso scrivere un
documento, inserirvi delle immagini, un grafico che ho prodotto utilizzando un altro programma.
Quando invece scrivo un programma (e quindi scrivo del codice in un qualche linguaggio di
programmazione), decido io cosa fa il programma; e tale programma, se sono abbastanza bravo,
potrà fare quasi tutto...! A seconda dello scopo che mi prefiggo (fare un videogioco, un virus (!),
migliorare un pezzo di un sistema operativo, collezionare dei dati, fare il grafico di una funzione)
dovrò utilizzare il linguaggio di programmazione più adatto, ma con uno o più linguaggi si può
creare un programma che faccia una qualsiasi cosa. Sorge il dubbio che avendo a disposizione
una cosı̀ grande libertà, i comandi e le istruzioni da imparare nel linguaggio scelto siano centinaia
o migliaia. Non è cosı̀. Facciamo un esempio: vogliamo creare un videogioco rudimentale che
simuli il tennis. Ci saranno quindi al posto delle racchette due rettangoli colorati alla sinistra
e alla destra dello schermo, ciascuno mosso da un giocatore premendo la tastiera. Ci sarà una
pallina che rimbalza sulle racchette. Se un giocatore la manca la pallina andrà oltre la racchetta,
verrà assegnato un punto all’avversario e il gioco riprenderà. Per fare tutto questo (o altro)
bastano pochissimi comandi. Questo perchè non esiste il comando “crea racchetta” o quello
“assegna il punto a Tizio”; se cosı̀ fosse, cambiando videogioco avremmo bisogno del comando
“crea astronave aliena” o “spara missile”. Le istruzioni di base invece sono astratte e hanno a che
vedere con il sommare una certa quantità ad una certa variabile, ripetere una istruzione un certo
numero di volte, controllare se una certa condizione si è verificata. Ecco perchè con le istruzioni
che useremo ci sarà la possibilità di creare programmi totalmente diversi l’uno dall’ altro.
Tutti i programmi che scriveremo saranno strutturati nel seguente modo: una sequenza di
istruzioni, una per riga. Le istruzioni saranno di pochi tipi, elencati qui sotto. Alcune le abbiamo
già utilizzate, altre le useremo.
6
V. Lelli
Input Questo tipo di istruzioni le eviteremo spesso. Questa prassi va contro ogni logica di
programmazione, ma all’inizio è più semplice: i programmi che creiamo sono per noi e li possiamo
modificare quando e come vogliamo. Tutte le volte salveremo, compileremo e faremo il run.
Output
• print
Questa istruzione l’abbiamo già usata. In realtà anche il comando circle crea un output:
visualizza un cerchio sullo schermo. A me piace però inserire circle nella sezione grafica.
• sleep
Con questa istruzione blocchiamo l’esecuzione del programma esattamente nel punto dove
compare la scritta sleep. Basta premere un qualsiasi tasto e il programma prosegue. Se
dopo sleep non vi sono altre istruzioni, il programma termina.
Strutture condizionali
• if ...
then
Comandi di salto
• goto
• gosub
Cicli
• for ...
• do ...
next
loop
Potremmo addirittura fare a meno dei cicli: un ciclo può essere implementato con una
struttura condizionale e una istruzione di salto. Ma i cicli sono cosı̀ comodi...
Dichiarazioni di variabili
• dim as integer ...
• dim as single ..., dim as double ...
Spiegheremo in seguito cosa sono le variabili. integer vuol dire variabile di tipo intero , single
o double sono tipi di variabili alle quali possono essere assegnati numeri non interi (... con la
virgola).
Assegnazione di e computazione con le variabili
• x = 3
Alla variabile x è stato assegnato il valore 3.
• *, +, -, ...
Con questi simboli possiamo moltiplicare, sommare, sottrarre due variabili.
7
V. Lelli
Grafica
• screen
• window
• circle
• pset
Con questa istruzione è possibile colorare un pixel sullo schermo.
Vogliamo ora scrivere un programma che disegni 5 cerchi distinti sullo schermo. Il modo più
banale e noioso di farlo (se i cerchi fossero 100?) sarebbe questo:
screen 19
window (-10,-10)-(10,10)
circle(3,2),1,4,,,,f
circle(1,4),1,4,,,,f
circle(2,3),1,4,,,,f
circle(3,6),1,4,,,,f
circle(-5,2),1,4,,,,f
sleep
Noi però vogliamo che i cerchi siano allineati (le palle viaggiano in linea retta) e non vogliamo
ripetere le stesse istruzioni troppe volte. Utilizzeremo quindi il ciclo for ... next. Cercarlo
nell’help. Qui sotto c’è un programma che scrive 100 volte “ciao”, affiancando al saluto un
contatore che tenga il conto di quante volte compare la scritta.
Programma 3.
Tanti saluti...
dim as integer k
for k = 1 to 100
print "ciao", k
next
sleep
Il ciclo funziona cosı̀: utilizza una variabile k che fa da contatore: all’inizio vale 1, entriamo nel
ciclo e viene scritto “ciao 1” sullo schermo. Troviamo poi next; il valore di k viene incrementato di
1 (attenzione: questa non è una istruzione che compare sullo schermo) e poiché 2 < 100 torniamo
all’inizio del ciclo e questa volta k vale 2. Sullo schermo compare la scritta “ciao 2”. L’istruzione
print ‘‘ciao’’, k viene ripetuta finché k = 100. A questo punto automaticamente usciamo
dal ciclo e troviamo sleep. L’esecuzione si arresta fino a quando non premiamo un tasto.
Importante: la variabile k va dichiarata. Provate a cancellare la prima riga del programma
e guardate cosa dice il compilatore. Ogni volta che utilizziamo una variabile, la dobbiamo
dichiarare.
Torniamo al programma dei cerchi allineati. Supponiamo di dover far apparire un cerchio
che abbia il centro nel punto A(0; 0), poi un secondo cerchio con centro in B(1; 1), poi un terzo
in C(2; 2) e tutto questo con un’unica istruzione circle. È chiaro che non basta scrivere
8
V. Lelli
circle(0,0),1,4,,,,f
oppure
for k = 1 to 10
circle(0,0),1,4,,,,f
next
Nel primo caso disegnamo un cerchio con centro A(0; 0), nel secondo disegnamo 10 cerchi
sovrapposti, tutti con centro in A(0; 0). In qualche modo dobbiamo riuscire a far variare le
coordinate del centro. Utilizzeremo due variabili: x e y. Provate il seguente programma:
screen 19
window (-10,-10)-(10,10)
dim as single x,y
x = 0
y = 0
circle(x,y),1,4,,,,f
sleep
Vedrete comparire un cerchio con centro nell’ origine. Il programma cioè produce lo stesso
risultato di questo:
screen 19
window (-10,-10)-(10,10)
circle(0,0),1,4,,,,f
sleep
ma è più complicato. Abbiamo dichiarato due variabili (x e y) che sono le coordinate del
centro e le abbiamo inizializzate: all’inizio valgono entrambe 0.
Ora dobbiamo trovare il modo di variarle. Si fa cosı̀: inserendole all’interno di un ciclo.
Programma 4.
10 cerchi.
dim as integer k
screen 19
window (-10,-10)-(10,10)
dim as single x,y
x = 0
y = 0
for k = 1 to 10
circle(x,y),1,4,,,,f
x = x + 1
9
V. Lelli
y = y + 1
next
sleep
All’interno del ciclo for compaiono 3 istruzioni: la prima disegna un cerchio con centro in
A(x;y), la seconda dice questo: assegna alla variabile x il vecchio valore che aveva, aumentato di
1. La terza istruzione è simile alla seconda. Per capire meglio, provate a far girare il seguente
programma e a capire cosa fa e perchè lo fa:
dim as integer k
dim as single x,y
x = 3
y = 4
for k
print
x = x
y = y
next
= 1 to 10
"x = ",x, "y = ",y, "k = ",k
+ 1
+ 3
sleep
oppure semplicemente questo:
dim as single x
x = 3.67
print "x = ",x
x = x + 5.2
print "ho sommato 5.2 a x, ora x = ",x
sleep
Nel programma 1.2.1 le istruzioni che incrementano le variabili sono all’interno di un ciclo,
quindi ogni volta che il contatore k aumenta di 1, le istruzioni x = x + 1 e y = y + 1 vengono
ripetute. Ora è il tempo di un trucco e di una magia.
Il trucco:
dim as
screen
window
dim as
integer k
19
(-10,-10)-(10,10)
single x,y
x = 0
y = 0
for k = 1 to 10
10
V. Lelli
circle(x,y),0.1,4,,,,f
x = x + 1
y = y + 1
sleep 150
next
sleep
La magia:
Programma 5.
Magia.
dim as
screen
window
dim as
integer k
19
(-10,-10)-(10,10)
single x,y
x = 0
y = 0
for k = 1 to 10
x = x + 1
y = y + 1
sleep 150
cls
next
sleep
Attenzione: cls significa “clearscreen”: pulisci lo schermo. Capite perchè succede quel che
succede? L’istruzione cls la metterei fra quelle di output.
Non abbiamo finito: vogliamo una pallina che si muove per sempre e rimbalza sullo schermo.
Il problema del ciclo for è che permette di ripetere delle istruzioni un certo numero di volte:
10, 100, 1000... vogliamo avere la possibilità di andare avanti in modo illimitato. Utilizzeremo il
ciclo do ... loop. Quando inizieremo a programmare in modo più sofisticato provvederemo
a trovare un modo per uscire da questo ciclo, per il momento se volete uscirne e terminare il
programma, dovete chiudere la finestra piccola cliccando con il mouse.
screen 19
window (-10,-10)-(10,10)
dim as single x,y
x = -7
y = -5
do
11
V. Lelli
x = x + 0.5
y = y + 0.3
sleep 150
cls
loop
sleep
direi che il cerchietto è scappato dallo schermo e non tornerà più. Il programma non si arresta
da sè: dovete forzarne la chiusura chiudendo la finestra piccola (ho detto PICCOLA...).
Cercate il ciclo do ... loop nell’ help e provate un po’ di esempi ivi inclusi.
Ora il cerchio che rimbalza: quando il cerchio arriva ad una delle estremità della finestra, ad esempio al margine sinistro, deve poter invertire la direzione. Questo significa che
se incrementavamo la x di 1, ora l’incremento deve cambiare segno.
Lo so, non sono stato chiarissimo. Provate questo programma e nel caso fate delle domande.
Programma 6.
Rimbalzi a destra
screen 19
window (-10,-10)-(10,10)
dim as single x,y,a
x = 3
y = -8
a = 0.5
do
if x > 10 then a = - a
x = x + a
y = y + 0.3
sleep 150
cls
loop
sleep
La pallina rimbalza a destra e poi... se ne va. Abbiamo ottenuto questo effetto dichiarando
una nuova variabile a, inizializzandola a = 0.5 e poi incrementando la x con essa: x = x + a.
Il rimbalzo sta in questa parte di codice:
if x > 10 then a = - a
Se (if) la variabile x diventa maggiore di 10 (e quindi la pallina esce dallo schermo) allora
(then) la variabile a cambia segno (a = - a) per cui la coordinata x, che prima aumentava,
torna a diminuire.
12
V. Lelli
Programma 7.
Screensaver
screen 19
window (-10,-10)-(10,10)
dim as single x,y,a,b
x = 3
y = -8
a = 0.5
b = 0.3
do
if
if
if
if
x
x
y
y
>
<
>
<
10 then a = - a
’ rimbalzo a destra
-10 then a = - a
’ rimbalzo a sinistra
10 then b = - b ’ in alto
-10 then b = - b ’in basso
x = x + a
y = y + b
sleep 150
cls
loop
sleep
All’interno di un programma spesso si trovano dei commenti, come quello qui sotto:
’ rimbalzo a sinistra
Cominciano con un apostrofo. Il compilatore capisce che non sono istruzioni e li ignora.
Servono solo al programmatore o a chi legge il programma per spiegare a cosa serve quel pezzo
di codice. Provate a scrivere 100 righe di programma senza commentarle e rileggerle dopo un
mese. Capirete a cosa servono i commenti.
Per quanto riguarda l’istruzione if, provate il seguente programma:
dim as integer j
for j = 1 to 10
if k<4 then print "non mi saluti? ", k
sleep 300
if k > 7 then print "vabbè, ciao ", k
sleep 300
next
sleep
13
V. Lelli
Capitolo 2
Programmi vari
2.1
Achille e la Tartaruga
Abbiamo discusso in classe del paradosso di Zenone. Vogliamo ora vedere la gara implementata
su un computer. Riprodurremo cosı̀ le tabelle di marcia dei corridori e vedremo se e quando
Achille raggiungerà la Tartaruga.
I dati del problema sono i seguenti: la distanza iniziale fra A. e T. è d = 100 m, la velocità
di A. è vA = 10 m/s, quella di T. è vT = 1 m/s. Quando A. raggiungerà T?
Implementiamo il problema un pezzo di codice per volta. Questa è la corsa di A, opportunamente commentata (i commenti sono numerati e rimandano all’elenco sotto al codice):
screen 19
window(-5,-5)-(150,5)
dim as double xa, va, dt
’1
xa = 0
va = 10
dt = 0.01
’2
’3
’4
do
circle(xa,0),1,4,,,,f
xa = xa + va*dt
sleep 100
loop
’5
’6
1. La larghezza della finestra è importante: in classe abbiamo visto che A. percorrerà una
distanza di circa 111.11 metri per raggiungere la T. Se la larghezza della finestra non è
opportuna rischiamo di perderci la fine della gara.
2. A. parte dall’ origine
3. Questa è la velocità di A. Notate come nel codica non possiamo inserire unità di misura.
Dobbiamo essere consapevoli che in questo caso sono 10 metri al secondo.
4. dt è importante: “fotograferemo” la corsa a intervalli di 0.01 secondi. Questo parametro
può essere modificato. Provate a farlo.
14
5. Qui disegnamo la posizione di A. con un cerchietto
6. Questo è il pezzo più importante del codice: ogni volta che facciamo un ciclo, la vecchia
posizione di A. viene aggiornata incrementandola del pezzetto va*dt. È proprio quello che
succede: ogni volta che passano dt = 0.01 secondi A. percorre uno spazio pari a va*dt
metri.
Ultimo dettaglio: il trascorrere del tempo. Nella nostra simulazione, ogni volta che vengono
eseguite tutte le istruzioni all’interno del do ... loop, è come se fosse passato un tempo t
pari a dt = 0.01 secondi. Attenzione: la velocità della simulazione non è connessa al tempo
trascorso che simuliamo. Cambiate sleep 100 con sleep 500: la simulazione va più lenta ma
A. viaggia con la stessa velocità e raggiungerà la T. nello stesso istante.
Ancora sul trascorrere del tempo: provate il seguente programma.
dim as single dt, t
t = 0
dt = 0.1
do
print "sono passati dall’inizio del programma ", t, "
t = t + dt
sleep 300
loop
secondi."
Stiamo simulando il passare del tempo, ma la velocità di simulazione non ha niente a che
vedere con t o dt.
Inseriamo ora il moto della tartaruga e un “cronometro” per misurare quanto dura la corsa.
screen 19
window(-5,-5)-(150,5)
dim as double xt, vt
dim as double t
’variabili Tartaruga
’per misurare il tempo che passa
xa = 0
va = 10
dt = 0.01
xt = 100
vt = 1
t = 0
do
circle(xa,0),0.1,4,,,,f
circle(xt,3),0.1,2,,,,f
xa = xa + va*dt
xt = xt + vt*dt
t = t + dt
sleep 100
loop
’la T. parte 100 metri davanti ad A.
’ma è più lenta
’il cronometro parte da 0
’la T. è un po’ più su e ha un colore differente
’legge del moto per la T.
’questo è il tempo che passa
15
V. Lelli
Ora occorre inserire un controllo che ci dica quando A. supera T: il sorpasso avviene quando
xa > xt. Nel programma qui sotto incontreremo anche l’istruzione goto. Vedremo a cosa serve.
Programma 8.
Achille e la Tartaruga.
screen 19
window(-5,-5)-(150,5)
dim as double xt, vt
dim as double t
xa = 0
va = 10
dt = 0.01
xt = 100
vt = 1
t = 0
do
circle(xa,0),1,4,,,,f
circle(xt,3),1,2,,,,f
if xa > xt then goto finecorsa
xa = xa + va*dt
xt = xt + vt*dt
t = t + dt
sleep 100
loop
finecorsa:
print
print
print
print
"Achille ha superato la Tartaruga in "; t, "
secondi"
"Achille ha percorso una distanza di "; xa, "
metri"
"La Tartaruga ha percorso una distanza di "; xt, "
metri"
"Zenone c’e’ rimasto male e se n’e’ andato..."
sleep
Rimane da commentare l’istruzione goto: serve a saltare da una parte del codice ad un altra.
La necessità di fare questo tipo di operazione è evidente nel programma appena scritto. Per
sperimentare un po’, provate quello qui sotto (e cercate come al solito nell’help).
print "sperimentiamo il goto"
sleep 200
goto pippo
16
V. Lelli
print "questo è un messaggio invisibile"
pippo:
print "avete mica visto il messaggio invisibile?"
sleep
Come vedete l’esecuzione del programma, non appena trova l’istruzione goto pippo, salta
direttamente alla riga contenente l’etichetta pippo: (i due punti ci vanno messi) e prosegue da
lı̀.
Se invece di “guardare” le corsa vogliamo stampare le tabella di marcia, possiamo modificare
il programma cosı̀:
Programma 9.
Achille e la Tartaruga: tabelle di marcia.
dim as double xa, va, dt,xt,vt,t
xa = 0
va = 10
dt = 0.1
xt = 100
vt = 1
t = 0
do
print "tempo ", "Achille ", "Tartaruga "
if xa > xt then print "fine della gara " : stop
print t,xa,xt
xa = xa + va*dt
xt = xt + vt*dt
t = t + dt
sleep 100
loop
Cercate nell’help i nuovi comandi. I due punti (:) servono a separare una istruzione dall’altra
nel caso si voglia scriverle tutte su una riga. La seguente scritta:
dt = 0.1
xt = 100
vt = 1
è equivalente a questa:
dt = 0.1 : xt = 100 : vt = 1
(che occupa meno spazio).
2.2
π
Faremo un programma che calcoli π. Il metodo è poco efficiente anche per un computer, ma è
semplice e funziona. π è l’area del cerchio di raggio r = 1. Il metodo è il seguente ed è stato
17
V. Lelli
chiarito nei dettagli in classe. Questo è solo un promemoria. Ci costruiamo una griglia di punti
che stanno all’interno del quadrato avente un vertice in O(0; 0) e il vertice opposto, giacente sulla
stessa diagonale, in A(1; 1). Il quadrato giace tutto nel primo quadrante. Il seguente programma
crea una tabella con le coordinate x,y dei punti che generiamo.
dim as double j,k
for j
for k
print
sleep
next
next
sleep
= 0 to 1 step 0.1
= 0 to 1 step 0.1
j,k
200
Le novità sono le seguenti: due cicli for annidati l’uno dentro l’altro e il comando step 0.1
che stabilisce il valore per l’incremento dei contatori.
Il quadrato suddetto ha area A = 1. qui ci vanno delle spiegazioni...
Programma 10.
Calcolo di π.
dim as double j,k, pigreco
dim as integer npunti, ndentro
npunti = 0
ndentro = 0
for j = 0 to 1 step 0.01
for k = 0 to 1 step 0.01
npunti = npunti +1
if j^2+k^2 < 1 then ndentro = ndentro + 1
next
next
pigreco = 4*ndentro/npunti
print "pigreco = ", pigreco
sleep
e qui esercizi e modifiche proposte per migliorare il programma.
18
V. Lelli
Capitolo 3
Grafici
3.1
Assi cartesiani
Siamo già capaci di allineare dei cerchietti, non avremo alcuna difficoltà ad allineare dei punti
(pixel). I punti saranno tanti, quindi useremo dei cicli. Il seguente codice traccia l’asse x. Notare
che i pixel sono piuttosto “radi”.
screen 19
window(-10,-10)-(10,10)
dim as single x
for x = -10 to 10 step 0.1
pset(x,0),4
next
sleep
’asse x
Il seguente programma è migliore.
Programma 11.
Assi cartesiani
screen 19
window(-10,-10)-(10,10)
dim as single x
for x = -10 to 10 step 0.01
pset(x,0),4
pset(0,x),4
next
sleep
’asse x
’asse y
Notare che la variabile x è solo un nome... la possiamo utilizzare anche per tracciare l’asse y
(mettendola al posto opportuno).
19
3.2
Rette
Il metodo utilizzato per le rette è valido per qualsiasi funzione.
Programma 12.
Retta y = x
screen 19
window(-10,-10)-(10,10)
dim as single x,y
for x = -10 to 10 step 0.01
pset(x,0),4
pset(0,x),4
next
’asse x
’asse y
’per comodità mettiamo qui il codice per le funzioni
’(lo potevamo mettere dentro il primo ciclo)
for x = -10 to 10 step 0.01
y = x
pset(x,y),2
next
sleep
’qui scriviamo l’eq della funzione
L’unico dettaglio fastidioso è che la bisettrice del primo e terzo quadrante non sembra tanto
bisettrice. Questo perchè la finestra ha una risoluzione di 800x600 pixel, quindi in orizzontale
ci sono più pixel che in verticale, mentre noi abbiamo dichiarato window(-10,-10)-(10,10).
Ovviamo al problema in questa maniera: window(-8,-6)-(8,6). Anche questa è un’applicazione
dell’argomento “la retta”, no? (triangoli simili...).
3.3
Circonferenze
Scriviamo il programma per intero, anche se la modifica sarebbe minima. Notare:
1. Preferiamo window(-8,-6)-(8,6), altrimenti la circonferenza diventa un ellisse.
2. Possiamo disegnare la parte di sopra della circonferenza (e poi quella di sotto).
3. La radice quadrata è sqr( ).
4. Non c’è bisogno di stare attenti a dove varia la x: se x = -10 la sqr( x ) non è un numero
reale. Facendo girare il programma non notiamo particolari problemi...
Programma 13.
Circonferenza x2 + y 2 = 1
screen 19
window(-8,-6)-(8,6)
dim as single x,y
20
V. Lelli
for x = -10 to 10 step 0.01
pset(x,0),4
pset(0,x),4
next
’asse x
’asse y
for x = -10 to 10 step 0.01
y = sqr(1-x^2)
pset(x,y),2
y = -sqr(1-x^2)
pset(x,y),3
next
sleep
3.4
’circonferenza di sopra
’e di sotto
Funzioni trigonometriche
Attenzione: gli angoli sono misurati in radianti e π ∼ 3.14...
Programma 14.
Seno.
screen 19
window(-6,-2)-(6,2)
dim as single x,y
for x = -10 to 10 step 0.01
pset(x,0),4
pset(0,x),4
next
’asse x
’asse y
for x = -10 to 10 step 0.01
y = sin(x)
pset(x,y),2
next
sleep
21
V. Lelli
Capitolo 4
Trasformazioni del piano
4.1
4.1.1
Traslazioni
Attive
Programma 15.
Attive 1
screen 19
window(-10,-10)-(10,10)
dim as single x,y,a,b
x= 1:y=2
a = 0.2: b=0.3
do
circle(x+2,y-5),0.5,2,,,,f
if x>10 then a = -a
if x<-10 then a = -a
if y>10 then b= -b
if y<-10 then b = -b
x = x+a
y = y+b
sleep 100
cls
loop
’cerchio traslato
’in realtà anche questa è una traslazione...
Programma 16.
Attive 2
screen 19
window(-10,-10)-(10,10)
dim as single x,y
for x = -10 to 10 step 0.01
22
pset(x,0),4
pset(0,x),4
next
for x = -10 to 10 step 0.01
y = x^2
pset(x,y),2
pset(x+3,y+2),3
next
sleep
4.1.2
’asse x
’asse y
’qui scriviamo l’eq della parabola
’qui la disegna
’e qui la disegna traslata
Passive
23
V. Lelli

Appunti di Freebasic (FBIde)

Transcript

Documenti analoghi

International Conference on Respiratory Pathophysiology, Sleep

C:\Documents and Settings\Standard\Desktop\TONY PAGLIUCA

Dalla Sleep Endoscopy alla scelta terapeutica

Come ordinare - Exacta Optech+Labcenter SpA

Scarica PDF - CARLO ERBA Reagents

Teorema di Pitagora (Metodo di Garfield)

Scarica PDF - CARLO ERBA Reagents

Circle time - USP di Piacenza

Microscribe Dentale

clicca per continuare la lettura