Alle 
calcolatrici non programmabili
possiamo far eseguire solo singole operazioni di:• addizione, moltiplicazione, … e calcolo di altre funzioni per cui hanno programmi incorporati
• immagazzinamento o estrazione di dati dalle memorie-utente.
Calcolatore (2) - Programmazione (nuova versione)
Alle calcolatrici non programmabili
possiamo far eseguire solo singole operazioni di:
• addizione, moltiplicazione, … e calcolo di altre funzioni per cui hanno programmi incorporati
• immagazzinamento o estrazione di dati dalle memorie-utente.
A un calcolatore (o computer o macchina
calcolatrice programmabile) [ calcolatore 1] possiamo far gestire
l'esecuzione di tutto un algoritmo: esso infatti accetta come
informazioni provenienti dall'esterno:
• non
solo dati e specifici comandi,
• ma
anche programmi che gli indicano l'ordine con cui dovrà
utilizzare i programmi incorporati per elaborare i dati che gli
verranno forniti dall'esterno.
Che
cosa deve essere in grado di fare un computer per eseguire un
programma fornito dall'utente, cioè per tradurlo
in una sequenza di operazioni-macchina?
Consideriamo ad esempio il calcolo della ripartizione percentuale di una serie di dati. Usando una CT possiamo procedere in questo modo:
| (1) | batto 100 | (#) |
| (2) | batto  | |
| (3) | batto totale | |
| (4) | batto  | faccio calcolare il fattore di proporzionalità per cui moltiplicare i dati |
| (5) | batto  | lo faccio mettere nella memoria |
| (6) | batto dato | |
| (7) | batto  | |
| (8) | batto  | |
| (9) | batto | faccio calcolare la percentuale di dato rispetto a totale |
| (10) | ritorno a (6) | vado a introdurre un nuovo dato |
Come si vede, è l'utente che deve
gestire l'esecuzione dell'algoritmo (#), cioè comandare
alla CT man mano quale operazione compiere.
I calcolatori sono invece in grado di
"leggere" e tradurre automaticamente in una sequenza di
operazioni-macchina (calcoli, memorizzazioni, …)
un programma che illustri l'intero procedimento, cioè
una descrizione dell'algoritmo (#) fatta in un opportuno linguaggio
"comprensibile" dal calcolatore.
Molti computer tascabili (o pocket
computer) e tutti i calcolatori di maggiori dimensioni sono in
grado di eseguire il seguente programma (##) scritto
in linguaggio Basic:
| 10 | INPUT T | l'utente deve battere totale |
| 20 | K = 100/T | (##) |
| 30 | INPUT D | l'utente deve battere dato |
| 40 | PRINT D*K | |
| 50 | GOTO 30 |
| È facile comprendere il significato di questo programma, che ha la forma di una sequenza di istruzioni numerate. PRINT in inglese significa "stampa"; GOTO deriva dall'inglese "go to", che significa "vai a". La parola INPUT, che abbiamo già usato funzione 1], |
? 1500 ? 200 13.33333 ? 300 20 ? 100 6.666667 ? |
Per poter eseguire un programma come 
(##)
un pocket computer deve essere in grado di memorizzare il
testo del programma, cioè, nel caso di (##), la seguente
sequenza di caratteri, dove con"ø" e con 
"
20øK=100/T30øINPUTøD40øPRINTøD*K50øGOTOø30
Come le usuali CT memorizzano i numeri
sotto forma di sequenze di bit, così un pocket computer
memorizza sotto forma di una sequenza di bit anche il testo del
programma, utilizzando uno specifico codice.
Deve, inoltre, essere in grado (quando
l'utente gli comanda, con un opportuno tasto, di eseguire
il programma) di leggere (la sequenza di bit con cui
ha codificato) il programma e decidere, man mano, quale operazione
eseguire: una memorizzazione, un richiamo dalla memoria, un
calcolo o una visualizzazione (operazioni che nelle CT non
programmabili vengono comandate direttamente da tastiera), o un
trasferimento dell'esecuzione a un altro punto del programma.
Per fare tutto ciò, il pocket computer
deve avere:
• un
"programma incorporato" per codificare il "programma
battuto dall'utente",
• un
dispositivo di memorizzazione in cui registrare il programma
codificato,
• almeno
26 memorie-utente (memoria A, memoria B, …, memoria Z)
da associare alle diverse lettere dell'alfabeto e
• un
ulteriore "programma incorporato" per tradurre
il programma codificato nell'azionamento dei vari dispositivi di
calcolo, memorizzazione, ….
Esistono versioni più sofisticate del
linguaggio Basic in cui, tra l'altro, si possono usare come variabili
non solo lettere ma nomi composti da più caratteri e in cui non è
necessario scrivere in testa a ogni riga di programma un numero
che indichi l'ordine in cui va eseguita. Poiché esse richiedono dei
programmi di traduzione più complicati, oltre a una maggiore capacità di memorizzazione (possono impiegare un numero molto più alto di variabili) esse vengono impiegate solo su
personal computer o su calcolatori di dimensioni maggiori. Sotto a sinistra, in (###), si vede come il programma (##) può essere riscritto usando una di queste versioni, il QBasic, che ha la caratteristica di essere molto semplice e di essere liberamente riproducibile.
A destra è presentata una stesura del programma in un altro linguaggio, una versione di Pascal (il nome, Pascal, deriva da quello del
famoso filosofo e scienziato francese - vedi - che, nella prima metà del 1600, inventò una delle prime calcolatrici da tavolo, per fare addizioni
e sottrazioni).
|
|
|
Se clicchi QUI si apre una finestra
in cui è incorporato un programma scritto in un altro linguaggio, più recente, chiamato
Javascript. Gli input e gli output sono inseriti in diverse finestrelle invece che elencati
uno sotto l'altro. Ci soffermeremo più avanti su
questo linguaggio, così come su R,
una delle applicazioni matematiche più usate, dopo aver messo a fuoco
alcune idee base riferendoci, per semplictà, al QBasic.
Un computer (personal computer o di dimensioni maggiori), a differenza del pocket computer di cui abbiamo parlato prima, non ha un unico programma traduttore "incorporato", ma è in grado di tradurre in operazioni-macchina un programma scritto in un qualunque linguaggio di programmazione, a patto che gli venga fornito in "input" anche un opportuno programma traduttore.
La CPU di un computer può eseguire direttamente solo un programma che le arrivi sotto forma di una sequenza di bit che, a gruppi, rappresentino direttamente le operazioni-macchina da effettuare. Il linguaggio (che ha come alfabeto i simboli 0 e 1) in cui vengono scritti questi programmi viene detto linguaggio macchina.
I linguaggi di programmazione come i Basic e i Pascal non descrivono direttamente singole operazioni-macchina, ma, come abbiamo visto, • impartiscono comandi più sofisticati (a cui corrispondono più comandi del linguaggio-macchina), • usano come caratteri quasi tutti i simboli della tastiera e • indicano i comandi con nomi che ne richiamano il significato; per questo vengono detti linguaggi evoluti (o di alto livello). Per usare un linguaggio evoluto in genere non si dota il computer solo di un programma traduttore ma di un programma in linguaggio macchina più articolato, che funge da vero e proprio ambiente di programmazione, cioè un programma che contiene come sottoprogrammi:
• un programma redattore (editor) per registrare sotto forma di byte i caratteri battuti dall'utente, ad esempio registrare col nome "percent.bas" il testo del programma (###); in genere è presente anche un help, che richiama uso e significato dei comandi, propone esempi, … .
Un editor è una applicazione per leggere/elaborare testi (come NotePad/BloccoNote in Windows e SimpleText in Mac) che registra i documenti codificando i vari caratteri (lettere, cifre, virgole, spazi bianchi, e altri simboli) attraverso byte, ossia sequenze di 8 bit (i caratteri codificabili in questo modo sono 256; infatti le diverse sequenze di 8 cifre che riesco a costruire con 0 e 1 sono
2·2·2·2·2·2·2·2 = 28 = 256).
Il 
codice impiegato è chiamato ASCII (pronuncia: aski).
Ad esempio "P" è codificato con 01010000 (che interpretato come numero in base 2 corrisponde in base dieci a 16+64 = 80), l'"a capo" con 00001101 (che in base dieci diventa 1+4+8 = 13); si dice che 01010000, o più frequentemente che 80, è il codice ASCII di "P".
[codice simile all'ASCII, usatissimo, è l'UTF-8; in R la codifica/decodifica è
visionabile coi comandi "utf8ToInt" e "intToUtf8"; ad esempio utf8ToInt("P"); intToUtf8(80); intToUtf8(13)
danno come uscite 80, "P" e "\r".
Clicca QUI per una tabella che descrive il codice ascii]
• un programma traduttore per tradurre la sequenza di bit costruita dall'editor, cioè il programma in linguaggio evoluto, in una sequenza di bit che sia la versione in linguaggio macchina del programma. Nel caso del QBasic abbiamo una finestra di lista per la descrizione del programma e una finestra di output per le uscite, in altri casi (ad es. in quello di R) tutto avviene in un'unica finestra.
| finestra di lista: si batte il testo (in linguaggio evoluto) che l'editor codifica in byte (clicca l'immagine per ingrandirla) |  |
 | finestra di output: dopo avere avviato l'esecuzione del programma, vengono visualizzati eventuali output (e vengono battuti eventuali input) |
[se operi da Windows clicca qui per poter aprire dalla finestra a sinistra il QBasic - vedi dalla stessa finestra le informazioni su come incollare nella finestra di lista, o, meglio, in una finestra di BloccoNote/NotePad da aprire con QBasic, programmi ad es. selezionati e copiati da questa voce]
In un ambiente di programmazione la
traduzione in linguaggio macchina può essere avviata operando con il mouse su un menu a cascata
]
In alcuni casi si tratta di un comando (Start o Esegui o …) che ordina la traduzione del programma in linguaggio macchina e il suo invio
alla CPU per l'esecuzione; la versione in linguaggio macchina viene memorizzata temporaneamente; quando l'esecuzione
finisce essa viene persa. Nel caso di R per la traduzione ed esecuzione basta un "a capo".
In altri casi si tratta di un comando (Compile o Make EXE o …) che ordina la traduzione
del programma in linguaggio macchina e la sua registrazione sul disco fisso o su un altro supporto di memorizzazione.
La versione in linguaggio macchina può essere avviata successivamente, anche al di fuori dell'ambiente di
programmazione. Questo tipo di traduzione, che comporta la creazione e registrazione di un programma autonomo
(un file eseguibile), viene detta compilazione.
I programmi "originali", in linguaggio evoluto, vengono detti programmi
sorgenti.
Dei moltissimi programmi che troviamo su un computer, in genere avviabili cliccandone l'icona col mouse,
non conosciamo né le versioni sorgenti né il linguaggio evoluto in cui esse erano state realizzate.
Se li esaminiamo con un editor ci appaiono come una sequenza di caratteri del genere di quella parzialmente riprodotta
qui sotto, estratta da un particolare programma:
Si tratta della decodifica operata dall'editor della sequenza di bit:
01010000 01010001 01010110 01010111 01111011 10100100 01111011 11000111 01111011 11010010 01111011 11101001 10001010 01001000 10011000 01111011 10100011 00100010 01110111
che esso ha interpretato come se fosse stata la codifica ASCII di un testo (01010000 è la codifica di "P", … 01110111 quella di "w"), mentre in realtà si trattava di una sequenza di bit che, a gruppi, rappresentavano comandi in linguaggio macchina.
Nello
stendere un programma in un linguaggio evoluto dobbiamo tener presenti
delle regole di scrittura che garantiscano che il testo battuto sia
effettivamente traducibile in linguaggio macchina. L'insieme di
queste regole di scrittura viene detto sintassi.
Anche
nella lingua naturale esistono delle regole sintattiche. Ad esempio
uno dei modi in cui si può comporre una frase in italiano
è: articolo+nome+verbo dove articolo,
nome e verbo devono essere raccordati in numero
(sing./plu.) e, eventualmente, in genere (m/f), e rispettare
altre eventuali condizioni (es.: davanti ai nomi maschili singolari se
iniziano con z, x, gn, pn, ps, s
seguita da consonante o i seguita da vocale si può mettere
uno non un; negli altri casi si può mettere un,
non uno). Ma
si tratta di regole che spesso presentano eccezioni e su cui spesso
esistono opinioni contrastanti (ad es.qualcuno sostiene che davanti a
pn - pneumatico, pneumotorace, … - occorre, o si può,
usare un). In realtà non si tratta di "regole" ma di modelli
Poi,
anche se ci esprimiamo in modo un po' sgrammaticato, in genere ci
capiamo allo stesso (di fronte al cartello «attendi - lo cane
morzica» non abbiamo difficoltà a interpretarlo come
«Attenti: il cane morsica»).
Nel
caso dei linguaggi di programmazione le regole sintattiche sono invece
definite senza ambiguità ed eccezioni (per questo si parla di
linguaggi formali) e devono essere rispettate
rigorosamente: se invece di print si
è scritto prlnt (una "l" al posto della "i") il programma traduttore
non può meccanicamente individuare l'operazione che l'utente
voleva indicare.
L'help indica le regole sintattiche da rispettare per costruire i programmi. Ecco la parte dell'help del Qbasic relativa alle assegnazioni, come l'istruzione (###). In "[LET] variabile=espressione" le parentesi quadre indicano una parte opzionale; "variabile" e "espressione" fungono da variabili sintattiche, cioè sono nomi che indicano (non numeri o altri oggetti matematici ma) generiche espressioni del linguaggio, così come lo è "termine" quando definiamo equazione come
La prima riga dell'help spiega sinteticamente la semantica delle assegnazioni, cioè
come esse vengono tradotte in linguaggio macchina (ossia il loro "significato; nel caso del linguaggio comune la semantica
si riferisce al significato di parole e frasi, qui a quello di istruzioni e programmi). Una spiegazione più dettagliata
è presente alla voce
struttura di un termine: vengono associati dei registri di memorizzazione alle
variabili che compaiono nella assegnazione e poi vengono man mano calcolati i valori intermedi utilizzando eventualmente
altri registri di lavoro, fino al calcolo del risultato finale e la sua memorizzazione nel registro associato alla variabile
a sinistra di "=".
Nel caso di R le assegnazioni vengono realizzate con istruzioni del
tipo
Nota. Nell'help del Qbasic, nel rimando alla voce "struttura di un termine" viene spiegata
la semantica delle assegnazioni numeriche. Vi sono anche le assegnazioni stringa:
una stringa è una sequenza di caratteri, un termine stringa
è • una costante stringa (ossia una sequenza di caratteri
racchiusa tra virgolette), • una variabile stringa (a seconda del
linguaggio di programmazione può essere una variabile
precedentemente dichiarata di tipo "stringa" con un opportuno comando [in Qbasic si può fare coi
comandi DEFSTR e DIM] o che sia implicitamente dichiarata di tipo stringa mediante la presenza del
suffisso $, es.: nome$, o a cui sia stato assegnato un termine stringa, come in R)
oppure • una espressione costruita a partire da costanti e
variabili stringa mediante concatenazioni (l'operazione di concatenazione in Qbasic è indicata
con "+", in R col comando "paste").
Esempio: in QBasic l'assegnazione
[vi sono anche altri modi per ottenere termini stringa. Ad esempio in
Qbasic CHR$(TermineNumerico) è un termine stringa
che ha come valore il carattere avente TermineNumerico come codice ASCII; in particolare CHR$(80) ha come
valore "P"]
Nel
caso del Qbasic l'espressione:
10 INPUT x: PRINT x/(SQR(4)-2): GOTO 10
(SQR indica la radice quadrata) è un programma costruito
rispettando le regole sintattiche del linguaggio. Infatti se eseguo il programma non compare alcun messaggio che segnali la presenza di errori "sintattici": il programma traduttore riesce a leggere il programma (e a tradurlo in linguaggio macchina).
Ma, appena batto un dato dopo il prompt "?" (il segnale con cui viene sollecitato l'utente a introdurre informazioni da tastiera), l'esecuzione si
arresta e viene segnalato un errore in corso di esecuzione (run-time
error): "divisione per 0". Infatti il computer, nel
dare un "significato" alle istruzioni, cioè
nell'eseguire le azioni da esse comandate, si trova di fronte al
calcolo di un termine indefinito.
Nota. Questo programma è costituito da un'unica
approfondimenti) concatenate
con ":". In Pascal e in altri linguaggi non esiste questo concetto: le "istruzioni composte" sono sequenze
di istruzioni (separate da ";") racchiuse tra un "begin" e un "end".
In JavaScript, invece,
le istruzioni composte sono
racchiuse tra una coppia di parentesi graffe.
In R più istruzioni possono stare sulla stessa riga se separate da ";"; un'istruzione può essere
spezzata su più righe; più istruzioni possono essere accorpate se racchiuse da una coppia di parentesi graffe;
le istruzioni di "input" sono realizzabili mediante il comando "scan".
Nel
caso di:
IF 0>1 THEN PRINT "a" ELSE PRINT "b"
non abbiamo né errori sintattici né errori semantici: il
computer dà come uscita b senza visualizzare alcun
messaggio. La condizione 0>1 è scritta
correttamente (non presenta errori sintattici) e il computer riesce a
darle un significato, cioè a determinare che è
una condizione "falsa" (non presenta errori semantici).
[ è facile comprendere il significato di questa istruzione tenendo conto che "if", "then" e "else" in inglese significano rispettivamente "se", "allora" e "altrimenti"]
I
linguaggi di programmazione sono lo strumento tipico per automatizzare
procedimenti di calcolo. In " approfondimenti" sono presenti alcuni altri richiami ed esempi relativi al Qbasic.
Esistono anche altre applicazioni che possono essere utilizzate per la definizione ed esecuzione di algoritmi e che
non sono in senso stretto dei linguaggi di programmazione; anche R, a cui abbiamo più volte accennato,
rientra in questa categoria.
Per esse si veda la successiva voce calcolatore 3.
Per il software "MaCoSa" rinviamo al link programmi apribili accessibile da 
.
altri collegamenti [nuova pagina]
Approfondimenti
Ancora sul QBasic
Di seguito sono indicate le principali parole chiave del Qbasic, cioè le parole "riservate" che in tale linguaggio si utilizzano per indicare comandi, funzioni, … e che non possono essere impiegate come nomi di variabili, etichette, sottoprogrammi, …. Rimandiamo all'help del linguaggio per spiegazioni sintattiche e semantiche, ed esempi. In grassetto sono segnalati gli elementi del linguaggio più utili da esaminare per un primo approfondimento. In blu-sottolineato sono indicati collegamenti ("cliccabili") a esemplificazioni.
Imparare ad usare il QBasic può essere utile anche per poi passare all'uso di applicazioni più recenti ed evolute come il VisualBasic o come altri linguaggi di programmazione "freeware", ossia scaricabili e usabili gratuitamente, come il RapidQBasic (clicca QUI o QUI per collegarti al relativo sito, QUI per collegarti alla relativa guida).
Un linguaggio, evoluto ma particolarmente semplice da utilizzare per realizzare
programmi di non grandi dimensioni, è il JavaScript (in breve, JS). Un
programma traduttore di questo
linguaggio è incoportato in tutti i browser, ossia in tutti i programmi per visualizzare
"documenti-web" come questo (Netscape, Internet Explorer, Opera, Mozilla, …). Il testo del
programma viene messo all'interno di un documento Html (ossia in un documento-web). La sintassi
è abbastanza simile a quella del QBasic. Tra le differenze, oltre a quelle legate al fatto
che input e output sono tutti all'interno di una normale pagina-web, ricordiamo che in JS variabili con
nomi formati dalla stessa sequenza di lettere ma con alcune di esse di diemensioni diverse sono
intese come diverse (es.: datoIniziale e DatoIniziale sono diverse), che nelle
condizioni invece di "=" e di "<>" occorre usare "==" e "!=". Vi sono poi delle differenze
nell'indicazione di alcuni simboli per le funzioni matematiche e nel modo in cui sono
scritti comandi come while, for ed altri illustrati qui sotto per il QBasic.
QUI troverai alcuni primi esempi di programmi in JS.
Classe Parole chiave comprese in questa classe
-------------------------------- ---------------------------------------
Controllo del flusso DO...LOOP, END, EXIT, FOR...NEXT,
del programma IF...THEN...ELSE, GOSUB...RETURN,
GOTO, ON...GOSUB, ON...GOTO,
SELECT CASE, STOP, SYSTEM, WHILE...WEND
Commenti REM (o ' )
Dichiarazione delle costanti e CONST, DATA, DIM, DEF..., ERASE, LET
delle variabili, assegnazione OPTION BASE, READ, REDIM RESTORE, SWAP,
di valori TYPE...END TYPE
Definizione e chiamata delle CALL, DECLARE, EXIT, FUNCTION, RUN,
procedure di BASIC SHELL, SHARED, STATIC, SUB
Periferica di input/output CLS, CSRLIN, INKEY$, INP, INPUT,
KEY (Assegnazione), LINE INPUT, LOCATE,
LPOS, LPRINT, LPRINT USING, OPEN COM,
OUT, POS, PRINT, PRINT USING, SPC,
Funzione SCREEN, TAB, VIEW PRINT,
WAIT, WIDTH
Visualizzazione di immagini CIRCLE, COLOR, GET (Grafica), LINE,
grafiche PAINT, PALETTE, PCOPY, PMAP, POINT,
PRESET, PSET, PUT (Grafica),
SCREEN Istruzione, VIEW, WINDOW
Produzione di suoni BEEP, PLAY, SOUND
Comandi del sistema DOS CHDIR, KILL, MKDIR, NAME, RMDIR, SHELL...
Input/output di file CLOSE, EOF, FILEATTR, FREEFILE
GET (I/O di file), INPUT, INPUT$,
LINE INPUT, LOC, LOCK, LOF, OPEN,
PUT (I/O di file), Funzione SEEK,
Istruzione SEEK, UNLOCK, WRITE
Gestione della memoria CLEAR, FRE, PEEK, POKE
Elaborazione delle stringhe ASC, CHR$, HEX$, INSTR, LCASE$, LEFT$,
LEN, LSET, LTRIM$, Funzione MID$,
Istruzione MID$, OCT$, RIGHT$, RSET,
RTRIM$, SPACE$, STR$, STRING$, UCASE$,
VAL
Esecuzione di calcoli matematici ABS, AND, ASC, ATN, CDBL, CINT, CLNG,
e ——> logici e altre funzioni COS, CSNG, CVDMBF, CVSMBF, DATE$, EQV,
numeriche e stringa EXP, FIX, IMP, INT, LOG, MOD, NOT, OR,
RANDOMIZE, RND, SGN, SIN, SQR, TAN,
TIME$, TIMER, XOR
Impostazione della gestione COM, ERDEV, ERDEV$, ERL, ERR, ERROR,
degli eventi e degli errori KEY (Gestione eventi), ON COM, ON ERROR,
ON KEY, ON PEN, ON PLAY, ON STRIG,
ON TIMER, PEN, PLAY (Gestione eventi),
RESUME, RETURN, STRIG, Istruzione TIMER |
| Qualche esempio che illustra alcune delle principali parole chiave: • una versione in QBasic del procedimento descritto con un diagramma di flusso alla voce diagrammi che esemplifica il comando FOR: |
PRINT "Cambi eseguiti:" PRINT " 500=200+200+100 200=100+100 100=50+50" Introduzione: INPUT ; "Introduci moneta ", m IF m=500 THEN a=2: b=1: c=0: GOTO Restituzione IF m=200 THEN a=0: b=2: c=0: GOTO Restituzione IF m=100 THEN a=0: b=0: c=2: GOTO Restituzione PRINT m : GOTO Introduzione Restituzione: PRINT " cambio: "; FOR i=1 TO a: PRINT 200;: NEXT FOR i=1 TO b: PRINT 100;: NEXT FOR i=1 TO c: PRINT 50;: NEXT PRINT GOTO Introduzione |
FOR...NEXT
Ripete un blocco di istruzioni per un determinato numero di volte
FOR contatore = inizio TO fine [STEP incremento]
[bloccoistruzioni]
NEXT [contatore [,contatore]...]
-> contatore Una variabile numerica usata come contatore del ciclo
-> inizio e fine I valori iniziale e finale del contatore
-> incremento Dopo ogni iterazione, il valore del contatore viene
modificato.
| • una versione del precedente procedimento che utilizza le istruzioni WHILE e SELECT CASE: |
PRINT "Cambi eseguiti:"
PRINT " 500=200+200+100 200=100+100 100=50+50"
WHILE 1
INPUT ; "Introduci moneta ", m
PRINT " cambio: ";
SELECT CASE m
CASE 500
a = 2: b = 1: c = 0
CASE 200
a = 0: b = 2: c = 0
CASE 100
a = 0: b = 0: c = 2
CASE ELSE
a = 0: b = 0: c = 0: PRINT m;
END SELECT
FOR i = 1 TO a: PRINT 200; : NEXT
FOR i = 1 TO b: PRINT 100; : NEXT
FOR i = 1 TO c: PRINT 50; : NEXT
PRINT
WEND |
WHILE...WEND
Esegue una serie di istruzioni fino a che una condizione specificata
e' vera.
WHILE condizione
...
WEND
-> condizione Un'espressione numerica che Basic valuta come vera
(diversa da zero) o falsa (zero).
SELECT CASE
Esegue uno tra più blocchi di istruzioni a seconda del valore assunto
dall'espressione.
SELECT CASE espressionetest
CASE elencoespressioni1
[bloccoistruzioni-1]
[CASE elencoespressioni2
[bloccoistruzioni-2]]...
[CASE ELSE
[bloccoistruzioni-n]]
END SELECT
-> espressionetest Qualsiasi espressione numerica o a stringa.
-> elencoespressioni1 Una o più espressioni che corrispondano ad
elencoespressioni2 espressionetest
La parola chiave IS deve precedere ogni operatore
relazionale contenuto in un'espressione
-> bloccoistruzioni-1 Una o più istruzioni contenute su una o più
bloccoistruzioni-n righe
-> Gli argomenti di elencoespressioni possono avere una delle forme
seguenti o una combinazione di queste, a patto che siano separate da
una virgola.
espressione[,espressione]...
espressione TO espressione
IS operatore relazionale espressione
-> espressione Qualsiasi espressione numerica o stringa
compatibile con espressionetest
-> operatore relazionale Uno tra i seguenti operatori relazionali:
<, <=, >, >=, <>, o =
|
• Un programma che automatizza il procedimento numerico per risolvere equazioni illustrato alla voce risoluzione di equazioni 1 e che illustra il funzionamento dei sottoprogrammi GOSUB (le righe inizianti con ', o, equivalentemente, con REM, contengono commenti che servono a chi legge il programma; sono saltate dal programma traduttore): |
CLS
DEFDBL A-Z
'le variab. inizianti per A..Z useranno registri di capacita` doppia
PRINT "Cerco x t.c. f(x)=0"
PRINT "Tu scegli l'appr. per dif. x0 e l'incremento h iniziali"
Via:
INPUT ; "x0=", x: INPUT " h=10^N, N=", n
PRINT " x"; TAB(27); "f(x)" ' f(x) e` stampato alla 27^ colonna
GOSUB F: s = SGN(y): x0 = x: h = 10 ^ n: i = 0 'SGN e` la funz. segno
Ciclo:
i = i + 1: x = x0 + h * i: GOSUB F
'L'esecuzione, trasferita ad F, ritorna qui quando incontra RETURN
'PRINT x; TAB(25); y; TAB(50); : INPUT " premi ACapo", a$
'Per vedere i calcoli intermedi togli l'apostrofo dalla riga prec.
IF y = 0 OR y = y0 THEN COLOR(14): PRINT x; TAB(25); y: END
IF i = 1000 THEN PRINT "fino a x="; x; "f(x) non ha mutato segno": END
IF SGN(y) = s THEN y0 = y: GOTO Ciclo
x0 = x0 + h * (i - 1): n = n - 1: h = 10 ^ n: i = 0
GOTO Ciclo
F: y = x + 10 - x * x
'assegna a y il termine f(x)
RETURN
La ricerca delle due soluzioni:
x=3 h=10^N, N=0
x f(x)
3.701562118716424 4.969982758673552D-16
x=-4 h=10^N, N=0
x f(x)
-2.701562118716425 -2.346213501258632D-15
Le uscite se (togliendo l'apostrofo alla 3ª riga del ciclo) si
attiva la stampa dei valori ma mano calcolati:
x=3 h=10^N, N=0
x f(x)
3 4 premi a capo
4 -2 premi a capo
3.1 3.489999999999999 premi a capo
3.2 2.959999999999999 premi a capo
|
GOSUB
Passa a e ritorna da una subroutine
GOSUB riga1
...
RETURN [riga2]
-> riga1 L'etichetta o il numero della prima riga della subroutine.
-> riga2 L'etichetta o il numero della riga a cui ritorna l'esecuzione;
in assenza di 'riga2' l'esecuzione riprende dall'istruzione
che segue il GOSUB da cui è stata avviata la subroutine
|
• Un programma per moltiplicare numeri comunque lunghi che illustra il funzionamento di alcune funzioni stringa e l'uso dei sottoprogrammi SUB (su questi vedi anche calcolatore 5): |
PRINT "Moltiplicazione tra numeri naturali comunque lunghi"
Via:
INPUT "x"; x$
INPUT "y"; y$
z$ = "": zeri$ = "" ' In Z mettero' il risultato
L1 = LEN(x$): L2 = LEN(y$) ' Le lungh. dei numeri X e Y
n = 0 ' Considero le unita' di Y
WHILE n < L2
w$ = "": r = 0
c2$ = MID$(y$, L2 - n, 1) ' La cifra di posto N di Y
m = 0 ' Considero le unita' di X
WHILE m < L1
c1$ = MID$(x$, L1 - m, 1) ' La cifra di posto M di X
c = VAL(c1$) * VAL(c2$) + r ' ProdottoCifre + riporto
c$ = STR$(c)
w$ = RIGHT$(c$, 1) + w$ ' Chiamo W la cifra a destra e
r = c \ 10 ' R il riporto ('\': div. intera)
m = m + 1 ' Avanzo di un posto su X
WEND
SOMMA z$, w$ + zeri$, s$ ' Con il Sub SOMMA aggiungo
z$ = s$ ' W0..0 a Z
n = n + 1: zeri$ = zeri$ + "0" ' Avanzo di un posto su Y
WEND
IF r > 0 THEN z$ = STR$(r) + z$ ' Aggiungo l'ultimo riporto
PRINT z$
INPUT "smetto (1: SI`, 0: NO)"; risp
IF risp = 0 THEN GOTO Via ELSE END
SUB SOMMA (x$, y$, z$) STATIC
' Somma tra numeri naturali comunque lunghi
z$ = "": r = 0
L1 = LEN(x$)
L2 = LEN(y$)
n = 0 'considero le unita' (cifre di posto 0)
WHILE n < L1 OR n < L2
'sommo le cifre; prendo 0 come cifre in testa al numero piu` corto
IF n < L1 THEN c1$ = MID$(x$, L1 - n, 1) ELSE c1$ = "0"
IF n < L2 THEN c2$ = MID$(y$, L2 - n, 1) ELSE c2$ = "0"
c = VAL(c1$) + VAL(c2$) + r
c$ = STR$(c)
z$ = RIGHT$(c$, 1) + z$
IF c > 9 THEN r = 1 ELSE r = 0 'il resto
n = n + 1 'passo alla cifra di ordine di grandezza successivo
WEND
IF r = 1 THEN z$ = "1" + z$
END SUB
Moltiplicazione tra numeri naturali comunque lunghi
x? 123456789012345678901234567890
y? 111111111111111111111111111111
13717421001371742100137174209986282578998628257899862825790
smetto (1: SI`, 0: NO)?
|
SUB
Definisce una procedura
SUB nome[(elencoparametri)] [STATIC]
[bloccoistruzioni]
END SUB
-> nome Il nome di una procedura SUB, lungo fino a 40
caratteri e senza il suffisso del tipo di dati.
-> elencoparametri Una o più variabili che specificano i parametri
da passare alla procedura SUB quando questa viene
chiamata:
variabile[( )] [, variabile[( )]]...
-> STATIC Specifica che i valori delle variabili locali della
procedura SUB vengono salvati tra una chiamata di
funzione e l'altra.
-> Quando viene chiamata una Procedura SUB, è possibile specificare
che il valore di un argomento non deve essere cambiato dalla
procedura racchiudendo tale valore tra parentesi
ASC restituisce il codice ASCII del 1° carattere di un'espressione a stringa
CHR$ restituisce il carattere corrispondente ad un codice ASCII specificato.
ASC(espressioneastringa$)
CHR$(codice ascii%)
-> espressioneastringa$ Un'espressione a stringa qualsiasi.
-> codice ascii% Il codice ASCII del carattere desiderato.
Esempio:
PRINT ASC("Q") 'Risultato: 81
PRINT CHR$(65) 'Risultato: A
DATA specifica i valori che vanno letti dalle istruzioni READ successive.
READ legge quei valori e li assegna a delle variabili.
RESTORE permette a READ di rileggere dei valori all'interno di istruzioni
DATA specificate.
DATA costante[,costante]...
READ elencovariabili
RESTORE [riga]
-> costante Una o più costanti stringa o numeriche che indicano i
dati che vanno letti. Le costanti stringa contenenti
virgole, due punti o spazi iniziali o in coda vengono
racchiuse tra virgolette.
-> elencovariabili Una o più variabili separate da virgole a cui vengono
assegnati dei valori di dati. I nomi delle variabili
sono composti da un massimo di 40 caratteri e devono
iniziare con una lettera. I caratteri ammessi sono
A-Z, 0-9 e il punto.
-> riga L'etichetta o il numero di riga di un'istruzione DATA.
Se la riga non viene specificata, l'istruzione READ
successiva legge i valori contenuti nella prima
istruzione DATA incontrata nel programma.
-> Le istruzioni DATA possono essere specificate soltanto al livello
modulo e non possono essere usate nelle procedure.
Esempio:
FOR i% = 1 TO 3
READ a%, b$
PRINT a%, b$
RESTORE
NEXT i%
DATA 1, "Ripeti"
FIX tronca un'espressione numerica agli interi.
INT restituisce la "parte intera" di (ossia il maggiore intero
minore o uguale ad) un'espressione numerica.
Esempi:
PRINT FIX(12.49), FIX(12.54) 'Risultato: 12 12
PRINT INT(12.54), INT(-99.4) 'Risultato: 12 -100
IF ... THEN ... ELSE ...
esegue un'istruzione o un blocco di istruzioni a seconda delle condizioni.
IF condizione1 THEN
[bloccoistruzioni-1]
[ELSEIF condizione2 THEN
[bloccoistruzioni-2]]...
[ELSE
[bloccoistruzioni-n]]
END IF
IF condizione THEN istruzioni [ELSE istruzioni]
-> condizione1 Ogni espressione che Basic valuta come vera
condizione2 (diversa da zero) o falsa (zero).
-> bloccoistruzioni-1 Una o più istruzioni su una o più righe.
bloccoistruzioni-2
bloccoistruzioni-n
-> istruzioni Una o più istruzioni separate dai due punti.
esempio altro esempio:
INPUT "1 o 2? ", i%
IF i% = 1 OR i% = 2 THEN
PRINT "Va bene"
ELSE
PRINT "Valore non ammesso"
END IF
INPUT legge l'input dalla tastiera o da un file
LINE INPUT legge una riga lunga fino a 255 caratteri da tastiera o da file
INPUT [;] ["prompt"{; | ,}] elencovariabili
LINE INPUT [;] ["prompt";] variabile$
INPUT #numerofile%, elencovariabili
LINE INPUT #numerofile%, variabile$
-> prompt Una stringa di testo opzionale che viene visualizzata
prima dell'immissione dei dati da parte dell'utente.
Se si fa seguire il prompt da un punto e virgola, la
stringa del prompt apparirà seguita da un punto di
domanda.
-> elencovariabili Una o più variabili separate da una virgola alle quali
vengono assegnati i dati immessi dalla tastiera o letti
da un file. I nomi delle variabili possono essere costi-
tuiti da un massimo di 40 caratteri e devono iniziare
con una lettera. I caratteri ammessi sono le lettere
dalla A alla Z, i numeri da 0 a 9 ed il punto.
-> variabile$ Contiene una riga di caratteri immessi dalla tastiera o
letti da un file.
-> numerofile% Il numero di un file aperto.
-> INPUT richiede una virgola per separare più variabili.
LINE INPUT legge tutti i caratteri incontrati fino a che non incontra un
ritorno a capo.
-> Se i dati vengono immessi dalla tastiera, un punto e virgola dopo INPUT
provvede a mantenere il cursore sulla stessa riga dopo che è stato
premuto Invio.
esempio esempio
MOD divide un numero per un altro e restituisce il resto intero.
espressione numerica1 MOD espressione numerica2
-> espressione numerica1 Espressioni numeriche qualsiasi. I numeri
espressione numerica2 reali vengono arrotondati ad interi.
Esempio:
PRINT 19 MOD 6.7 'QBASIC arrotonda 6.7 a 7 poi esegue la divisione.
'Risultato: 5 (resto di 19 diviso 7)
PRINT invia i dati allo schermo o li scrive su un file.
PRINT [#numerofile%,] [elencoespressioni] [{; | ,}]
-> numerofile% Il numero di un file aperto. Se non viene specificato
alcun valore, PRINT invia i dati allo schermo.
-> elencoespressioni Un elenco di una o più espressioni numeriche o a
stringa che si desiderano inviare ad una periferica
tramite PRINT.
-> {; | ,} Determina da dove deve iniziare l'output successivo:
; inizia l'output subito dopo l'ultimo valore
, inizia l'output all'inizio della prima zona di
output che incontra. Una zona di output è larga
14 caratteri.
esempio esempio esempio
SWAP Scambia i valori di due variabili.
SWAP variabile1, variabile2
-> variabile1 e variabile2 Due variabili dello stesso tipo
di dati.
Esempio:
a% = 1: b% = 2
PRINT "Prima: "; a%, b%
SWAP a%, b%
PRINT "Dopo: "; a%, b%
TAB
Sposta il cursore di testo nel punto in cui si vuole che inizi l'output.
TAB(colonna%)
-> colonna% Il numero della colonna del successivo punto di output.
Esempio:
PRINT TAB(25); "Testo"
TIMER
Restituisce il numero di secondi trascorsi dalla mezzanotte.
-> Usare TIMER per cronometrare l'esecuzione di una parte o di un intero
programma oppure con l'istruzione RANDOMIZE per generare un numero
casuale.