Flowgorithm

© 2023 Roberto Atzori

 2 Flowgorithm

Sommario

Capitolo I Introduzione 8
1 Introduzione ................................................................................................................. 11

Capitolo II Installazione 13
1 Sistema Operativo Windows ......................................................................................... 14
Versione 64 bit .................................................................................................................................................................. 14
Versione 32 bit .................................................................................................................................................................. 14
2 Sistema Operativo iOS ................................................................................................. 14
Emulatore Wine ................................................................................................................................................................. 15
GitHub ................................................................................................................................................................................. 15
Video Youtube ................................................................................................................................................................... 16
3 Sistema Operativo Linux .............................................................................................. 16

Capitolo III Flowgorithm 18

1 Caratteristiche e funzionalità ........................................................................................ 19
L’interfaccia ....................................................................................................................................................................... 19
Caratteristiche principali ................................................................................................................................................ 19
Supporto Multilingua ................................................................................................................................................... 19
Grafica Tartaruga ....................................................................................................................................................... 21
Concetti di base .................................................................................................................................................. 21
Equivalenza tra LOGO (base) e Flowgorithm .................................................................................................. 24
Supporto base sui File ............................................................................................................................................... 26
Interruzione con condizione ....................................................................................................................................... 26
Generazione interattiva del codice ........................................................................................................................... 27
Temi ............................................................................................................................................................................. 28
Menù ............................................................................................................................................................................ 28
Finestre con aspetto automatico .............................................................................................................................. 29
Finestra "Visualizzazione Variabili" ......................................................................................................................... 29
Specifiche ................................................................................................................................................................... 29
In aggiunta ................................................................................................................................................................... 30

Capitolo IV Flowgorithm nel dettaglio 31

1 Barra del menù ............................................................................................................. 32
Voce di menù “File” ......................................................................................................................................................... 32
Stampa ........................................................................................................................................................................ 33
Voce di menù “Modifica” ................................................................................................................................................ 34
Voce di menù “Aspetto” ................................................................................................................................................. 34
Lingua .......................................................................................................................................................................... 35
Dimensionamento ...................................................................................................................................................... 35
Selezione Combinazione di colori ............................................................................................................................ 36
Stile diagramma ......................................................................................................................................................... 36
Modifica schema colori .............................................................................................................................................. 37
Modifica Stile Diagramma ........................................................................................................................................ 38
Voce di menù “Programma” ......................................................................................................................................... 40
Velocità di esecuzione ............................................................................................................................................... 41

© 2023 Roberto Atzori

 Contenuti 3

Rimuovere i punti di arresto ...................................................................................................................................... 41

Nuova Funzione .......................................................................................................................................................... 41
Gestione funzioni utente ............................................................................................................................................. 42
Informazioni programma ............................................................................................................................................ 43
Voce di menù “Strumenti” ............................................................................................................................................. 44
Esporta immagine in un file ....................................................................................................................................... 44
Esporta immagine in formato vettoriale ................................................................................................................... 45
Voce di menù “Aiuto” ...................................................................................................................................................... 46
2 Barra dei pulsanti ......................................................................................................... 48

Capitolo V Le finestre di Flowgorithm 50

1 Finestra “Esecuzione” .................................................................................................. 51
2 Finestra “Codifica” ....................................................................................................... 52
3 Finestra “Variabili” ....................................................................................................... 55
4 Finestra grafica “Tartaruga” ........................................................................................ 56
5 Disposizione finestre .................................................................................................... 58

Capitolo VI Menù contestuale 59

Capitolo VII Funzioni predefinite 61

1 Matematiche ................................................................................................................. 62
2 Stringa .......................................................................................................................... 62
3 Conversione tipo di dati ............................................................................................... 63
4 Altre .............................................................................................................................. 63

Capitolo VIII Costanti predefinite 64

Capitolo IX Istruzioni 66
1 Output .......................................................................................................................... 67
2 Input ............................................................................................................................. 69
3 Assegnazione ............................................................................................................... 69
4 Commento .................................................................................................................... 70
5 Dichiarazione ................................................................................................................ 71
6 If ................................................................................................................................... 72
7 Cicli di ripetizione ......................................................................................................... 73
For ........................................................................................................................................................................................ 73
Do ......................................................................................................................................................................................... 73
While .................................................................................................................................................................................... 74
8 Chiamata di Funzione o Procedura ............................................................................... 75
9 Grafica Tartaruga ......................................................................................................... 75
Ruotare ............................................................................................................................................................................... 75
Avanzare ............................................................................................................................................................................. 75
Punto iniziale ..................................................................................................................................................................... 76
Esempi ................................................................................................................................................................................ 76
Disegno di un fiore ..................................................................................................................................................... 76
Scalinate ...................................................................................................................................................................... 77

© 2023 Roberto Atzori

 4 Flowgorithm

10 Gestione File ................................................................................................................ 78

Lettura ................................................................................................................................................................................. 78
Scrittura .............................................................................................................................................................................. 78
Chiusura ............................................................................................................................................................................. 78
Apertura .............................................................................................................................................................................. 78
Esempi ................................................................................................................................................................................ 80
Fibonacci con utilizzo di file ....................................................................................................................................... 80
Calcolo dei quadrati ................................................................................................................................................... 81
11 Interruzioni con condizione .......................................................................................... 81

Capitolo X Per gli Amministratori di Sistema 82

1 Installazione silente ...................................................................................................... 83
Versione 2.15 e precedenti ............................................................................................................................................ 83
Versione 2.16 e successive ........................................................................................................................................... 83
2 Impostazioni nel file registro di Windows ..................................................................... 83
Chiavi Registro ................................................................................................................................................................. 84
Cartella Radice ........................................................................................................................................................... 84
Chiavi per l’utente ................................................................................................................................................ 85
Cartella ‘Printer’ .......................................................................................................................................................... 85
Cartella ‘Shapes’ ........................................................................................................................................................ 86
Cartella ‘Source Code Viewer’ ................................................................................................................................. 88
Cartella ‘Colors’ .......................................................................................................................................................... 88
Chiavi per l’Amministratore ........................................................................................................................................... 90

Capitolo XI Creare una Traduzione 92

1 Formato Base del File ................................................................................................... 93
2 Provare la Traduzione .................................................................................................. 94
3 Durante la Traduzione .................................................................................................. 95
4 Altro ............................................................................................................................. 95

Capitolo XII Formato File Sorgente 96

Capitolo XIII Programmazione e Flowgorithm 105

1 Il mio primo diagramma di flusso ................................................................................ 106
2 Tipi di dato ................................................................................................................. 108
Integer (Intero) ................................................................................................................................................................. 108
Real (Reale) ...................................................................................................................................................................... 108
String (Stringa) ................................................................................................................................................................ 108
Boolean (Booleano o Logico) ..................................................................................................................................... 109
3 Identificatori ............................................................................................................... 109
4 Parole chiave .............................................................................................................. 109
5 Operatori .................................................................................................................... 109
Precedenze ...................................................................................................................................................................... 110
6 Funzioni e Procedure .................................................................................................. 111
Differenza tra FUNZIONE e PROCEDURA ............................................................................................................... 111
Passaggio dei parametri .............................................................................................................................................. 112
Esempio 1 in Flowgorithm ...................................................................................................................................... 113
Esempio 2 in Flowgorithm ...................................................................................................................................... 115

© 2023 Roberto Atzori

 Contenuti 5

7 La ricorsione .............................................................................................................. 118

Introduzione .................................................................................................................................................................... 118
Funzione (o Procedura) ricorsiva .............................................................................................................................. 122
Esempio in Flowgorithm .............................................................................................................................................. 123

Capitolo XIV Paradigma di Programmazione 126

1 Gli elementi di base .................................................................................................... 127
Introduzione .................................................................................................................................................................... 127
Tipi di paradigmi ............................................................................................................................................................. 127
Formato File ..................................................................................................................................................................... 128
Estensione del file .................................................................................................................................................... 129
Formato File (elementi base) ................................................................................................................................. 129
Formato Linea .......................................................................................................................................................... 130
Campi ........................................................................................................................................................................ 130
Linee Multiple ............................................................................................................................................................ 131
Flag ............................................................................................................................................................................ 131
Indentazione .............................................................................................................................................................. 132
Flags Globali .................................................................................................................................................................... 132
Funzioni intrinseche ................................................................................................................................................. 133
Array .......................................................................................................................................................................... 134
Altro ............................................................................................................................................................................ 134
Programma ...................................................................................................................................................................... 134
La chiave testuale .................................................................................................................................................... 135
2 Identificatori e Tipi ...................................................................................................... 136
Attributi del linguaggio ................................................................................................................................................. 136
Attributi ...................................................................................................................................................................... 136
Identificatori ..................................................................................................................................................................... 137
Creazione di nuovi identificatori ............................................................................................................................. 138
La chiave ‘Convention’ ..................................................................................................................................... 138
La chiave ‘Normal’ ............................................................................................................................................ 139
La chiave ‘Conflict’ ............................................................................................................................................ 139
Tipi ..................................................................................................................................................................................... 140
3 Gli elementi testuali .................................................................................................... 141
I valori stringa testuali ................................................................................................................................................... 141
La chiave ‘Text’ ......................................................................................................................................................... 141
La chiave ‘Replace’ ................................................................................................................................................. 141
valori interi testuali ......................................................................................................................................................... 142
La chiave ‘Text’ ......................................................................................................................................................... 142
I valori reali testuali ........................................................................................................................................................ 142
La chiave ‘Text’ ......................................................................................................................................................... 143
I valori booleani testuali ................................................................................................................................................ 143
Le chiavi ‘True’ e ‘False’ ......................................................................................................................................... 143
4 Espressioni ................................................................................................................. 144
Espressioni e funzioni intrinseche ............................................................................................................................ 144
Espressioni ............................................................................................................................................................... 144
Livelli di precedenza ......................................................................................................................................... 144
La sezione ‘Subexpression’ ............................................................................................................................ 145
Sezioni e Flags ......................................................................................................................................................... 145
Sezioni ............................................................................................................................................................... 145
Chiavi ................................................................................................................................................................. 146
Flags ................................................................................................................................................................... 147
Accesso alla variabile ................................................................................................................................................... 149
La chiave ‘Precedence’ ........................................................................................................................................... 150

© 2023 Roberto Atzori

6 Flowgorithm

La chiave ‘Text’ ......................................................................................................................................................... 150

Elenco Argomenti .......................................................................................................................................................... 151
La chiave ‘Separator’ .............................................................................................................................................. 151
La chiave ‘Text’ ......................................................................................................................................................... 151
5 Funzioni ...................................................................................................................... 152
Funzione Principale ...................................................................................................................................................... 152
La chiave ‘Text’ ......................................................................................................................................................... 153
Parametri .......................................................................................................................................................................... 153
La chiave ‘Separator’ .............................................................................................................................................. 153
La chiave ‘Text’ ......................................................................................................................................................... 154
Funzioni ............................................................................................................................................................................ 155
La chiave ‘Text’ ......................................................................................................................................................... 155
Intestazione di Funzione .............................................................................................................................................. 156
La chiave ‘Text’ ......................................................................................................................................................... 156
Intestazione di Variabile ............................................................................................................................................... 157
La sezione ‘Variable Header Name’ ..................................................................................................................... 157
La chiave ‘Separator’ ....................................................................................................................................... 157
La chiave ‘Text’ ................................................................................................................................................. 158
La sezione ‘Declare’ ................................................................................................................................................ 158
La chiave ‘Text’ ................................................................................................................................................. 158
La chiave ‘Name Mode’ ................................................................................................................................... 159
6 Istruzioni ..................................................................................................................... 159
Assegnazione ................................................................................................................................................................. 160
La chiave ‘Text’ ......................................................................................................................................................... 160
Chiamata .......................................................................................................................................................................... 160
La chiave ‘Text’ ......................................................................................................................................................... 161
Commento ....................................................................................................................................................................... 161
La chiave ‘Text’ ......................................................................................................................................................... 161
La chiave ‘Replace’ ................................................................................................................................................. 162
Dichiarazione .................................................................................................................................................................. 162
Sezione 'Declare Name' .......................................................................................................................................... 163
La chiave ‘Separator’ ....................................................................................................................................... 163
La chiave ‘Text’ ................................................................................................................................................. 163
Sezione 'Declare' ..................................................................................................................................................... 164
La chiave ‘Text’ ................................................................................................................................................. 164
La chiave ‘Name Mode’ ................................................................................................................................... 164
Struttura ‘Do’ ................................................................................................................................................................... 165
La chiave ‘Text’ ......................................................................................................................................................... 165
Struttura ‘For’ .................................................................................................................................................................. 166
La chiave ‘Text’ ......................................................................................................................................................... 166
Struttura ‘While’ .............................................................................................................................................................. 167
La chiave ‘Text’ ......................................................................................................................................................... 168
Struttura ‘If’ ...................................................................................................................................................................... 168
La chiave ‘Text’ ......................................................................................................................................................... 169
Input ................................................................................................................................................................................... 170
La chiave ‘Text’ ......................................................................................................................................................... 170
Output ............................................................................................................................................................................... 171
Output ........................................................................................................................................................................ 171
La chiave ‘Text’ ................................................................................................................................................. 171
Lista Output ............................................................................................................................................................... 172
Come funziona .................................................................................................................................................. 172
Chiave ‘Separator’ ............................................................................................................................................ 172
Chiave ‘Text’ ...................................................................................................................................................... 173
7 Esempi di Paradigma di Programmazione ................................................................... 173

© 2023 Roberto Atzori

 Contenuti 7

Linguaggio di programmazione Lua ........................................................................................................................ 173

Linguaggio di programmazione Java (semplificato) ............................................................................................ 179
Linguaggio di programmazione Pascal ................................................................................................................... 187
Linguaggio di programmazione Python .................................................................................................................. 194
Linguaggio di programmazione Visual Basic .NET .............................................................................................. 200

Capitolo XV Versioni precedenti 208

1 Versioni 32 bit ............................................................................................................. 209
2 Versioni 64 bit ............................................................................................................. 212

Capitolo XVI Altro 214

Capitolo XVII Esercizi 216

1 Esercizi - parte 1 ......................................................................................................... 217
2 Esercizi - parte 2 ......................................................................................................... 231

Indice 0

© 2023 Roberto Atzori

Capitolo I
 Introduzione 9

1 Introduzione

Sito Flowgorithm dell'autore Devin Cook

Sito Flowgorithm di Roberto Atzori

Flowgorithm su Facebook

Algoritmi e Flowchart (eBook non più aggiornato)

Esercizi (ITA- ENG) 217 con gli esempi dell'eBook (Esercizi - parte 1 217 ) e i nuovi
esempi (Esercizi - parte 2 231 ) in continuo aggiornamento

Altre risorse

© 2023 Roberto Atzori

10 Flowgorithm

Video lezioni (in inglese) su Youtube (Damian Burrin)

Flowgorithm su Reddit

Flowgorithm su Discord

Flowgorithm su Twitter

GitLab - Flowgorithm Extras (Petr Vanecek)

Strumenti utili

Editor Notepad++ (freeware and portable)

HxD - Freeware Hex Editor and Disk Editor

© 2023 Roberto Atzori

 Introduzione 11

1.1 Introduzione

Flowgorithm

Flowgorithm è un'applicazione gratuita che consente di creare programmi utilizzando

diagrammi di flusso.
In informatica il diagramma di flusso (in inglese detto anche flowchart) rappresenta un
linguaggio di modellazione grafico per rappresentare il flusso di controllo ed esecuzione di
algoritmi, procedure, istruzioni operative (in senso lato).
Esso consente di descrivere in modo schematico ovvero grafico:
•le operazioni da compiere, rappresentate mediante sagome convenzionali (rettangoli,
rombi, esagoni, parallelogrammi, rettangoli smussati...), ciascuna con un preciso significato
logico e all'interno delle quali un'indicazione testuale descrive tipicamente l'attività da
svolgere
•la sequenza nella quale devono essere compiute sono rappresentate con frecce di
collegamento.
Per questa loro connotazione topologica i diagrammi di flusso possono essere ricondotti alla
classe più ampia dei diagrammi a blocchi, che a loro volta rientrano nell'ancora più vasta
categoria delle mappe concettuali, utilizzate soprattutto per la descrizione e la
rappresentazione delle informazioni e della conoscenza.
In genere, i programmi sono scritti utilizzando un editor di testo. A seconda del linguaggio di
programmazione, questo può risultare facile o molto difficile per un programmatore alle prime
armi. Molti linguaggi richiedono la stesura di diverse righe di codice solo per arrivare alla
visualizzazione di una semplice frase come "Ciao, mondo!".
Tuttavia, utilizzando Flowgorithm, è possibile utilizzare dei simboli per rappresentare le diverse
azioni che si desidera che il programma esegua. Quindi, ci si può concentrare su un algoritmo
(Pensiero Computazionale) piuttosto che su tutte le sfumature e i dettagli propri di un tipico
linguaggio di programmazione (Coding).
È possibile eseguire i programmi direttamente in Flowgorithm. Ma, se si vuole imparare un
linguaggio di programmazione ad alto livello, Flowgorithm può convertire il diagramma di flusso
in molti linguaggi popolari. Questi includono: C#, C++, Delphi/Pascal, Java, JavaScript, Lua, Perl,

© 2023 Roberto Atzori

12 Flowgorithm

Python, QBasic, Ruby, Swift 2, Visual Basic .NET e Visual Basic for Applications (utilizzato in
Microsoft Office), TypeScript, Scala.

Una importante collezione di algoritmi di vario genere, famosi o meno, creati con il software
Flowgorithm, possono essere visionati e/o scaricati dal mio eBook presente nel mio sito
all’indirizzo [Link] oppure Esercizi - parte 1 217 .

© 2023 Roberto Atzori

Capitolo II
 14 Flowgorithm

2 Installazione
Come installare Flowgorithm in vari Sistemi Operativi

2.1 Sistema Operativo Windows

Nel Sistema Operativo Windows

2.1.1 Versione 64 bit

Quanto segue contiene il programma di installazione di Windows per Flowgorithm. Si consiglia
vivamente di selezionare questa opzione.

Download Flowgorithm (ultima versione)

Tuttavia, se si ha necessità solo dell'eseguibile, usa il link qui sotto. Nota: non verranno associati
i tipi di file.

Download Flowgorithm (Ultima versione SOLO eseguibile)

Comunque è possibile scaricare le seguenti vecchie versioni di Flowgorithm a 64 bit.

Metto a disposizione queste versioni anche per capire da dove si è partiti e dove si è arrivati
grazie all'immenso lavoro dell'autore Devin Cook.
Per vedere quali cambiamenti sono stati apportati nelle varie versioni, cliccare sul seguente link
Older Revisions

Scaricare le versioni precedenti 212

2.1.2 Versione 32 bit

La versione a 32 bit non viene più supportata.

Comunque è possibile scaricare le seguenti vecchie versioni di Flowgorithm a 32 bit.

Metto a disposizione queste versioni anche per capire da dove si è partiti e dove si è
arrivati grazie all'immenso lavoro dell'autore Devin Cook.
Per vedere quali cambiamenti sono stati apportati nelle varie versioni, cliccare sul
seguente link Older Revisions

Scaricare le versioni precedenti 209

2.2 Sistema Operativo iOS

Nel Sistema Operativo iOS

© 2023 Roberto Atzori

 Installazione 15

2.2.1 Emulatore Wine

Installazione di Flowgorithm su MacOS usando Wine

Ecco passo dopo passo l'installazione di Flowgorithm in MacOS.

1. Devi avere 'Homebrew', il gestore di pacchetti software di terze parti per MacOS. Se
non ne hai uno, puoi seguire il passaggio di installazione QUI.

2. Una volta installato 'Homebrew', puoi installare 'Wine' e le sue librerie.

Apri [Link] e digita questo comandi:

brew cask install xquartz

brew cask install wine-stable

Attendi il processo di installazione e inserisci la tua password quando viene richiesta.

Dopo aver terminato il processo di installazione, Wine dovrebbe essere installato nella cartella Applic

3. Dopo aver installato Wine è possibile scaricare il software Flowgorithm.

Non tutte le versioni di Flowgorithm sono supportate da Wine.

2.2.2 GitHub
Vedere il seguente sito:

Flowgorithm .app for Mac

© 2023 Roberto Atzori

 16 Flowgorithm

2.2.3 Video Youtube

Per installare Flowgorithm sul Mac, seguire il seguente filmato (in inglese)

Come installare Flowgorithm sul Sistema Operativo MacOS

2.3 Sistema Operativo Linux

Come installare Flowgorithm in Linux (tratto da
[Link]
[Link])

Flowgorithm è un programma sviluppato in ambiente Windows e non esiste un porting

per Linux o MacOS. Quello che però si può fare, almeno per Linux ma dovrebbe essere
possibile anche per MacOS, è di fare girare l'eseguibile Windows su uno strato di
emulazione implementato da Wine. Il seguente procedimento è stato inizialmente
proposto dallo studente Alfano Andrea (che ringrazio per il test iniziale e per aver provato
per primo, con successo, l'esecuzione su Windows) e poi testato da me, con qualche
modifica. Quella che segue qui è la versione da me provata su una macchina virtuale
Ubuntu 20.04.

Dopo aver aperto un terminale, eseguire il comando

wget -nc [Link]

e successivamente

sudo -H gpg -o /etc/apt/[Link].d/[Link] --dearmor [Link]

Dopo aver inserito la chiave del repository di Wine bisogna aggiungere il repository nella
lista di apt

sudo add-apt-repository 'deb [Link] focal main'

e aggiornare la lista dei pacchetti

sudo apt update

A questo punto si può procedere con l'installazione di Wine con l'istruzione

sudo apt install --install-recommends winehq-stable

e, volendo verificare che la versione di Wine sia maggiore o uguale alla 6, si può eseguire
il comando

© 2023 Roberto Atzori

 Installazione 17

wine --versione

Siccome Flowgorithm è stato sviluppato utilizzando il framework .Net, bisogna ancora

aggiungere il porting di .Net per Linux, Mono. Anche in questo caso si può utilizzare apt
per installare il pacchetto della propria distribuzione, con il comando

sudo apt install mono-complete

Dopo aver preparato l'ambiente di esecuzione, si può scaricare l'eseguibile di

Flowgorithm da qua e salvarlo in una qualsiasi posizione sulla propria macchina, in questo
esempio si è scelto il Desktop. Dopo averlo estratto dal pacchetto zip, sempre sul
Desktop, bisogna passarlo come argomento a Wine in questo modo

wine Desktop/[Link]

Nella mia esperienza alla prima esecuzione si accorge della mancanza del pacchetto
Gecko, che servirebbe per il rendering dell'HTML, siccome però non serve a Flowgorithm,
cliccare pure Cancel ogni volta che appare questa richiesta. Durante il lancio e anche
durante l'esecuzione, nel terminale appariranno diversi messaggi di errori, si possono
tranquillamente ignorare senza pregiudicare l'esecuzione del programma, come si può
vedere nell'immagine qua sotto.

© 2023 Roberto Atzori

Capitolo III
 Flowgorithm 19

3 Flowgorithm
Le caratteristiche di Flowgorithm

3.1 Caratteristiche e funzionalità

3.1.1 L’interfaccia
Flowgorithm si presenta con una interfaccia molto semplice ed intuitiva. La zona menù è
corredata di tutte le funzionalità fornite dal software. La zona pulsanti è munita delle
principali funzionalià per una facile implementazione dell’algoritmo, una facile
esecuzione e un facile controllo dello stesso.

3.1.2 Caratteristiche principali

[Link] Supporto Multilingua

Flowgorithm è tradotto in molti linguaggi:

· Cinese (Simplificato)
· Ceco
· Inglese - U.S. e British
· Francese
· Galiziano
· Tedesco
· Ungaro
· Italiano
· Giapponese
· Portoguese
· Spagnolo – Messicano e Castigliano
· ….

© 2023 Roberto Atzori

20 Flowgorithm

Per cambiare linguaggio (inizialmente)

possiamo cliccare la voce di menù Tools
à Change Language
Oppure fare doppio click col tasto
sinistro del mouse in basso a destra della
finestra in corrispondenza della figura

o nella icona nel menu

Verrà aperta la finestra di selezione nuovo linguaggio:

Selezionare la voce “Italiano” e l’intera interfaccia di Flowgorithm userà l’idioma

italiano.

e il simbolo cambierà in ad indicare la lingua correntemente in uso.

© 2023 Roberto Atzori

 Flowgorithm 21

[Link] Grafica Tartaruga

Dalla versione 3 di Flowgorithm è stata introdotta la Grafica Tartaruga . L'idea deriva dal
classico linguaggio di programmazione LOGO, sviluppato nel 1967. Permette di creare
immagini con le semplici azioni della "tartaruga" - un "pennello" grafico che può essere
ruotato e spostato per creare immagini. L'obiettivo è insegnare i concetti di
programmazione attraverso i passaggi sequenziali necessari per creare un'immagine.

· Ruota: cambia l'angolo ruotando la tartaruga a sinistra o a destra.

· Avanza: sposta la tartaruga della distanza specificata.

· Punto Iniziale - riporta la tartaruga alla posizione iniziale e imposta l'angolo a 90

gradi.
L'introduzione della Grafica Tartaruga darà ai docenti uno strumento aggiuntivo per
insegnare la programmazione. Ad esempio, si potrebbe chiedere allo studente di
disegnare un rettangolo, prima attraverso una sequenza di passaggi, poi, usando
l'iterazione.

Nella modalità Grafica Tartaruga di Flowgorithm, la figura apparirà al

centro di un'area grafica.

Concetti di base

A seconda della versione del LOGO, la figura può sembrare un animale reale

(appunto una tartaruga ) con una testa e quattro zampe o, come nel UCBLogo

di Berkeley , può essere rappresentata come un triangolo .

© 2023 Roberto Atzori

22 Flowgorithm

La tartaruga sarà rivolta verso la parte superiore dello schermo. Qualsiasi disegno
grafico precedente verrà cancellato dallo schermo e dalla memoria del computer.
La "tartaruga" sta puntando in una particolare direzione e può muoversi solo in
quella direzione. Può muoversi avanti o indietro, come un'auto con retromarcia,
ma non lateralmente. Per disegnare in qualsiasi altra direzione, la "tartaruga" deve
prima girare in modo che sia rivolta nella nuova direzione.
Per spostare la "tartaruga" si usa il comando Avanza, abbreviato fd o forward. Forward
richiede un input, che deve essere un numero. L'effetto dell'avanti è quello di muovere
la tartaruga nella direzione in cui è rivolta, attraverso una distanza specificata
dall'input. L'unità di distanza è il "passo della tartaruga", una piccola distanza che
dipende dalla risoluzione dello schermo del computer. Generalmente, un passo della
tartaruga è la linea più piccola che il tuo computer può disegnare.
Il comando LOGO
forward 80
se la "tartaruga" era rivolta verso la parte superiore dello schermo, aveva come
conseguenza lo spostamento dell'animale che lasciava dietro una traccia, una linea
che indicava il percorso seguito.
Le prime tartarughe erano veri e propri robot che si muovevano lungo il pavimento.
Hanno preso il nome di "tartaruga" a causa dei gusci duri che circondano le loro
delicate parti elettroniche. Una tartaruga robot aveva una penna nella pancia, che
poteva estrarre e spingerla fino al pavimento o riportare su dentro di sé, dentro la
pancia. Quando la penna era giù, la tartaruga disegnava una traccia del suo
movimento lungo il pavimento.

Quando si parla della "tartaruga" dello schermo, è consuetudine pensare allo

schermo come a una sorta di mappa, che rappresenta un pavimento orizzontale.
Pertanto, invece di riferirci alle direzioni dello schermo come "su", "giù", "sinistra" e
"destra", parliamo delle direzioni della bussola Nord, Sud, Ovest e Est.
La tua "tartaruga" è ora rivolta a Nord. Oltre ad adattarsi meglio alla metafora della
"tartaruga", questa terminologia evita una possibile confusione: la parola "sinistra"
potrebbe significare la sinistra della "tartaruga" o la sinistra dello schermo.
Inizialmente è nella stessa direzione e le due affermazioni coincidono ma non
saranno le stesse dopo aver girato (ruotato) la tartaruga. Per evitare questo
problema, si usa "Ovest" per il bordo sinistro dello schermo e riserviamo la parola
"sinistra" per la direzione a sinistra in qualsiasi modo la tartaruga sia rivolta.

Logo fornisce comandi primitivi per alzare e abbassare la penna della" tartaruga". Il
comando penup (abbreviato pu) non richiede input; il suo effetto è quello di alzare la

© 2023 Roberto Atzori

 Flowgorithm 23

penna. In altre parole, dopo aver usato questo comando, qualsiasi ulteriore movimento
della tartaruga non traccerà linee.

penup
forward 80

Il comando back (o bk) richiede un input, che deve essere un numero. L'effetto è
quello di spostare la tartaruga all'indietro della distanza utilizzata come input.

penup
back 80
Alla "tartaruga", vengono forniti altri due comandi: left (abbreviato lt) prende un
input, che deve essere un numero. Il suo effetto è quello di far girare la tartaruga
verso la sua sinistra. L'angolo attraverso il quale la tartaruga gira è l'input; gli
angoli sono misurati in gradi.

left 45

Il comando right (o rt) è proprio come left, tranne per il fatto che gira la tartaruga in
senso orario, verso la propria destra.

right 45

Il comando

repeat 4 [.......]

rappresenta un ciclo ripetitivo, solitamente un ciclo FOR (enumerativo) in Flowgorithm,

e il contenuto delle parentesi quadre rappresenta l'insieme (blocco) delle istruzioni da
ripetere.

© 2023 Roberto Atzori

24 Flowgorithm

Equivalenza tra LOGO (base) e Flowgorithm

Tabella di Equivalenza

Comando LOGO Flowgorithm

e poi, con doppio click del mouse sulla figura Forward

appena inserita nel diagramma di flusso

pendown
forward 80

e poi, con doppio click del mouse sulla figura Forward

appena inserita nel diagramma di flusso

penup
forward 80

In Flowgorithm, l'effetto del comando back, lo si ottiene inserendo un

numero negativo come parametro

penup
back 80

© 2023 Roberto Atzori

 Flowgorithm 25

e poi, con doppio click del mouse sulla figura Turn appena

inserita nel diagramma di flusso

left 45

e poi, con doppio click del mouse sulla figura Turn appena

inserita nel diagramma di flusso

right 45

© 2023 Roberto Atzori

 26 Flowgorithm

repeat 4
[.......]

[Link] Supporto base sui File

Dalla versione 3 è stato aggiunto il supporto per l'input/output di base per i file. Usando le
nuove quattro forme, Flowgorithm fornisce la possibilità di leggere o scrivere testo semplice su
un file. Gli studenti saranno in grado di generare file in output o aprire file in input e possono
eseguire calcoli su un insieme di dati di grandi dimensioni.

[Link] Interruzione con condizione

Dalla versione 3 è stato introdotto la interruzione con condizione. Nella versione precedente di
Flowgorithm, le interruzioni interrompevano (pausa) sempre l'esecuzione del programma.

Ora, l’interruzione può utilizzare il suo classico comportamento (impostazione predefinita) o

può utilizzare un'espressione condizionale (attiva per Vero) per effettuare una pausa in quel
punto del diagramma di flusso. Questo dovrebbe rendere l’azione dell’interruzione un po' più
utile, specialmente per le dimostrazioni in classe.

© 2023 Roberto Atzori

 Flowgorithm 27

[Link] Generazione interattiva del codice

Il visualizzatore del codice sorgente può convertire il diagramma di flusso in diversi principali
linguaggi di programmazione. Se si ha intenzione di imparare una lingua di alto livello, questa
funzione dovrebbe aiutare nell’intento.

Il codice viene evidenziato utilizzando lo stesso colore utilizzato dalle forme corrispondenti del
diagramma di flusso. Ciò consente di vedere visivamente la correlazione tra il codice e il
diagramma di flusso. Inoltre, se si evidenziano le forme nel diagramma di flusso o si esegue il
programma, il codice sorgente verrà evidenziato in modo corrispondente.

Sono supportati i seguenti linguaggi di programmazione:

· Ada 95 · MATLAB · Scala

· AppleScript · Nim · Smalltalk
· Bash · Pascal · Swift
· C# · Perl · Transact-SQL
· C++ · PHP · TypeScript
· Fortran 2003 · Powershell · VBA (Visual Basic for Applications)
· Java · Python · Visual Basic .NET
· JavaScript · QBasic · .....
· Lua · Ruby

Sono supportati anche i seguenti pseudocodici:

· Pseudocodice automatico - creato utilizzando la traduzione corrente in spagnolo, arabo,

coreano, italiano, ecc...

· Pseudocodice Gaddis - utilizzato nel libro "Programmazione Logica e Design" di Tony

Gaddis.

· Pseudocodice IBO

© 2023 Roberto Atzori

 28 Flowgorithm

Se il linguaggio di programmazione e/o pseudocodice non è elencato, Flowgorithm supporta

modelli di programma personalizzabili. Questi sono semplici file di testo che possono essere
scritti con qualsiasi editor di testo. Una volta caricato, il diagramma di flusso può essere
convertito automaticamente nella sintassi di destinazione. Si prega di controllare la
documentazione.

[Link] Temi

Dalla versione 3 l'utente può estendere i temi colore all'applicazione. La nuova finestra
"Schema colori" consentirà all'utente di scaricare temi colore, selezionare uno dei classici
schemi integrati e applicarli all'applicazione. La casella "Applica lo schema di colori a
Windows" è una casella di controllo, quindi l'utente può applicare lo schema solo al
diagramma di flusso.
In definitiva, ciò consentirà a Flowgorithm di avere un tema scuro, un tema chiaro o
qualsiasi colore, se è per questo. L'immagine sotto mostra il tema del colore Cyberspace
applicato a tutte le finestre.

[Link] Menù

Dalla versione 3, Flowgorithm conterrà altre 7 forme: 3 per i grafici delle tartarughe e le
altre 4 per i file. Questo potrebbe intimidire i nuovi studenti anche perché le nuove figure
potrebbero non essere utilizzate nei corsi di programmazione. Facendo clic sulla freccia in
basso verranno visualizzate le nuove forme. Il sistema ricorderà la selezione dell'utente.

© 2023 Roberto Atzori

 Flowgorithm 29

[Link] Finestre con aspetto automatico

Nella versione 3, le finestre devono essere impostate per l'aspetto automatico quando
vengono aperte o chiuse. Spesso è difficile per i docenti destreggiarsi tra le varie finestre
durante le dimostrazioni in classe. La nuova funzionalità, se selezionata, posizionerà e

ridimensionerà automaticamente le finestre.

[Link] Finestra "Visualizzazione Variabili"

Dalla versione 3 Flowgorithm sarà in grado di visualizzare lo stack di sistema. La parte

superiore dello stack (ovvero il programma principale) verrà elencata per prima. Questa
funzione può essere abilitata/disabilitata dalla barra degli strumenti. Le variabili e i
parametri possono essere raggruppati visivamente. Questa funzione può anche essere
abilitata/disabilitata dalla barra degli strumenti.

[Link] Specifiche
· Array mono dimensionali
· Cicli con controllo in testa e in coda
· Cicli enumerativi (FOR)
· Dichiarazione esplicita delle variabili. I diagrammi di flusso generalmente usano
dichiarazione implicita (essendo abbastanza minimalisti). Tuttavia, praticamente tutti i
linguaggi di programmazione utilizzano dichiarazioni esplicite. Quindi, è una buona idea
per gli studenti impararlo fin dall'inizio.
· Ricorsione controllata. Flowgorithm è fornito di uno stack interno (piuttosto che lo stack
del sistema). Se lo studente crea accidentalmente una chiamata ricorsiva infinita, il
programma non si bloccherà. Si riceverà, al contrario, un messaggio di errore.
· Supporta operatori sia della famiglia dei linguaggi di programmazione come C che della
famiglia del BASIC. Si possono utilizzare qualunque di questi operatori
indipendentemente dal linguaggio di programmazione che si vuole imparare.

© 2023 Roberto Atzori

 30 Flowgorithm

· Sono supportate funzioni e procedure create dall’utente che possono o meno restituire
un valore.
· Oltre 20 funzioni predefinite.

E ancora...
· Sono supportati diversi stili di rappresentazione come il tipo classico, IBM, SDL, e altri...
· I diagrammi di flusso possono essere stampati sia a colori che in bianco e nero.
· I diagrammi di flusso possono essere salvati in un file PNG sia a colori che in bianco e
nero.
· L’editor possiede una caratteristica chiamata "Layout Windows". È progettato per
aiutare a visualizzare il contenuto senza alcun intervento manuale sulla finestra.
· I programmi sono salvati in XML.

[Link] In aggiunta
• Sono supportati diversi stili di diagramma di flusso. Ciò include: classico, IBM, SDL e
altro...

• I diagrammi di flusso possono essere esportati sia in formato PNG (bitmap) che in
formato SVG (vettoriale) in qualsiasi schema di colori.

• L'editor ha una funzione chiamata "Finestre di Visualizzazione". È progettato per

aiutare i docenti a mostrare tutto il contenuto necessario sullo schermo senza dover
ridimensionare manualmente ciascuna finestra (azione che può risultare seccante).

• I programmi vengono salvati utilizzando XML.

© 2023 Roberto Atzori

Capitolo IV
 32 Flowgorithm

4 Flowgorithm nel dettaglio

4.1 Barra del menù

La barra dei menu presenta la maggior parte dei comandi disponibili nel programma, suddivisi
per menu (elenchi di scelte). Tramite tastiera è possibile consultare la barra dei menu
premendo il tasto Alt e spostandosi con la Freccia Destra o Sinistra per leggere le intestazioni di
ogni menu. Una volta individuato quello di interesse, è possibile leggere le voci contenute al suo
interno utilizzando i comandi Freccia Giù o Su. Per attivare una voce è sufficiente, dopo averla
individuata, premere il tasto Invio.

Per aprire ciascuno dei menu disponibili, si possono utilizzare anche le seguenti combinazioni di
tasti, dette anche tasti caldi (hot):

· Alt più F per il menu File;

· Alt più M per il menu Modifica;

· Alt più P per il menu Programma;

· Alt più S per il menu Strumenti;

· Alt più A per il menu Aspetto.

Per chiudere un menu è sufficiente selezionare un comando del menu, attivare un altro menu o
premere il tasto Alt.

4.1.1 Voce di menù “File”

Voce menù Descrizione

Nuovo Crea un nuovo flowchart

Apri Carica un flowchart precedentemente creato e salvato

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 33

Salva Salva il flowchart

Salva Salva il flowchart con la possibilità di cambiare nome allo stesso e cartella dove
come… salvarlo

Stampa Per stampare la zona correntemente visualizzata

Esci Uscire dal programma

[Link] Stampa
Selezionando la voce di menù “Stampa” si aprirà la seguente finestra:

attraverso la quale è possibile inserire delle impostazioni personalizzate per la stampa.

© 2023 Roberto Atzori

 34 Flowgorithm

4.1.2 Voce di menù “Modifica”

Voce menù Descrizione

Taglia Cancellate l’elemento selezionato copiandolo in memoria

Copia Copia in memoria l’elemento selezionato

Cancella Cancella l’elemnto selezionato

Annulla Azione Annulla operazione inserimento forme, digitazione, …

Ripristina Azione Ripristina operazione annullata

4.1.3 Voce di menù “Aspetto”

Voce menù Descrizione

Cambia Lingua Permette di cambiare l’idioma

Ripristina Azione Ripristina operazione annullata

Aumenta ingrandimento Ingrandisce la zona del flowchart

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 35

Diminuisci ingrandimento Rimpicciolisce la zona del flowchart

Dimensionamento Ridimensiona intera finestra Flowgorithm

Applica la combinazione di
colori a tutte le finestre
Scegli la combinazione di
colori Selezionare la combinazione di colori

Stile diagramma … Seleziona lo stile del diagramma

Modifica Schema Colori … Modifica colorazione temi

Modifica Stile diagramma … Modifica lo stile del diagramma

[Link] Lingua

[Link] Dimensionamento
L'applicazione ora è "DPI-aware". Ciò significa che la finestra si "ridimensionerà" su schermi più
grandi (con grande risoluzione) utilizzando un fattore di scala. Normalmente questo è
impostato al 125% o 150%. L'utente può anche modificare il fattore di scala corrente dal menu

© 2023 Roberto Atzori

 36 Flowgorithm

Strumenti à Dimensionamento. Prima di questo cambiamento, Windows avrebbe

semplicemente, su schermi più grandi come ad esempio un 4K, rimpicciolito tutta la grafica
rendendola poco leggibile.

Questa possibilità è utile ad esempio in ambito laboratoriale nel momento in cui si utilizza una
risoluzione molto dettagliata (ad esempio 4k) di difficile lettura agli ultimi posti nel laboratorio.

[Link] Selezione Combinazione di colori

[Link] Stile diagramma

Particolare importanza riveste la scelta della selezione “Stile del diagramma” che porta
all’apertura di una nuova finestra:

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 37

[Link] Modifica schema colori

Selezionando questa voce, è possibile modificare la grafica dei simboli predefiniti

Questo permetterà di creare/modificare qualsiasi stile del diagramma di flusso.

Cliccando su qualsiasi elemento della zona “Anteprima” (a sinistra), si avrà la possibilità (sulla
destra) di cambiare a proprio piacimento la combinazione di colori per l’elemento selezionato.

© 2023 Roberto Atzori

 38 Flowgorithm

o, addirittura, colore di un elemento grafico importandolo dal proprio PC.

[Link] Modifica Stile Diagramma

E’ possibile personalizzare ogni elemento selezionato nella zona “Anteprima” a sinistra,

assegnandoci una qualsiasi forma tra quelle presenti nella zona “Forme” a destra.

All’indirizzo Flowgorithm - Download Color Schemes si possono trovare gli schemi preinstallati
ed altri nuovi, la cui colorazione può essere modificata dall’utente.

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 39

© 2023 Roberto Atzori

 40 Flowgorithm

4.1.4 Voce di menù “Programma”

Voce menù Descrizione

Esegui Esegue il flowchart (interpretazione)

Passo successivo Esegue passo passo il flowchart

Pausa Pausa esecuzione

Ferma Interrompe l’esecuzione

Velocità di esecuzione Selezione della velocità di esecuzione in modalità automatica

Rimuovere i punti di
arresto Rimuove tutti i punti di interruzione inseriti

Nuova funzione Aggiunge una nuova funzione

Gestione funzioni utente
… Gestione delle funzioni
Informazioni programma
… Proprietà del programma

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 41

[Link] Velocità di esecuzione

Selezionando la voce di menù Velocità di esecuzione si aprirà un altro menù attraverso il quale
sarà possibile individuare la velocità di esecuzione in automatico delle istruzioni.

[Link] Rimuovere i punti di arresto

Questa voce permette di rimuovere tutti i punti di arresto nel flowchart

[Link] Nuova Funzione

Selezionando la voce di menù “Nuova funzione” si aprirà un’altra finestra tramite la quale sarà
possibile creare procedure e funzioni accessori e utili al funzionamento dell’algoritmo stesso.

© 2023 Roberto Atzori

 42 Flowgorithm

Ovviamente questa zona necessita di conoscenze di programmazione avanzata per poterla

sfruttare appieno.

I pulsanti freccia servono per modificare l’ordine dei parametri della funzione. Modificando
l’ordine dei parametri si deve prestare attenzione a quanto scritto nel flowchart come codice!!

[Link] Gestione funzioni utente

Selezionando la voce di menù Gestione funzioni utente si accede alla lista delle funzioni create
per l’algoritmo corrente e tramite la quale è possibile modificare le funzioni create, duplicarle
(copia e incolla) o cancellare quelle che non servono più.

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 43

[Link] Informazioni programma

Selezionando la voce di menù Informazioni programma (oppure cliccando sul tasto funzione
F4) viene attivata un’altra finestra che offre la possibilità di poter inserire ulteriori informazioni
sul flowchart.

Queste informazioni, comunque, non modificano il funzionamento del flowchart.

© 2023 Roberto Atzori

 44 Flowgorithm

4.1.5 Voce di menù “Strumenti”

Voce menù Descrizione

Disposizione automatica Disposizione automatica delle finestre di Flowgorithm

Disposizione finestre … Disposizione delle finestre nel desktop

Abilita la finestra per il controllo delle variabili utilizzate nel
Finestra ‘Variabili’ … programma
Abilita la finestra per monitorare l’esecuzione del programma
Finestra ‘Esecuzione’ … e per inserire i valori da tastiera

Finestra grafica Tartaruga Utilizzo della programmazione Tartaruga (stile LOGO)

Abilita la finestra per visualizzare la codifica automatica nei
Finestra ‘Codifica’ … linguaggi previsti da Flowgorithm

Copia immagine in memoria Copia l’immagine in memoria

Esporta immagine in un file … Esporta l’immagine area attiva in un file PNG

Esporta l’immagine area attiva in un file in formato vettoriale
.SVG (Scalable Vector Graphics ) o .EMF (Enhanced Metafile
Esporta immagine in formato Format)
vettoriale

[Link] Esporta immagine in un file

Selezionando la voce di menù Esporta immagine in un file viene aperta la seguente finestra. Se
lasciamo tutto così, come ci viene proposto, e clicchiamo sul pulsante Crea, ci verrà proposto di
dare un nome al file (con estensione PNG) e di selezionare in quale cartella salvarlo.

All’interno della finestra ci vengono proposte tre schede per la selezione di ulteriori
impostazioni prima della creazione.

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 45

La prima scheda Stile ci ricorda quella che viene attivata dalla sequenza del menù Modifica à
Scegli lo stile del diagramma vista precedentemente.

Il campo Dimensioni permette di impostare la grandezza del carattere. Un valore di 18 è

considerato un valore adatto nella maggior parte dei casi.

Il campo Margini consente di impostare lo spazio in pixels intorno all’immagine (padding). Per
Word è consigliato impostare tale spazio a 0.

[Link] Esporta immagine in formato vettoriale

Selezionando la voce di menù Esporta immagine in formato vettoriale viene aperta la seguente
finestra.

© 2023 Roberto Atzori

 46 Flowgorithm

È possibile salvare l’immagine della funzione scelta in un file in formato .SVG (Scalable Vector
Graphics) o in formato .EMF (Enhanced Meta File). Inoltre è possibile salvare le immagini anche
con sfondo trasparente.

4.1.6 Voce di menù “Aiuto”

Voce menù Descrizione

Apre la pagina online relativa alla documentazione

Documentazione [Link]
Apre la pagina iniziale online relativa al sito Flowgorithm
Flowgorithm – Sito Web [Link]
Apre un sottomenu di collegamenti all’Università di appartenenza
Collegamenti dell’autore di Flowgorithm
Apre finestra informazioni sul software, traduzioni e ringraziamenti a
Informazioni chi ha partecipato all’evoluzione di questo software

Verifica aggiornamenti Permette di controllare se esistono nuove versioni del software

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 47

© 2023 Roberto Atzori

 48 Flowgorithm

4.2 Barra dei pulsanti

sImmediatamente sotto la barra dei menu è presente la barra degli strumenti standard, che
contiene i pulsanti dei comandi utilizzati più di frequente (tasti di scelta rapida) per la gestione
dei file e per l'esecuzione delle operazioni più importanti.

Pulsante Descrizione

Carica un flowchart precedentemente creato e salvato

Salva il flowchart

Esegui interprete flowchart in automatico secondo la velocità impostata

Passo successivo modalità utente

Pausa nella modalità automatica

Interrompi interprete flowchart

© 2023 Roberto Atzori

 Flowgorithm nel dettaglio 49

Imposta velocità interprete in esecuzione automatica

Selettore programma principale / funzioni

Gestione funzioni utente

Aumenta ingrandimento

Diminuisci ingrandimento

Combinazioni colori

Auto Layout (la finestra verrà posizionata in primo piano)

Disposizione e selezione finestre

Finestra ‘Variabili’

Finestra ‘Esecuzione’

Finestra grafica Tartaruga

Finestra ‘Codifica’

Selezione lingua

Attenzione: i pulsanti della barra degli strumenti standard corrispondono alle voci più utilizzate
presenti nella barra dei menu; la barra degli strumenti standard, perciò, ha solo la funzione di
rendere tali voci più accessibili. Per esempio, se si vuole salvare il documento su cui si sta
scrivendo è sufficiente utilizzare l'apposito pulsante presente sulla barra degli strumenti senza
dover ogni volta aprire il menu File e selezionare la voce Salva.

Per selezionare i pulsanti della barra degli strumenti standard tramite tastiera è possibile:

· posizionarsi sulla barra dei menu tramite il tasto Alt;

· utilizzare la combinazione di tasti Control più Tab.

In questo modo viene selezionato il primo pulsante della barra; per spostarsi fra i pulsanti è
sufficiente utilizzare il tasto Tab per muoversi da sinistra verso destra e la combinazione di tasti
Shift più Tab per muoversi da destra verso sinistra. Una volta individuato il pulsante d’interesse
occorre premere il pulsante Invio per attivarlo.

© 2023 Roberto Atzori

Capitolo V
 Le finestre di Flowgorithm 51

5 Le finestre di Flowgorithm
5.1 Finestra “Esecuzione”

Selezionando la voce di menù Finestra “Esecuzione” viene attivata una finestra utilizzata
per monitorare l’esecuzione dell’algoritmo e per inserire da tastiera i valori necessari.

Il metodo classico per interagire con il computer è utilizzare la modalità "Console". Usando
questo approccio, il programma visualizza in uscita su uno schermo solo testo e l’utente
immette i dati utilizzando la tastiera. A volte la console permette al testo di cambiare i colori,
ma, per la maggior parte, è testo bianco su sfondo nero.

Mentre la Console funziona, la sua interfaccia semplice può rendere difficile distinguere l'input
dell'utente e l'output del programma. Così, invece di usare la schermata di solo testo,
Flowgorithm trasforma il tutto in una tipica finestra di messaggio. Dal punto di vista dei
programmatori, sono messaggi diretti e testuali.

I messaggi sono colorati in abbinamento alle forme di ingresso e di uscita utilizzati nel
diagramma di flusso. Nella schermata a destra, l'input dell'utente è visualizzato in blu, mentre
l'output del programma viene visualizzato in verde. Nella sua barra degli strumenti si possono
notare delle icone che non compaiono nella barra degli strumenti della finestra principale.

Pulsante Descrizione

Permette la visualizzazione dei valori sotto forma di riquadri di dialogo (visione

grafica)

Permette la visualizzazione delle interruzioni

Aumenta ingrandimento

Diminuisci ingrandimento

© 2023 Roberto Atzori

 52 Flowgorithm

Esegui interprete flowchart in automatico secondo la velocità impostata

Passo successivo modalità utente

Pausa nella modalità automatica

Interrompi interprete flowchart

Disposizione e selezione finestre

Finestra ‘Variabili’

Salva il flowchart

Copiare in memoria il contenuto della finestra

Cancellare il contenuto della finestra

5.2 Finestra “Codifica”

Selezionando la voce di menù Finestra “Codifica” si aprirà la finestra tramite la quale sarà
possibile vedere la trasformazione del flowchart creato, codificato in automatico in uno dei
tanti linguaggi di programmazione predisposti da Flowgorithm.

© 2023 Roberto Atzori

 Le finestre di Flowgorithm 53

Pulsante Descrizione

Permette la selezione della codifica in uno dei tanti linguaggi di

programmazione

Permette la visualizzazione dei numeri di linea

Permette la visualizzazione delle istruzioni con colori

Distanziamento linee del codice (interlinea)

Aumenta ingrandimento

Diminuisci ingrandimento

Esegui interprete flowchart in automatico secondo la velocità impostata

Passo successivo modalità utente

Pausa nella modalità automatica

Interrompi interprete flowchart

Salva il flowchart

Copiare in memoria il contenuto della finestra

Il flowchart può essere codificato nei seguenti linguaggi di programmazione:

© 2023 Roberto Atzori

54 Flowgorithm

Il pulsante permette di disabilitare o abilitare l’evidenziazione delle istruzioni

Da sottolineare il fatto che questa funzionalià permette di individuare in maniera interattiva

l’elemento del diagramma direttamente nella finestra codice. Infatti selezionando, ad esempio,
una struttura del diagramma di flusso, verrà evidenziata la stessa all’interno della finestra
codice di riferimento.

Il pulsante permette di rimuovere o aggiungere lo spazio tra le righe per una migliore
lettura

© 2023 Roberto Atzori

 Le finestre di Flowgorithm 55

Il pulsante permette di disabilitare o abilitare la numerazione delle righe

Se avete intenzione di imparare un nuovo linguaggio di alto livello, questa caratteristica è di

grande aiuto. Il codice viene evidenziato utilizzando lo stesso colore utilizzato per le forme
corrispondenti utilizzate nel diagramma di flusso. Questo permette, visivamente, di vedere la
correlazione tra il codice e il diagramma di flusso. Inoltre, se si evidenzia una forma nel
diagramma di flusso, o fate un passo con il vostro programma, il codice sorgente verrà
evidenziato nello stesso punto.

5.3 Finestra “Variabili”

Selezionando la voce di menù Finestra “Variabili” si aprirà la finestra relativa. La finestra

di controllo delle variabili viene utilizzata per tenere traccia di come le variabili cambiano man
mano che il programma viene eseguito. Quindi, se si è arrivati ad un punto del programma, la
finestra mostrerà ogni variabile e il suo valore corrente. Questo non è limitato solo a variabili
fondamentali. Anche gli array verranno visualizzati.

© 2023 Roberto Atzori

 56 Flowgorithm

Ogni variabile ha un colore codificato in base al suo tipo di dati. A prima vista, si può dire
esattamente che tipo di dati vengono memorizzati e focalizzarsi su un determinato tipo
di dato.

· Gli Interi sono visualizzati in blu.

· I numeri Reali sono visualizzati in viola.

· Le variabili di tipo Stringa sono vizualizzate in rosso.

· Le variabili Booleane sono visualizzate in verde scuro.

Pulsante Descrizione

Visualizzazione in colonne

Visualizzazione pila (programma principale + funzioni)

Visualizzazione etichette

Aumenta ingrandimento

Diminuisci ingrandimento

5.4 Finestra grafica “Tartaruga”

Selezionando la voce di menù Disposizione finestre si aprirà la finestra per dare la

possibilità dell’uso della grafica Tartaruga

© 2023 Roberto Atzori

 Le finestre di Flowgorithm 57

La versione 3 introduce la grafica della Tartaruga in Flowgorithm. L'idea deriva dal classico
linguaggio di programmazione LOGO, sviluppato nel 1967. Questà modalità permette di creare
immagini con le semplici azioni della "Tartaruga" - un "pennello" grafico che può essere ruotato
e spostato per creare immagini. L'obiettivo è insegnare i concetti di programmazione attraverso
i passaggi sequenziali necessari per creare un'immagine.

L'introduzione della grafica Tartaruga è uno strumento aggiuntivo per insegnare la

programmazione. Ad esempio, si potrebbe chiedere allo studente di disegnare un rettangolo,
prima attraverso una sequenza di passaggi, poi, usando l'iterazione.

In Flowgorithm sono state altre tre forme:

Cambia l'angolo ruotando la Tartaruga a sinistra o a destra di un numero

specificato di gradi. Questo ricorda i comandi Logo LT (svolta a sinistra) e RT (svolta
a destra).

Sposta la tartaruga della distanza specificata.

Questo ricorda i comandi Logo PU (penna su), PD (penna giù), FD (avanti) e BK

(indietro).

Piporta la tartaruga alla posizione iniziale e imposta l'angolo a 90 gradi.

Questo è lo stesso del comando Logo HOME

Alcune note sulla finestra grafica della tartaruga:

· I comandi grafici vengono memorizzati, quindi l'immagine può essere ridimensionata

e vettoriale se la finestra viene ridimensionata. Ciò significa anche che il disegno può
essere esportato in SVG o in un programma Logo.

· Il buffer, utilizzato per memorizzare l'immagine, è limitato e cancellerà gli elementi se

diventa eccessivamente grande (cosa che potrebbe fare uno studente). In realtà, gli
studenti non dovrebbero raggiungere questo limite.

© 2023 Roberto Atzori

 58 Flowgorithm

· Il campo di disegno ha una "estensione" (da -1.000.000 e 1.000.000) sia per l'asse x
che per y.

5.5 Disposizione finestre

Selezionando la voce di menù Disposizione finestre si aprirà la finestra per dare la

possibilità di una impostazione delle finestre definita dall’utente secondo le proprie necessità.

© 2023 Roberto Atzori

Capitolo VI
 60 Flowgorithm

6 Menù contestuale
Il menù contestuale può essere attivato utilizzando il tasto destro del mouse su specifiche
posizioni.

· Se si clicca, col tasto destro del mouse, sulla freccia di flusso apparirà un menu pop-up
mostrando tutte le figure che possono essere inserite

· Se si clicca, col tasto destro del mouse, sulla parte vuota della finestra di editazione

si attiverà il menù pop-up a destra attraverso il quale è possibile passare a menù già
trattati precedentemente.

© 2023 Roberto Atzori

Capitolo VII
 62 Flowgorithm

7 Funzioni predefinite
7.1 Matematiche
Dalla
Funzione Descrizione version
e..

Abs(n) Valore assoluto

Arcsin(n) Arcoseno di n (radianti) 1.7

Arccos(n) Arcocoseno di n (radianti) 1.7

Arctan(n) Arcotangente di n (radianti)

Cos(n) Coseno di n (radianti)

Sin(n) Seno di n (radianti)

Tan(n) Tangente di n (radianti)

Int(n) Parte intera di un numero reale

Ln(n) Logaritmo naturale

Log(n) Logaritmo naturale, come Ln(n)

Log10(n) Logaritmo in base 10

Sgn(n) Segno matematico (-1 se n è negativo, 0 se zero, 1 se positivo)

Sqrt(n) Radice quadrata di n

7.2 Stringa

Funzione Descrizione

Restituisce la lunghezza (intero) di una stringa

Len(s)
à
es: Len(“casa”) 4
Restituisce il carattere alla posizione i della stringa s. La posizione parte da 0.
Char(s, i)
à
es: Char(“casa”, 1) “a”

© 2023 Roberto Atzori

 Funzioni predefinite 63

7.3 Conversione tipo di dati

Dalla
Funzione Descrizione versio
ne..
Converte un codice carattere n in un carattere
ToChar(n)
à
es: ToChar(65) “A”
1.5

Converte un carattere c in un codice carattere (intero)

es: ToCode(“A”) à 65
ToCode(c) 1.8

ToFixed(r, Converte un numero reale r in una stringa con i cifre decimali

es: ToFixed(123.456, 1) à “123.4”
1.8
i)
ToInteger( Converte una stringa con caratteri numerici in un intero
s) es: ToInteger(“123”) à 123
Converte una stringa con caratteri numerici in un reale
es: ToReal(“123.5”) à 123.5
ToReal(s)

ToString(n Converte un numero in stringa es:

) ToString(123.5) à “123.5”

7.4 Altre
Dalla
Funzione Descrizione version
e..
Restituisce TRUE se si raggiunge la fine del file. Questa funzione è usata
EOF() per la lettura di un file aperto
Random(n
) Restituisce un numero intero tra 0 e n - 1

Size(a) Restituisce la grandezza (numero degli elementi) di un vettore (array) 1.7

© 2023 Roberto Atzori

Capitolo VIII
 Costanti predefinite 65

8 Costanti predefinite
La semantica di Flowgorithm prevede tre costanti predefinite. “True” e “False” spesso
utilizzate per inizializzare le variabili booleane e “Pi”, costante normalmente utilizzata in
matematica.
Tabella Operatori

Costanti Note

True Valore booleano (logico) per Vero

False Valore booleano (logico) per Falso

Pi Costante matematica (P greco π = 3.1415)

Costante matematica (P greco π = 3.1415) come
π sopra

© 2023 Roberto Atzori

Capitolo IX
 Istruzioni 67

9 Istruzioni
9.1 Output
Figura associata

Cosa fa

Un comando di Output valuta un’espressione e poi visualizza il risultato

sullo schermo.
Esempio

Il seguente esempio crea due variabili: 'area' e 'radius'. Utilizza poi un

Input per leggere il raggio da tastiera e assegnarlo alla variabile ‘radius’.
Alla fine verrà visualizzato un Output del risultato del calcolo dell’area.

Dalla versione 2.9 è stata inserita, per l’output, la possibilità di utilizzare la

funzione “Ritorno a capo” (in inglese: “New Line”)

© 2023 Roberto Atzori

68 Flowgorithm

Questa opzione influisce sulla visualizzazione dei messaggi con o senza il

ritorno a capo. Se utilizzata Flowgorithm creerà un messaggio diverso
per ogni istruzione di Output utilizzata.

Se invece non si imposta questa opzione, cioè si toglie la spunta

all’opzione, cliccando col mouse come da figura

si otterrà un unico messaggio con ritorno a capo nell’ultima parte del

messaggio:

© 2023 Roberto Atzori

 Istruzioni 69

9.2 Input
Figura associata

Cosa fa

Un Input legge un valore da tastiera e immagazzina tale valore in una

variabile.
Esempio

Il seguente esempio crea due variabili: 'area' e 'radius'. Utilizza poi un

Input per leggere il raggio da tastiera e assegnarlo alla variabile ‘radius’.
Alla fine verrà visualizzato un Output sullo schermo del risultato del
calcolo dell’area.

9.3 Assegnazione
Figura associata

Cosa fa

Un comando di assegnazione, calcola una espressione e registra il risultato

in una variabile.
Esempio

© 2023 Roberto Atzori

 70 Flowgorithm

Nel seguente esempio vengono dichiarate due variabili: “area” (che

conterrà numeri reali) e “radius” (che conterrà numeri interi). Viene poi
utilizzato il comando di assegnazione per impostare a 7 la variabile
'radius'. Per finire, nella variabile “area” verrà assegnato il calcolo
dell’area di un cerchio.

9.4 Commento
Figura associata

Cosa fa

I commenti non interferiscono con l’esecuzione del programma. Sono

utilizzati per documentare meglio le azioni intraprese e/o gli intendimenti
dell’autore. Questi possono includere: la logica di un ciclo, regole,
cambiamenti, ecc…
Esempio

© 2023 Roberto Atzori

 Istruzioni 71

9.5 Dichiarazione
Figura associata

Cosa fa

Il comando di dichiarazione viene usato per creare variabili e vettori

(arrays). Sono utilizzati per conservare i dati nel frattempo che il
programma è in esecuzione.
Esempio

Nel seguente esempio vengono dichiarate due variabili: “area” (che

conterrà numeri reali) e “radius” (che conterrà numeri interi). Viene poi
utilizzato il comando di assegnazione per impostare a 7 la variabile
'radius'. Per finire, nella variabile “area” verrà assegnato il calcolo
dell’area di un cerchio

© 2023 Roberto Atzori

 72 Flowgorithm

9.6 If
Figura associata

Cosa fa

Il comando If controlla una espressione booleana e passa al ramo del Vero

o del Falso a seconda se è verificata o meno la condizione.
Esempio

Il seguente esempio dichiara una variabile di tipo intero chiamata 'age'.

Viene inserita, quindi, l’età da tastiera per controllare se l’utente può
andare a votare o meno.

Alla fine, una struttura If controlla Ise l’età inserita da tastiera e assegnata
alla varibile “age” è maggiore o uguale a 18. Se si è maggiorenni. Il
programma visualizzerà la frase "Go vote!" altrimenti visualizzera la frase
"Sorry, not yet".

© 2023 Roberto Atzori

 Istruzioni 73

9.7 Cicli di ripetizione

9.7.1 For
Figura associata

Cosa fa

Il ciclo enumerativo For incrementa una variabile all’interno di un

intervallo di valori assegnati. Questa struttura, di solito, rimpiazza la
struttura While.
Esempio

Il seguente esempio visualizza a monitor i numeri da 1 a 100.

9.7.2 Do
Figura associata

Cosa fa

Un ciclo Do è simile al ciclo While tranne per il fatto che le istruzioni al suo
interno vengono eseguite almeno una volta prima di poterne verificare la
condizione di ciclo.
Esempio

© 2023 Roberto Atzori

 74 Flowgorithm

Il seguente esempio mostra il ciclo DO che accetta solo un input valido,

una età compresa tra 1 e 100. Se age < 1 o age > 100 ripete il ciclo.

9.7.3 While
Figura associata

Cosa fa

Il ciclo While valuta una espressione booleana e, se vera, esegue le

istruzioni contenute al suo interno. Cicla fino a quando la condizione
diventa falsa.
Esempio

Il seguente esempio visualizza i numeri da 1 a 100. Il comando di

assegnazione "n = n + 1" incrementa la variabile 'n' ogni iterazione del
ciclo.

© 2023 Roberto Atzori

 Istruzioni 75

9.8 Chiamata di Funzione o Procedura

Figura associata

Cosa fa

Un comando di chiamata trasferisce il controllo ad una funzione o ad una

procedura. Per veicolare le informazioni in una funzione o in una
procedura, si usano i parametri associati alla funzione o alla procedura e
ciò può essere portato a termine utilizzando o la modalità del passaggio
per valore o la modalità del passaggio per riferimento.

9.9 Grafica Tartaruga

9.9.1 Ruotare
Figura associata

Cosa fa

Cambia l'angolo ruotando la Tartaruga a sinistra o a destra di un numero

specificato di gradi.

9.9.2 Avanzare
Figura associata

Cosa fa

Sposta la tartaruga della distanza specificata, con pennino giù o pennino

sù

© 2023 Roberto Atzori

 76 Flowgorithm

9.9.3 Punto iniziale

Figura associata

Cosa fa

Riporta la tartaruga alla posizione iniziale e imposta l'angolo a 90 gradi.

9.9.4 Esempi
[Link] Disegno di un fiore
Con un input di 5 avremo …..

© 2023 Roberto Atzori

 Istruzioni 77

[Link] Scalinate
Con un input di 10 avremo…

© 2023 Roberto Atzori

 78 Flowgorithm

9.10 Gestione File

La versione 3 supporta la lettura e la scrittura di file di testo. Per supportare questa funzione,
vengono introdotte quattro nuove figure.

9.10.1 Lettura
Figura associata

Cosa fa

Un'istruzione di Lettura legge un valore dal file aperto e lo memorizza in

una variabile.

9.10.2 Scrittura
Figura associata

Cosa fa

Un'istruzione di Scrittura valuta un'espressione e scrive il risultato nel file aperto.

9.10.3 Chiusura
Figura associata

Cosa fa

Un'istruzione di Chiusura chiude un file aperto

9.10.4 Apertura
Figura associata

© 2023 Roberto Atzori

 Istruzioni 79

Cosa fa

Un'istruzione di Apertura consente le operazioni di lettura o scrittura su

un file.

Esempio

© 2023 Roberto Atzori

 80 Flowgorithm

9.10.5 Esempi
[Link] Fibonacci con utilizzo di file

© 2023 Roberto Atzori

 Istruzioni 81

[Link] Calcolo dei quadrati

9.11 Interruzioni con condizione

La versione 3 consentirà agli studenti di creare "Interruzioni condizionali".

Attualmente, la figura del punto di interruzione metterà sempre in pausa il

programma. La nuova versione può utilizzare questo comportamento (l'impostazione
predefinita) o interrompere solo se un'espressione condizionale è vera. Questo dovrebbe
essere un po' più utile, specialmente per le dimostrazioni in classe.

© 2023 Roberto Atzori

Capitolo X
 Per gli Amministratori di Sistema 83

10 Per gli Amministratori di Sistema

10.1 Installazione silente
10.1.1 Versione 2.15 e precedenti
Flowgorithm usa InstallShield. Se si desidera utilizzare un'installazione invisibile all'utente
(ad es. computer di laboratorio), utilizzare i seguenti parametri. NOTA: la spaziatura è
significativa per l'opzione /v.

10.1.2 Versione 2.16 e successive

La versione corrente di Flowgorithm utilizza Microsoft Installer Se si desidera utilizzare
un'installazione invisibile all'utente (ad es. computer di laboratorio), utilizzare i seguenti
parametri.

10.2 Impostazioni nel file registro di Windows

Flowgorithm usa il file registro di Windows per conservare le impostazioni utente. Sono
conservate solo poche impostazioni. Queste includono linguaggio, colori, modello di
diagramma e massima grandezza dello stack interno di Flowgorithm.

Quando si esegue Flowgorithm, verrà controllata prima la chiave CURRENT_USER per

caricare i valori in essa contenuti. Se non la trova, verrà controllata la chiave
LOCAL_MACHINE.

Se l’applicazione viene eseguita in modalità Amministratore, Flowgorithm salverà le sue

impostazioni nella chiave di registro LOCAL_MACHINE. Altrimenti la salverà in
CURRENT_USER. Se si vuole impostare i settaggi di default per tutti gli utenti del
laboratorio, apri l’applicazione in modalità Amministratore e imposta linguaggio, colore,
ecc… Ogni nuovo utente (che non possiede impostazioni utente), userà queste.

© 2023 Roberto Atzori

 84 Flowgorithm

10.2.1 Chiavi Registro

[Link] Cartella Radice

\HKEY_CURRENT_USER\Software\Flowgorithm

© 2023 Roberto Atzori

 Per gli Amministratori di Sistema 85

Valore Modificato
Chiave predefinit dal Descrizione
o software
Contiene il nome del modello ("Default",
"Classic", ecc... ) Se non viene riconosciuto il
Chart Style Default Si
valore della chiave, l’applicazione utilizzerà il
modello "Default".
Contiene il nome dello schema colori
corrente ("Pastel", "Cyberspace", ecc...) Se
Color Scheme Pastel Si non viene riconosciuto il valore della chiave,
l’applicazione utilizzerà il schema colori
"Pastel".
Contiene il codice ISO del linguaggio
visualizzato. Se non viene riconosciuto il
Language en Si
valore della chiave, l’applicazione utilizzerà il
codice lingua "en" (English).

Chiavi per l’utente

Le seguenti chiavi verranno applicate solo a CURRENT_USER. Anche se l'applicazione è aperta in
modalità amministratore, queste verranno salvate qui.

\HKEY_CURRENT_USER\Software\Flowgorithm
Valore Modificato
Chiave predefinit dal Descrizione
o software
MRU 0 Null string Si Elenco dei file utilizzati più di recente.

MRU 1 Null string Si Elenco dei file utilizzati più di recente.

MRU 2 Null string Si Elenco dei file utilizzati più di recente.

MRU 3 Null string Si Elenco dei file utilizzati più di recente.

MRU 4 Null string Si Elenco dei file utilizzati più di recente.

[Link] Cartella ‘Printer’

Nella versione 2.6.0 e successive, Flowgorithm salva le informazioni della stampa nel registro.

© 2023 Roberto Atzori

 86 Flowgorithm

\HKEY_CURRENT_USER\Software\Flowgorithm\Printer
Valore Modificato
Chiave predefinit dal Descrizione
o software
Valore booleano che specifica se per
Landscape False Si impostazione predefinita la stampante sarà
orizzontale (True) o verticale (False).
Margin Bottom 0.75 Si Margine in pollici.

Margin Left 0.75 Si Margine in pollici.

Margin Right 0.75 Si Margine in pollici.

Margin Top 0.75 Si Margine in pollici.

Name Si Nome dell'ultima stampante utilizzata.

[Link] Cartella ‘Shapes’

Nella versione 2.18 sono state aggiunte combinazioni di colori personalizzabili.
Se l'utente carica un file di stile grafico (o modifica quello corrente utilizzando l'applicazione), la
chiave "Stile grafico" viene impostata su "Personalizzata" e le informazioni sulla forma vengono
memorizzate nella sottocartella "Forme" di Flowgorithm. Se lo "Stile grafico" principale è
impostato su qualcos'altro, questi tasti vengono ignorati.

© 2023 Roberto Atzori

 Per gli Amministratori di Sistema 87

\HKEY_CURRENT_USER\Software\Flowgorithm\Shapes
Valore Modificato
Chiave predefinit dal Descrizione
o software
Nome dello stile grafico corrente. Questo
Name n/a Si
viene visualizzato sui controlli a discesa
Breve descrizione della combinazione di
About n/a Si
colori.
Author n/a Si L'autore dello stile grafico.

Assign n/a Si La figura utilizzata per ‘Assegnazione’.

Call n/a Si La figura utilizzata per ‘Chiamata’.

Declare n/a Si La figura utilizzata per ‘Dichiarazione’.

Do n/a Si La figura utilizzata per ‘Fai’.

End n/a Si La figura utilizzata per ‘Fine’.

For n/a Si La figura utilizzata per ‘Per’.

If n/a Si La figura utilizzata per ‘Se’.

Input n/a Si La figura utilizzata per ‘Lettura’.

Start n/a Si La figura utilizzata per ‘Inizio’.

© 2023 Roberto Atzori

 88 Flowgorithm

Output n/a Si La figura utilizzata per ‘Scrittura’.

While n/a Si La figura utilizzata per ‘Mentre’.

[Link] Cartella ‘Source Code Viewer’

Nella versione 2.12.0 e successive, Flowgorithm salva le chiavi relative alla lingua e ai numeri di
riga correnti

\HKEY_CURRENT_USER\Software\Flowgorithm\Source Code Viewer

Valore Modificato
Chiave predefinit dal Descrizione
o software
Il nome del linguaggio di programmazione
Language Auto Si corrente che il Visualizzatore codice sorgente
utilizzerà per generare il codice.
Line Numbers False Si Se la finestra visualizza i numeri di riga

[Link] Cartella ‘Colors’

Schemi di colori personalizzabili sono stati aggiunti nella versione 2.5. Se l'utente carica un file
di combinazioni di colori, il tasto "Schema colori" è impostato su "Personalizzato" e i colori
vengono memorizzati nella sottocartella "Colori" di Flowgorithm. Se il "Combinazione colori"
principale è impostato su qualcos'altro, questi tasti vengono ignorati.

N.B. La cartella comparirà nel file registro di Windows SOLO se viene utilizzato uno schema di
colori diverso da quello predefinito.

© 2023 Roberto Atzori

 Per gli Amministratori di Sistema 89

\HKEY_CURRENT_USER\Software\Flowgorithm\Colors
Valore Modificato
Chiave predefinit dal Descrizione
o software
Nome della combinazione di colori
Name n/a Si personalizzata corrente. Questo viene
visualizzato sui controlli a discesa
Breve descrizione della combinazione di
About n/a Si
colori.
Author n/a Si L'autore dello stile grafico.

Assign n/a Si Colori della figura ‘Assegnazione’

Breakpoint n/a Si Colori della figura ‘Interruzione’

Call n/a Si Colori della figura ‘Chiamata’

Comment n/a Si Colori della figura ‘Commento’

Declare n/a Si Colori della figura ‘Dichiarazione’

Error n/a Si Colori della figura ‘Errore’

© 2023 Roberto Atzori

 90 Flowgorithm

Executing n/a Si Colori della figura ‘Esecuzione’

Colori menu e numeri di riga (visualizzatore
Header n/a Si
di codice sorgente)
Effetto passaggio del mouse nel menu
Hover n/a Si
Aggiungi Figura
If n/a Si Colori della figura ‘Se’

Incomplete n/a Si Colori figura dati incompleti

Input n/a Si Colori della figura ‘Lettura’

Line n/a Si Colori della Linea

Loop n/a Si Colori della figura del ciclo (Per, Mentre, Fai).

Output n/a Si Colori della figura ‘Scrittura’

Page n/a Si I colori di sfondo

Selected n/a Si Colori degli elementi selezionati

Terminator n/a Si Colori della figura ‘Terminatore’

Window n/a Si Modifica i colori di sfondo della finestra

10.2.2 Chiavi per l’Amministratore

Le tre impostazioni seguenti non possono essere modificate (o visualizzate) dall'utente.
Saranno accessibili solo in LOCAL_MACHINE.

\HKEY_CURRENT_USER\Software\Flowgorithm
Valore Modificato
Chiave predefinit dal Descrizione
o software
Contiene la dimensione massima della pila.
Se l'applicazione supera questa dimensione,
visualizzerà un errore di overflow dello
stack. Questa impostazione non può essere
Max Stack Size 5000 No modificata dall'interno dell'applicazione. In
pratica, questo valore non dovrebbe mai
essere raggiunto a meno che il
programmatore non crei una chiamata
ricorsiva infinita.

© 2023 Roberto Atzori

 Per gli Amministratori di Sistema 91

Se impostato su False, il visualizzatore del

codice sorgente sarà nascosto. Non apparirà
Allow Source Code
True No sulla barra degli strumenti, nel menu
Viewer
principale o nello strumento Finestre di
Visualizzazione.
Se impostato su True (impostazione
predefinita), il sistema andrà in pausa se lo
stesso errore esatto si verifica due volte di
seguito. Il pulsante "Ok" nella finestra di
Error Auto Wait True No
errore impiegherà 5 secondi prima che
possa essere cliccato.
Questo impedisce allo studente di chiudere
la finestra senza preoccuparsi di leggerla.

I valori vengono letti, ma mai impostati (né aggiunti). Puoi aggiungere manualmente la chiave
nel registro e assegnarle il valore di stringa "false".

© 2023 Roberto Atzori

Capitolo XI
 Creare una Traduzione 93

11 Creare una Traduzione

In genere, i menu, i messaggi di errore, le finestre di dialogo e così via di un'applicazione sono
preimpostati su elementi fissi testuali. Se un programmatore desidera visualizzare "OK" su un
pulsante, imposta semplicemente la proprietà appropriata e non se ne deve preoccupare mai
più.

Nella versione 1.8, tutto il testo, normalmente visualizzato nell'applicazione, veniva spostato in
una tabella di ricerca. Ogni volta che viene caricata una finestra, il testo viene letto dalla tabella
di ricerca e utilizzato sullo schermo.

La tabella di ricerca è memorizzata in un semplice documento di testo. Quando Flowgorithm

viene caricato, legge questo documento e memorizza internamente tutti i dati di ricerca. Se il
file di testo viene modificato, il testo visualizzato sullo schermo ne risentirà.

Ecco come Flowgorithm supporta più lingue. Può esserci un file di "traduzione" per ogni lingua
supportata. Flowgorithm caricherà quello corrente e questo, a sua volta, cambierà tutto il testo
dell'applicazione.

Quindi, per creare una nuova traduzione, non si richiede alcuna programmazione o strumento.
È necessario creare solo una nuova versione del file di testo.

11.1 Formato Base del File

I modelli di programma vengono salvati in un semplice file di testo utilizzando il formato INI.
L'obiettivo era renderli facili da leggere e da scrivere utilizzando solo un semplice editor di
testo.

I modelli di programma Flowgorithm supportano Unicode, quindi sentiti libero di usare

qualsiasi carattere speciale (non solo ASCII).

I file INI riconoscono tre elementi sintattici di base: commenti, intestazioni di sezione e
dichiarazioni chiave/valore. Da questi è in grado di rappresentare tabelle non gerarchiche. Gli
elementi sono i seguenti:

Elemento Cosa fa Esempio

I commenti non influiscono sul file, ma sono utili per

Comment ; Comment
prendere appunti per chi legge il file.
Section Le sezioni individuano logicamente le diverse parti del file. [Section Name]
Il file contiene una serie di chiavi (come variabili) e i loro
Key/Value Key = Value
valori.

Il nome e la chiave della sezione vengono utilizzati per identificare un valore in modo univoco.

Questo è più o meno equivalente alle tabelle e alle righe trovate nei database.

© 2023 Roberto Atzori

 94 Flowgorithm

Durante la traduzione, i nomi delle sezioni ei nomi delle chiavi non devono essere modificati.

Il "Valore" contiene il testo che verrà visualizzato sullo schermo.

Molti dei valori contengono campi speciali indicati da parentesi graffe (parentesi). Quando il
valore viene letto, i dati verranno inseriti in questi campi. Anche questi nomi di campo non
devono essere modificati. In caso contrario, non verrà inserito nulla.

Quello che segue è un esempio dal file inglese. Questa sezione determina il testo visualizzato
sulle forme se viene utilizzata la didascalia "Shape Verbose".

Esempio

[Shape Verbose]
Assign = Assign {Variable} = {Expression}
Call = Call {Call}
Declare = Declare {Type} {Variable}
Declare Array = Declare {Type} Array {Variable}
Do = Do {Expression}
For Inc = For {variable} = {Start} to {End}
For Inc Step = For {Variable} = {Start} to {End} step {Step}
For Dec = For {Variable} = {Start} to {End} decreasing
For Dec Step = For {Variable} = {Start} to {End} decreasing step {Step}

11.2 Provare la Traduzione

La finestra ‘Cambia Lingua’ può essere utilizzata per passare a una delle traduzioni integrate o
per importare il file che stai creando. Per impostazione predefinita, il pulsante "Apri" è
nascosto.

Per visualizzarlo, premi contemporaneamente i seguenti tre tasti: CTRL+ALT+F1 oppure

CTRL+ALT+B. È possibile utilizzare il pulsante ‘Apri’ per caricare il file. La traduzione verrà
applicata immediatamente

© 2023 Roberto Atzori

 Creare una Traduzione 95

11.3 Durante la Traduzione

· Non modificare il testo tra parentesi graffe {...}. Questi sono usati per inserire dati nel
testo.

· Per favore, traduci tutto.

Flowgorithm è progettato per i principianti, quindi è meglio usare termini alla loro
portata. Ad esempio (in spagnolo), è meglio tradurre "Integer" in "Entero" piuttosto che
tenerlo "Integer". Ovviamente, usa quello che ritieni possa essere più vantaggioso.

11.4 Altro
Per modificare il file INI, utilizzare qualsiasi editor di testo come, ad esempio, Notepad++
([Link]).

Da scaricare:

· INI file in lingua inglese

Puoi cambiare questo file in un'altra lingua

· Programmi di prova

Progettati per causare tutti i diversi messaggi di errore

© 2023 Roberto Atzori

Capitolo XII
 Formato File Sorgente 97

12 Formato File Sorgente

Molte applicazioni salvano i dati in un file binario (di difficile lettura). Ciò ha senso se i
dati sono molto complessi e se si vuole minimizzare la grandezzo del file attraverso l’uso
della compressione.

I programmi scritti con Flowgorithm sono molto semplici. Non esistono dati di grande
complessità da dover essere compressi. I dati vengono salvati in un file di testo proprio
come se fossero scritti in Java, C#, ecc... In questo modo, piuttosto che avere file binari
complessi, questi ultimi sono di facile lettura e portabili verso altri sistemi. L’idea è che
usando questa applicazione questi file possano essere letti da altri strumenti (tipo
editor). Perciò i files vengono salvati in formato XML (Extended Markup Language).

Esempio
Prendiamo come esempio il seguente flowchart corrispondente all’esercizio “Somma tra due
numeri”:

Quando l’utente salva il suo esercizio con un determinato nome, Flowgorithm genera un file. Il
file generato da Flowgorithm (file sorgente) ha estensione .FPRG, ma non è un file proprietario
cioè non è un file che può essere letto solo dal software di appartenenza.

Proviamo ad aprire il file .FPRG corrispondente all’esercizio di cui sopra utilizzando non
Flowgorithm ma un editor di testo come ad esempio WordPad. Ecco cosa potremo vedere.

© 2023 Roberto Atzori

98 Flowgorithm

Forse a molti questo codice risulterà incomprensibile ma, anche per costoro, potrebbe essere
utile sapere alcune informazioni.

Per prima cosa si nota che l’autore, D. Cook, ha utilizzato il linguaggio XML (eXtended Markup
Language) che è una estensione del linguaggio HTML (Hyper Text Markup Language), il
linguaggio base che viene utilizzato per la generazione delle pagine web.

Perché l’autore ha utilizzato l’XML? Una prima risposta potrebbe essere perché è intelligibile
cioè, nonostante sia un codice sconosciuto ai più, si riesce a interpretare anche se vagamente. E
poi, con l’XML è possibile creare nuovi tagsa seconda dell’intendimento dell’autore.

Vediamolo un po’ più nel dettaglio.

La parte iniziale:

Vediamo più nel dettaglio.

© 2023 Roberto Atzori

 Formato File Sorgente 99

<?xml version="1.0"?> Indica la versione del linguaggio XML utilizzata

<flowgorithm fileversion="2.11"> Indica la versione di Flowgorithm utilizzata

per la creazione del file in oggetto

<attributes> Questa parte è utilizzata per memorizzare

<attribute name="name" value=""/> alcune informazioni da associare al file
<attribute name="authors" sorgente (.FPRG) come Autore, Data di
value="Roberto"/> creazione, e qualche altra informazione utile a
<attribute name="about" value=""/> Flowgorithm.
<attribute name="saved"
value="2019-02-07 08:45:07 "/>

<attribute name="created"
value="Um9iZXJ0bztERVNLVE9QLVJPQkVSVE87MjA
xOS0wMi0wNzsiMDg6NDI6NDUgIjszMDU2"/>

<attribute name="edited"
value="Um9iZXJ0bztERVNLVE9QLVJPQkVSVE87MjA
xOS0wMi0wNzsiMDg6NDU6MDcgIjsxOzMxNjU="/>

</attributes>

A partire fin da ora, le linee di codice avranno un riferimento più “familiare”.

<function name="Main" type="None" È l’inizio di una funzione (function) particolare

variable="">
in quanto è la prima funzione e questa
corrisponde al

Il tag “<function ..> ha un suo tag di chiusura

</function>

<parameters/> La funzione principale “Main” non ha

parametri. Questo tag assume forma diversa
nel caso di funzioni con parametri.

<body> Il corpo della funzione e </body> il fine tag

<declare name="A, B, SUM" type="Integer" La dichiarazione delle variabili

array="False" size=""/>

Nel flowchart:

© 2023 Roberto Atzori

100 Flowgorithm

In fase di creazione è facile individuare le

singole voci di appartenenza all’interno del
tag <declare … >:

<output expression="&quot;Digit A&quot;" Nel flowchart:

newline="True"/>

In fase di creazione:

<input variable="A"/> Nel flowchart:

In fase di creazione:

© 2023 Roberto Atzori

 Formato File Sorgente 101

<output expression="&quot;Digit B&quot;" Nel flowchart:

newline="True"/>

<input variable="B"/> Nel flowchart:

<assign variable="SUM" expression="A + Nel flowchart:

B"/>

In fase di creazione:

<output expression="&quot;The sum Nel flowchart:

is:&quot;" newline="True"/>

<output expression="SUM" newline="True"/> Nel flowchart:

</body> Fine tag del tag <body>

© 2023 Roberto Atzori

102 Flowgorithm

</function> Fine tag del tag <function>

</flowgorithm> Fine tag del tag <flowgorithm> (termine

esercizio)

Ovviamente possono essere presenti altri tag diversi da quelli visti fino ad ora e corrispondenti
a particolari operazioni / funzioni di Flowgorithm.

Per capire bene qual è l’importanza (per l’utente generico) dell’uso dell’XML, proviamo a vedere
il sorgente dell’esercizio “Somma tra due numeri” svolto utilizzando una funzione nuova creata
dall’utente che svolge, appunto, la somma tra due numeri. L’esercizio si compone di due parti:
una parte principale (MAIN) e una parte secondaria (FUNCTION) richiamata all’interno del
MAIN.

Vediamo il file sorgente:

© 2023 Roberto Atzori

 Formato File Sorgente 103

Oltre ad aver già spiegato prima parte della sua composizione, all’interno del file .FRPG (in XML)
è presente una funzione in più rispetto a quella principale (MAIN): è la funzione
“SumOfTwoNumbers” posizionata subito dopo la funzione MAIN.

Si nota, ora, la presenza di parametri (non presenti nella funzione MAIN).

Questa funzione, così costruita, puo’ essere copiata dal file XML e incollata all’interno di un altro
file XML (altro esercizio) che puo’ far uso di questa funzione subito prima del tag

© 2023 Roberto Atzori

104 Flowgorithm

<flowgorithm>. Dopo aver salvato il tutto e riaperto il file col software Flowgorithm, la funzione
verrà posizionata nella zona funzioni perfettamente funzionante e pronta all’uso all’interno del
nostro flowchart.

In questa maniera è possibile costruire una libreria (un file di tipo testuale .TXT) di funzioni da
copiare e incollare in quegli esercizi dove fosse necessario il loro utilizzo.

© 2023 Roberto Atzori

Capitolo XIII
 106 Flowgorithm

13 Programmazione e Flowgorithm
13.1 Il mio primo diagramma di flusso
Questo breve tutorial, serve creare un semplice programma chiamato “Ciao Mondo”. Si tratta
di un programma tradizionale per neofiti che visualizza "Ciao, mondo!" sullo schermo.
Quando si avvia un nuovo diagramma di flusso, vedrete due rettangoli arrotondati chiamati
simboli "terminali". Questi simboli rappresentano l'inizio e la fine del programma.
Molti diagrammi iniziano il flusso visualizzando il testo "Start". Flowgorithm, invece, usa il testo
"Main". La maggior parte dei linguaggi di programmazione iniziano con "Main" e Flowgorithm …
altrettanto.
Tutto, in un diagramma di flusso, è rappresentato da una figura geometrica. Potrai aggiungere
le figure tra la figura principale e quella finale.
Per aggiungere una figura, spostare il puntatore del mouse su una linea. Se è possibile
aggiungere una figura, la linea diventa di colore arancione.
Fare doppio clic o clicca col pulsante destro del mouse per aggiungere una figura.
Un menu pop-up apparirà mostrando tutte le figure che possono essere inserite.
Nei diagrammi di flusso, ogni azione che il computer può eseguire è rappresentata da una
figura diversa. Ad esempio, le figure di ingresso e di uscita sono rappresentate con
parallelogrammi.
Si può utilizzare anche il “copia e incolla”. Nell’immagine qui sotto è disegnata in grigio perché
non si è ancora copiato niente in memoria.

Il programma “Ciao Mondo” necessita di una figura per l’output. Ciò permetterà di visualizzare
l’informazione nello schermo del computer.

Spostare il mouse sopra il parallelogramma verde con la scritta interna “Output”: ora verrà
evidenziata con un rettangolo blu.

Cliccare sulla figura col pulsante sinistro del mouse e la figura verrà inserita nel diagramma.

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 107

Appena inserita, la figura apparirà colorata di grigio. In Flowgorithm, il colore grigio indica che la
figura è “incompleta”. Ciò significa che la figura ha necessita di altra informazione per poter
funzionare.

È necessario indicare a Flowgorithm cosa volete che visualizzi. Ciò può essere qualsiasi cosa: da
un risultato di un calcolo ad un messaggio.
Eseguendo un doppio click sulla figura si entra nella modalità modifica.

Apparirà una fistra intitolata "Scrittura su schermo". Con questa finestra sarà possibile indicare
cosa far apparire nello schermo del computer.

Nella finestra, scrivere "Ciao mondo!". Attenzione: è necessario aggiungere ache gli apici. Nei
linguaggi di programmazione ciò viene chiamata String (stringa).

Cliccare sul pulsante OK per continuare. Se viene commesso un errore, Flowgorithm ci avvisa
subito. Doppio click sulla figura per correggere l’errore.

La colorazione in verde della figura di output indicherà la corretta creazione.

© 2023 Roberto Atzori

 108 Flowgorithm

Poiché tutte le figure sono colorate nella maniera corretta, ora è possibile eseguire quanto
creato.

Sulla barra principale clicca sul pulsante per eseguire il programma.

Apparirà una nuova finestra chiamate "Finestra Esecuzione" usata per visualizzare le
informazioni e per inserire i dati.

Hai realizzato il tuo primo programma. Congratulazioni!

13.2 Tipi di dato

13.2.1 Integer (Intero)

Il tipo di dati Integer è uno dei tipi più comunemente

utilizzati nella programmazione. Una variabile di tipo
integer può memorizzare un numero intero positivo o
negativo, ma non può memorizzare valori frazionari.
Così, può memorizzare valori quali 5, 42, 1947, ma non
può memorizzare numeri come 3.2, 4.5, ecc ...
La finestra di controllo variabili visualizza i numeri interi
in blu.

13.2.2 Real (Reale)

Il tipo di dati Real può memorizzare un numero

qualsiasi, sia i numeri interi che quelli frazionari. In
molte lingue, questo è chiamato un Double dopo lo
standard implementazione noto come "virgola mobile a
doppia precisione".
La finestra di controllo variabili visualizza i reali in viola.

13.2.3 String (Stringa)

Il tipo di dati String viene utilizzata per memorizzare

tutti i dati testuali. Questo include parole, lettere, o
qualsiasi altra cosa si potrebbe inviare con un
messaggio di testo. Nella programmazione, il testo
viene delimitato da doppi apici. Ad esempio: "CSU,
Sacramento", "computer", e "Anno 1947" sono tutte
delle stringhe.
La finestra di controllo variabile visualizza le stringhe in
rosso.

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 109

13.2.4 Boolean (Booleano o Logico)

Il tipo di dati booleano è in grado di memorizzare sia

"vero" o "falso". Questi sono la base del processo
decisionale in un programma per computer.
La finestra di controllo variabile mostra booleani in
grigio verde.

13.3 Identificatori

Ogni volta che si definisce una funzione o una variabile, viene dato un nome univoco
chiamato "identificatore". Per evitare che gli identificatori possano essere confusi con
altri elementi in una espressione, esse devono seguire una convenzione. Ogni linguaggio
di programmazione ne possiede una e possono differire da un linguaggio all'altro.

In Flowgorithm, gli identificatori devono seguire le seguenti regole:

· Devono iniziare con una lettera.
· Dopo la prima lettera, l’identificatore può contenere lettere o numeri.
· Non sono permessi gli spazi.
· Non possono essere parole riservate o parole già definite in Flowgorithm.
Altre note:
· I linguaggi di programmazione come il Visual Basic e il C permettono anche l’uso del
carattere "_" (underscore). Flowgorithm, al contrario, non lo accetta.
· Gli identificatori non sono case-sensitive, per cui “CASA” è uguale a “casa”.

13.4 Parole chiave

Molte parole usate nei linguaggi di programmazione si sovrappongono alla convenzione

di denominazione utilizzata per gli identificatori. In questi casi, la parola è "riservata" e
non può essere utilizzata per gli identificatori. Inoltre, in molti linguaggi di
programmazione funzioni e altre costanti sono predefinite. Anche queste non possono
essere utilizzate.

13.5 Operatori

Le espressioni utilizzano operatori usati nei due principali linguaggi di programmazione:

la famiglia dei linguaggi di programmazione afferenti al "BASIC" e la famiglia dei
linguaggi di programmazione afferenti al "C" (che include C, Java, C#,..). Flowgorithm
supporta i simboli utilizzati in matematica (usando i valori Unicode).

© 2023 Roberto Atzori

 110 Flowgorithm

Poiché sono supportate entrambe le famiglie, siamo in presenza di un numero ridondante di

operatori. Questi sono:

Flowgorithm fornisce anche la possibilità d’uso di alcuni operatori tipici del Visual Basic
poiché sono utili, semanticamente ben definiti:

Operatore Visual Basic Descrizione

& Concatenazione tra stringhe

^ potenza

In Java e in C#, l’operatore "+" è utilizzato sia per la concatenazione di stringhe sia come
operatore nelle addizioni. Ciò potrebbe trarre in inganno. In Flowgorithm, l’operatore “+” è
utilizzato come operatore aritmetico. Per la concatenazione viene usato il simbolo
“&” (ampersand) e per l’operazione di esponenziazione, il simbolo “^”

13.5.1 Precedenze

La tabella seguente evidenzia il livello di precedenza degli operatori aritmetici e logici, dal
più alto (valutato per prima) al più basso (valutato per ultimo).
Livell
Nome Operazione Note
o

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 111

Operatore In Visual Basic 'not' precede tutti gli operatori

8 unario - ! not ¬ relazionali
Esponente
7 (potenza) ^ Il simbolo non è utilizzato in C# o Java
Operatori * × / ÷
6 aritmetici % mod La divisione ritorna sempre un numero reale
Operatori
5 aritmetici + - Il simbolo '+' è utilizzato solo con i numeri
C# e Java usano in maniera ambigua
4 Concatenazione & l'operatore '+'
Operatori
3 relazionali
∧
&& and

2 E (logico)
∨
|| or

1 O (logico)

Esempi
Soluzion
Espressione Note
e

1+3^2 10

10 * 2 + 5 * 6 50 E' come scrivere (10 * 2) + (5 * 6)

7 * (4 - 1) 21 Le parentesi modificano le precedenze

6/3+2 4 E' come scrivere (6 / 3) + 2

10 MOD 3 1 MOD restituisce il resto della divisione tra interi

10 % 3 1 Come la precedente ma per la famiglia C

13.6 Funzioni e Procedure

13.6.1 Differenza tra FUNZIONE e PROCEDURA
La differenza tra Funzione e Procedura è questa: mentre la Funzione restituisce un valore che
può essere utilizzato, ad esempio, in una espressione matematica, la Procedura non restituisce

© 2023 Roberto Atzori

 112 Flowgorithm

alcun valore ma risulta essere comunque utile (come la funzione) per ottimizzare lo schema
dell’algoritmo in blocchi.

13.6.2 Passaggio dei parametri

Il passaggio dei parametri può avvenire per:

· Valore
In questo caso alla funzione (o alla procedura) vengono passati dei valori (numeri,
stringa, ecc..) direttamente

· Riferimento
In questo caso alla funzione (o alla procedura) vengono passati dei valori (numeri,
stringa, ecc..) memorizzati in variabili

Esempio:
Somma di due numeri (utilizzando una funzione)

Esempio:
Somma di due numeri (utilizzando una procedura)

In questo caso si fa anche uso di una chiamata (alla procedura)

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 113

Nel passaggio dei parametri bisogna stare attenti che corrispondano (in numero, posizione e
tipo) i parametri utilizzati nella funzione chiamante e i parametri utilizzati nella funzione (o
procedura) stessa.

[Link] Esempio 1 in Flowgorithm

Esercizio

Alla stringa “parol” concatenare la lettera “a” per ottenere la stringa “parola” utilizzando le
funzioni

e vediamo come può essere risolto in Flowgorithm.

1a risoluzione

© 2023 Roberto Atzori

114 Flowgorithm

2a risoluzione

3a risoluzione

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 115

4a risoluzione

[Link] Esempio 2 in Flowgorithm

Esercizio

Calcolare il quadrato di un numero utilizzando le funzioni

© 2023 Roberto Atzori

116 Flowgorithm

e vediamo come può essere risolto in Flowgorithm.

1a risoluzione

In questo caso la funzione 'quadrato' non restituisce alcun valore ma ha il compito di valutare
l'espressione "a ^ 2" passata come parametro con la chiamata alla procedura nel programma
principale

dove:

2a risoluzione

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 117

in questo caso l'istruzione "Ouput", nel programma principale, si incarica della visualizzazione e
per fare ciò la stessa istruzione "Output" richiede un elemento da visualizzare, elemento che la
funzione "quadrato", per come è stata scritta nella 1a risoluzione, non viene fornito per cui è
necessario cambiare la funzione "quadrato" in questo modo:

dove:

© 2023 Roberto Atzori

 118 Flowgorithm

in questo modo l'istruzione "Ouput" nel programma principale, funzionerà correttamente

13.7 La ricorsione
13.7.1 Introduzione
Nell’arte possiamo trovare uno dei massimi rappresentanti della ricorsione: Maurits Cornelis
Escher. Il nome di Escher è indissolubilmente legato alle sue incisioni su legno, litografie e
mezzetinte che tendono a presentare costruzioni impossibili (mondi impossibili), esplorazioni
dell'infinito, tassellature del piano e dello spazio e motivi a geometrie interconnesse che
cambiano gradualmente in forme via via differenti.

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 119

Considerando l’arte e la matematica, un esempio classico di utilizzo della ricorsione è il frattale.

Un frattale è un oggetto geometrico dotato di omotetia interna: si ripete nella sua forma allo
stesso modo su scale diverse, e dunque ingrandendo una qualunque sua parte si ottiene una
figura simile all'originale. ([Link]

Ma possiamo trovare la ricorsione anche nei detti popolari:

nasce prima l’uovo o la gallina?

© 2023 Roberto Atzori

120 Flowgorithm

E in Russia …..

In campo tipicamente informatico, e quindi nella implementazione di algoritmi complessi, nasce

l’esigenza, anche per una migliore lettura e ottimizzazione dell’algoritmo stesso, della
scomposizione di quest’ultimo in sotto problemi (sotto algoritmi) più piccoli in modo da tale da
suddividere il “carico” di lavoro in insiemi ognuno dei quali è specializzato in un compito
preciso.

Si possono fare tanti esempi per comprendere questo metodo di approccio ai problemi.

Si può fare l’esempio di una fabbrica di auto suddivisa in tanti reparti, ognuno specializzato
nella costruzione di particolari parti dell’auto: progettazione, carrozzeria, verniciatura,

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 121

meccanica, collaudo, ecc. E probabilmente ognuno di questi reparti, a sua volta, è suddiviso in
altri piccoli reparti per l’attuazione di compiti più piccoli atti alla realizzazione del lavoro
compito di quel singolo reparto.

Si può fare l’esempio di una espressione matematica composta sì da numeri ma anche da

operatori e regole che servono per suddividere l’espressione stessa in parti più piccole e più
semplici da risolvere e partendo da queste ultime si riesce a risolvere l’intera espressione.

Questo metodo di risoluzione viene denominato “Top Down” (dall’alto verso il basso) ovvero
scomporre il problema in sotto problemi più piccoli che a loro volta possono essere scomposti
in sotto problemi più piccoli, ecc. fino ad arrivare ad un problema non più scomponibile (detto
atomico) da cui ripartire e risalire (metodo “Bottom Up”, dal basso verso l’alto) fino al risultato
finale.
Ovviamente noi tutti applichiamo questa metodologia fin da piccoli in modo automatico ma la
maggior parte di noi, diventando grandi o utilizzando strumenti o dispositivi più veloci per
risolvere il problema, dimentica questa metodologia dandola per scontata e ciò ha come
conseguenza la perdita della conoscenza del meccanismo stesso (logica) che porta alla
risoluzione del problema.

Nella implementazione di un algoritmo, il metodo “Top Down” può essere raggiunto con
l’utilizzo, ad esempio, di funzioni e procedure che hanno il compito (ognuno diverso) di
risolvere un pezzo del problema.

Ma se per risolvere il problema si attua lo stesso compito anche per ogni singolo pezzo del
problema stesso, ecco che allora interviene un altro meccanismo: la ricorsione.

© 2023 Roberto Atzori

 122 Flowgorithm

13.7.2 Funzione (o Procedura) ricorsiva

Una funzione è detta ricorsiva se chiama sé stessa. La funzione ricorsiva sa risolvere
direttamente solo casi particolari di un problema detti casi di base o atomici.

Ad ogni chiamata (utilizzo interno alla stessa funzione, Top Down) si semplificano/riducono i
dati, così ad un certo punto si arriva ad uno dei casi di base. Quando la funzione chiama sé
stessa, sospende la sua esecuzione per eseguire la nuova chiamata (con dati più piccoli/ridotti).
L’esecuzione riprende quando la chiamata interna a sé stessa termina cioè la sequenza di
chiamate ricorsive termina quando quella più interna (annidata) incontra uno dei casi di base
(atomici o non più scomponibili).
A questo punto la funzione stessa risale di livello (Bottom Up) ricordandosi la composizione del
problema a livello precedente (elaborazione intermedia) fino alla risoluzione di quest’ultimo
(livello di partenza).

Ovviamente questa particolare metodologia risolutiva ha dei “pro” e dei “contro”.

Pro
Spesso la ricorsione permette di risolvere un problema anche molto complesso con poche linee
di codice.

Contro
La ricorsione è poco efficiente perché richiama molte volte una funzione e questo:

· richiede molto tempo (tecnicamente: per la gestione dello stack allocare e

passare i parametri, salvare l’indirizzo di ritorno, e i valori di alcuni registri della
CPU)
· consuma molta memoria (tecnicamente: alloca un nuovo stack frame ad ogni
chiamata, definendo una nuova ulteriore istanza delle variabili locali non static
e dei parametri ogni volta)

Qualsiasi problema ricorsivo può essere risolto in modo non ricorsivo (ossia iterativo), ma la
soluzione iterativa potrebbe non essere facile da individuare oppure essere molto più
complessa.

Quando non ci sono particolari problemi di efficienza e/o memoria, l’approccio ricorsivo è in
genere da preferire se:
· è più intuitivo di quello iterativo
· la soluzione iterativa non è evidente o agevole

Esempi di problemi che si prestano ad essere risolti ricorsivamente:

· Successione di Fibonacci (L'intento di Leonardo Fibonacci era quello di trovare una legge
matematica che descrivesse la crescita di una popolazione di conigli.)

· Numero Fattoriale (i fattoriali sono importanti nel calcolo combinatorio. In particolare vi

sono n ! {\displaystyle n!} n! diverse sequenze formate da n {\displaystyle n} n oggetti
distinti, cioè vi sono n ! {\displaystyle n!} n! permutazioni di n {\displaystyle n} n oggetti; i
fattoriali quindi enumerano le permutazioni.)

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 123

· Torre di Hanoi (la Torre di Hanoi, anche conosciuta come Torre di Lucas dal nome del
suo inventore, è un rompicapo matematico composto da tre paletti e un certo numero
di dischi di grandezza decrescente, che possono essere infilati in uno qualsiasi dei
paletti. [Link] )

13.7.3 Esempio in Flowgorithm

Esempio di risoluzione informatica: calcolo del fattoriale.

In matematica il fattoriale di un numero viene così espresso:

Ovviamente, come detto precedentemente, ogni funzione ricorsiva può essere espressa
in modo iterativa.
Ecco la risoluzione iterativa del problema

© 2023 Roberto Atzori

124 Flowgorithm

E questa è la versione ricorsiva:

© 2023 Roberto Atzori

 Programmazione e Flowgorithm 125

© 2023 Roberto Atzori

Capitolo XIV
 Paradigma di Programmazione 127

14 Paradigma di Programmazione
14.1 Gli elementi di base
14.1.1 Introduzione
In informatica, un paradigma di programmazione è uno stile fondamentale di programmazione,
ovvero un insieme di strumenti concettuali forniti da un linguaggio di programmazione per la
stesura del codice sorgente di un programma, definendo dunque il modo in cui il
programmatore concepisce e percepisce il programma stesso. Diversi paradigmi si
differenziano per i concetti e le astrazioni usate per rappresentare gli elementi di un
programma (come ad esempio le funzioni, gli oggetti, le variabili, vincoli, ecc.) e per i
procedimenti usati per l'esecuzione delle procedure di elaborazione dei dati (assegnazione,
calcolo, iterazione, data flow, ecc).

14.1.2 Tipi di paradigmi

Per quanto riguarda almeno i linguaggi di programmazione usati nella pratica industriale
dello sviluppo del software, si può identificare un "filone principale" di paradigmi di
programmazione:
programmazione modulare

(metà anni settanta) Modula, CLU (linguaggio)

programmazione orientata agli aspetti

Una estensione dell'OOP (anni 2000) AspectJ

programmazione orientata agli utenti

Inside Microsoft Windows NT Internet Development (1998 Microsoft Press),

piattaforma .NET

programmazione orientata agli oggetti

(anni ottanta) Smalltalk, Eiffel, C++, Java, Python, Ruby, piattaforma .NET

programmazione strutturata secondo patterns

Java blueprints, Sun Java blueprints

programmazione per pattern matching

(Espressioni regolari)

programmazione procedurale

(anni sessanta) Fortran, F#

© 2023 Roberto Atzori

 128 Flowgorithm

programmazione strutturata

(primi anni settanta) Pascal, C

programmazione per tipi di dati astratti

(tardi anni settanta) OBJ

Altri paradigmi sono nati per applicazioni specifiche:

programmazione concorrente

Inizialmente per il calcolo su architetture parallele (anni settanta) Erlang,

Communicating Sequential Processes (CSP), Occam

programmazione logica

Per applicazioni euristiche, intelligenza artificiale, ecc.; (anni settanta) Prolog

programmazione funzionale

Per applicazioni matematiche e scientifiche ecc.; (anni settanta) Lisp, Haskell

programmazione orientata agli eventi

Per applicazioni real-time e interfacce grafiche

programmazione a vincoli

14.1.3 Formato File

I meccanismi di astrazione dei linguaggi di programmazione, differenti per i vari paradigmi,
possono contribuire a rendere possibile stili di programmazione basati su concetti non
direttamente forniti dal linguaggio utilizzato.

Con l’uscita della versione 2.15.0, Flowgorithm si arricchisce di una nuova funzionalità: il
supporto per la personalizzazione dei modelli di programmazione.

Il Visualizzatore Codice Sorgente di Flowgorithm consente di convertire i diagrammi di flusso in

diversi linguaggi di programmazione attualmente in voga. Questi includono: Java, C #, Visual
Basic .NET, Smalltalk e molti altri. Il codice sorgente generato viene creato utilizzando i modelli
di programmazione. Si tratta di file che contengono informazioni sintattiche sul linguaggio di
programmazione selezionato come parole chiave, formattazione e precedenza degli operatori.

Questa documentazione individua il formato e i modelli utilizzati da Flowgorithm. Tutto ciò può
essere utile per creare nuovi modelli partendo da quelli esistenti.

© 2023 Roberto Atzori

 Paradigma di Programmazione 129

[Link] Estensione del file

I modelli di programmazione di Flowgorithm usano l’estensione .fpgt anche se il Visualizzatore

del Codice Sorgente è in grado di aprire file con qualsiasi estensione purché rappresenti un
modello di programmazione.

[Link] Formato File (elementi base)

I modelli di programmazione vengono salvati in un semplice file di testo utilizzando il formato

INI. L'obiettivo è renderli di facile lettura e scriverli tramite l’uso di un semplice editor di testo. I
modelli di programmazione di Flowgorithm supportano la codifica Unicode con la possibilità,
quindi, di utilizzo di caratteri diversi da quelli proposti dalla codifica standard ASCII.

I files con estensione INI riconoscono tre elementi sintattici di base: commenti, intestazioni di
sezione, e dichiarazioni di chiave o di valore. Partendo da questi, si è in grado di rappresentare
tabelle non gerarchiche.

Gli elementi sono i seguenti:

Elemento Azione Esempio

Comment I Commenti non producono alcuna azione ; Comment

ma sono utili come documentazione per
chiunque legga il file.

Section Le Sezioni individuano differenti parti logiche [Section Name]

del file.

Key/Value Le Chiavi (Key) si comportano come le Key = Value

variabili e vengono valorizzate.

Il nome e la chiave della sezione vengono utilizzati per identificare univocamente un valore.
Questo è, più o meno, equivalente alle tabelle e alle righe presenti negli archivi di dati
(databases).

Esempio

[Variable ID]

Convention = camel

© 2023 Roberto Atzori

 130 Flowgorithm

Normal = {Name}

Conflict = var_{Name}

[Link] Formato Linea

Ogni riga nel modello contiene fino a tre sotto valori. Ciò consente di specificare quanto segue
per ogni riga:

1. Formato testo / valore

2. Flag che indica quando la linea è considerata valida

3. Qualsiasi cambiamento nell’indentazione

Formato linea

Text | Flags | Indentation

I tre valori non devono necessariamente essere presenti tutti nella riga. Se l’indentazione è
lasciata vuota, ad esempio, il sistema assumerà il valore 0 (zero) o il significato di nessuna
modifica.

[Link] Campi
Molte delle diverse chiavi / valori contengono "campi" che sono indicati da parentesi graffe
‘{‘ (parentesi graffa aperta) e ‘}’ (parentesi graffa chiusa). Quando viene generato un
programma, il testo viene inserito in questi campi a seconda dell'oggetto corrente (ad es. una
espressione, una istruzione, ecc.). I contenuti dei campi possono essere prelevati direttamente
dall'oggetto o, in alcuni casi, generati utilizzando altre parti del modello.

I nomi dei campi non sono ‘case sensitive’ (ovvero non c’è alcuna distinzione fra maiuscole e
minuscole). L'utilizzo di una doppia parentesi graffa aperta ‘{{‘ indica una sequenza di
sostituzione.

Nell'esempio seguente, la chiave ‘Text’ contiene due campi: {Variable} e {Expression}.

Esempio – Istruzione di Assegnazione

Text
= Set {Variable} = {Expression}

© 2023 Roberto Atzori

 Paradigma di Programmazione 131

La maggior parte dei campi sono specifici per la sezione nella quale vengono utilizzati. Tuttavia,
ci sono alcuni campi definiti ‘globali’ molto utili. Sono progettati per superare i limiti del
formato del modello di programmazione.

Campi Globali Contenuto

{space} Questo contiene un singolo carattere (spazio). Poiché il

formato del file elimina automaticamente spazi iniziali e/o
finali, questa variabile può essere utilizzata per aggiungere
esplicitamente un carattere spazio all’interno di un
programma.

{pipe} Il simbolo pipe ‘|’ è usato per separare le tre sezioni di

una linea. Per consentire l'uso del simbolo pipe nel
programma, questa variabile contiene un singolo carattere
‘|’.

[Link] Linee Multiple

I file INI, su cui si basano i modelli di programma Flowgorithm, generalmente non consentono a
una chiave di contenere valori multipli (o righe). Tuttavia, i modelli di programma consentono a
qualsiasi chiave di contenere più valori (o righe). Questi possono rappresentare diversi possibili
valori o diverse righe in un'istruzione generata. Per aggiungere un altro valore/riga a una
chiave, inizia la riga successiva con un segno di uguale =.

Esempio – Istruzione While

Text = while {condition}

= -->BLOCK
= end while

[Link] Flag
Quando viene generato il codice sorgente, il sistema può includere o escludere le righe in base
alle informazioni dello stesso programma. Ciò può essere dovuto al fatto che sia necessaria
una specifica sintassi, in presenza di diverse chiamate di libreria (in base al tipo di dati
utilizzato in una istruzione), ecc ....

Per controllare quali linee sono valide nel modello di programmazione, il sistema fa uso dei
Flags. I Flags sono definiti dalla sezione nella quale hanno un significato e possono essere
utilizzati per controllare il codice sorgente generato. Si possono utilizzare più Flags ma separati
da virgole. La linea è considerata valida se, e solo se, tutti i Flags sono abbinati in maniera

© 2023 Roberto Atzori

 132 Flowgorithm

corretta. Se un Flag è preceduto dal simbolo tilde ‘~’, il sistema lo individuerà come essere
‘False’.

L'esempio seguente utilizza diversi Flags, in particolare "inc" e "step". Nel contesto di una
struttura iterativa For, il Flag "Step" è impostato su True nella struttura iterativa For avente un
valore di step diverso da 1 e "inc" è impostato a True se la struttura iterativa For segue un
andamento in ordine crescente (positivo).

La combinazione di questi valori comporterà la selezione di una riga (che inizia con ‘for’).

Esempio – Struttura iterativa “For”

[For]
Text = for {Variable} = {Start} To {End} | inc, ~step
= for {Variable} = {Start} To {End} Step {step} | inc, step
= for {Variable} = {Start} To {End} Step -1 | ~inc, ~step
= for {Variable} = {Start} To {End} Step -{step} | ~inc, step
= -->BLOCK | |1
= end for

[Link] Indentazione
La maggior parte dei linguaggi di programmazione consente l'uso dell'indentazione per
formattare visivamente il testo. Ciò consente al programmatore di poter facilmente distinguere
e comprendere blocchi e ad altri elementi sintattici. L'ultimo sotto valore di una riga può
contenere la modifica nella indentazione del codice generato.

Nell'esempio seguente, la riga che contiene il valore speciale "---> BLOCK" (che ha un flag vuoto)
ha un singolo "1" per l’indentazione. Ciò farà indentare il testo inserito di 1 livello.

Nota: questo non si riferisce ai caratteri, ma al livello di indentazione. Il livello di indentazione,

nel codice generato, viene convertito automaticamente in un numero fisso di spazi.

Esempio – Struttura iterativa “While”

Text = while {condition}

= -->BLOCK ||1
= end while

14.1.4 Flags Globali

I modelli contengono un numero di flag a seconda se vengono utilizzate determinate istruzioni
e funzioni. Questi sono globali e sono progettati per essere utilizzati con la sezione [Program] e
la sezione delle istruzioni.

© 2023 Roberto Atzori

 Paradigma di Programmazione 133

[Link] Funzioni intrinseche

Flags Da utilizzare quando ….

arccos la funzione ArcCos è utilizzata nel programma.

arcsin la funzione ArcSin è utilizzata nel programma.

cos la funzione Cos è utilizzata nel programma.

char la funzione ArcSin è utilizzata nel programma.

int la funzione Int è utilizzata nel programma.

log la funzione Log è utilizzata nel programma.

log10 la funzione Log10 è utilizzata nel programma.

pi viene utilizzata la costante PI nel programma.

random la funzione Random è utilizzata nel programma.

sin la funzione Sin è utilizzata nel programma.

size la funzione Size è utilizzata nel programma.

sgn la funzione Sgn è utilizzata nel programma.

tan la funzione Tan è utilizzata nel programma.

tochar la funzione ToChar è utilizzata nel programma.

tocode la funzione ToCode è utilizzata nel programma.

tointeger la funzione ToInteger è utilizzata nel programma.

tofixed la funzione ToFixed è utilizzata nel programma.

tostring la funzione ToString è utilizzata nel programma.

toreal la funzione ToReal è utilizzata nel programma.

© 2023 Roberto Atzori

 134 Flowgorithm

[Link] Array

Flags Da utilizzare quando ….

arrays Sono utilizzati gli Array (di qualsiasi tipo).

integer-arrays Sono utilizzati gli Array di tipo intero.

real-arrays Sono utilizzati gli Array di tipo reale.

string-arrays Sono utilizzati gli Array di tipo stringa.

boolean-arrays Sono utilizzati gli Array di tipo booleano.

[Link] Altro

Flags Da utilizzare quando ….

input viene utilizzata l’istruzione Input nel programma

output viene utilizzata l’istruzione Output nel programma

trigonometry viene utilizzata qualsiasi funzione trigonometrica, incluso PI

14.1.5 Programma
Quando un diagramma di flusso (flowchart) viene convertito in un determinato linguaggio di
programmazione, il sistema parte dalla sezione [Program]. Questa sezione dà, allo sviluppatore,
la possibilità di inserire la funzione principale, le funzioni aggiuntive, le intestazioni di funzione e
altre definizioni necessarie. Come conseguenza, nella sezione si farà un uso importante dei
flags.

Esempio Java

[Program]
Text = import [Link].*;
= import [Link];
=
= public class JavaApplication {{
= private static Scanner input = new
| input |1
Scanner([Link]);
= private static Random random = new Random(); | random |1

© 2023 Roberto Atzori

 Paradigma di Programmazione 135

=
= -->MAIN | |1
= -->FUNCTIONS | |1
= | tofixed |1
= private static String toFixed(double value, int digits) {{ | tofixed |1
= return [Link]("%." + digits + "f", value); | tofixed |2
=} | tofixed |1
=}

Nell’esempio precedente i flags sono utilizzati, opzionalmente, per creare dichiarazioni per la
funzione Scanner e Random rispettivamente. Inoltre, se viene utilizzata la funzione ToFixed, il
modello creerà una funzione locale chiamata ToFixed() che implementerà tale logica.

[Link] La chiave testuale

La chiave testuale viene utilizzata per generare la sintassi del programma principale. Essa non
contiene alcun campo.

Campi

Nessuno

Flags

Vedere l’argomento Flags

Globali 132

Per poter inserire il blocco della struttura iterativa While, si utilizzi una singola linea contenente
i seguenti valori speciali. Se si vuole cambiare l’indentazione del blocco, assicurarsi di
specificare l’indentazione dopo il secondo simbolo di pipe ‘|’.

Valore speciale Cosa fa

-->HEADERS Inserisce intestazioni di funzione. Queste verranno

generate all’interno della sezione [Function Header]

-->MAIN Inserisce la funzione principale. Questa è definita nella

sezione [Main Function]

© 2023 Roberto Atzori

 136 Flowgorithm

-->FUNCTIONS Inserisce le funzioni dei programmi. Non viene incluso il

Main. Queste sono definite nella sezione [Function]

14.2 Identificatori e Tipi

14.2.1 Attributi del linguaggio
La prima sezione del modello definisce un importante numero di attributi del linguaggio di
programmazione di destinazione quali il suo nome, l’elenco delle parole chiave e se il linguaggio
è ‘case sensitive’

Esempio Java

[Language]
Name = Java
Extension = java
Direction = left-to-right

Keywords = abstract, assert, boolean, break, byte, case, catch, char, class, const
= continue, default, double, do, else, enum, extends, false, final, finally
= float, for, goto, if, implements, import, instanceof, int, interface, long
= native, new, null, package, private, protected, public, return, short, static
= strictfp, super, switch, synchronized, this, throw, throws, transient, true, try
= void, volatile, while

Conflicts = input
Case
= true
Sensitive

Options = aligned

[Link] Attributi

Attributi Contenuti

Name Il nome del linguaggio di programmazione. Questo valore verrà

visualizzato nel menù e negli altri elementi grafici dell’interfaccia utente
(GUI)

© 2023 Roberto Atzori

 Paradigma di Programmazione 137

Extension Quando viene salvato un programma generato, questo valore rappresenta

l’estensione del file

Direction Questo attributo controlla se il codice generato verrà visualizza nel

formato da sinistra verso destra (la tipica modalità di scrittura utilizzata
nelle nazioni come Inghilterra, Spagna, Italia,..) o da destra verso sinistra
(la tipica modalità di scrittura tipica di alcune nazioni quali Arabia Saudita,
Israele, …)

Keywords Questa chiave è utilizzata per elencare tutte le chiavi del linguaggio di
programmazione di destinazione. L’elenco verrà utilizzato per generare
identificatori univoci per il resto del programma. E’ importante elencare
tutte le parole chiave e le parole riservate che potrebbero causare errori
sintattici quando vengono usati dall’utente come un qualsiasi
identificatore.

Conflicts Questa chiave viene utilizzata con le stesse modalità della chiave
precedente Keywords. Essa fornisce un elenco delle parole chiave o parole
riservate che verrà utilizzato per la generazione di identificatori.
Comunque, questo elenco viene predisposto per elencare gli identificatori
che lo stesso modello crea. Ad esempio, se un modello crea una funzione
chiamata Output, allora la parola ‘output’ dovrebbe essere elencata qui.

Case Sensitive Può essere impostata sia a True che a False

Options Campi di formattazione opzionali supportati dal Visualizzatore del Codice

Sorgente. Attualmente è supportato solo il valore ‘aligned’ che crea un
elenco a discesa contenente le parole chiave ‘aligned’ e ‘hanging’ per l’uso
nei linguaggi di programmazione della famiglia del linguaggio di
programmazione ‘C’

14.2.2 Identificatori
La maggior parte di linguaggi di programmazione possiede un elenco di parole chiave (che
seguono lo stesso formato degli identificatori) che implementano i diversi elementi sintattici del
linguaggio di programmazione. Ad esempio, la maggior parte dei linguaggi di programmazione
utilizza la parola chiave "if" per le istruzioni condizionali.

È possibile creare un nome di variabile (o un nome di funzione) in un linguaggio che potrebbe

non essere valida per un altro linguaggio. I programmatori di Visual Basic, ad esempio, possono
creare una variabile chiamata "float" poiché non è una parola chiave (VB utilizza "single" per
numeri in virgola mobile a precisione singola). Sebbene sia valido in VB, l'identificatore non può
essere utilizzato testualmente se il programma viene convertito in Java. In questo caso, "float" è
una parola riservata.

© 2023 Roberto Atzori

 138 Flowgorithm

Il conflitto risultante causerà un codice generato non valido (generando ad esempio un errore
di sintassi).

[Link] Creazione di nuovi identificatori

I modelli contengono due sezioni progettate per generare nuovi identificatori (se necessario).
Entrambe le sezioni contengono le stesse chiavi e la stessa modalità di base. L'identificatore
originale di Flowgorithm viene controllato, ogni volta, con l'elenco di valori presenti nelle
sezioni Keywords e Conflicts definiti nella sezione [Language]. Se non viene trovato alcun
conflitto, verrà utilizzata la chiave Normal per creare l'identificatore. Se viene rilevato un
conflitto, verrà utilizzata la chiave Conflict.

Esempio Java

[Function ID]
Convention = camel
Normal = {Name}
Conflict = func_{Name}

[Variable ID]
Convention = camel
Normal = {Name}
Conflict = var_{Name}

Nota: il carattere di sottolineatura ‘_’ non è consentito negli identificatori di Flowgorithm. Può
essere usato per creare una stringa univoca prefissa (o suffisso) di caratteri.

La chiave ‘Convention’
La chiave ‘Convention’ viene utilizzata per creare un identificatore utilizzando la convenzione di
denominazione della lingua di destinazione. Può contenere una delle due opzioni:

1. Proper

2. Camel

L’opzione Proper viene utilizzata da linguaggi come Visual Basic e Smalltalk. In questa
convenzione, la prima lettera di ogni parola è maiuscola come TestProgram e FirstName. Le
lingue, come Java e C#, usano questa convenzione solo per i nomi di classe.

L’opzione Camel viene utilizzata per nomi di variabili in lingue come C # e Java. In questa
convenzione, la prima lettera della parola è in minuscolo mentre il resto è in maiuscolo o
minuscolo. Ad esempio: testProgram e firstName.

© 2023 Roberto Atzori

 Paradigma di Programmazione 139

Campi

Nessuno

Flags

Nessuno

La chiave ‘Normal’
Viene utilizzata questa chiave se l'identificatore, utilizzato nel diagramma di flusso, non è in
conflitto con le parole chiave del linguaggio di destinazione.

Campi

{Name} Identificatore originale di Flowgorithm

Flags Da utilizzare quando ….

integer L’identificatore è di tipo Integer.

real L’identificatore è di tipo Real.

boolean L’identificatore è di tipo Boolean.

string L’identificatore è di tipo String.

None L’identificatore non è di alcun tipo conosciuto. Ciò accade quando,

ad esempio, si è in presenza di un identificatore non dichiarato.
Suggerito come impostazione di sintassi iniziale.

La chiave ‘Conflict’
Se l'identificatore di Flowgorithm è in conflitto con una delle parole chiave del linguaggio di
destinazione, questa chiave viene utilizzata per generare un nuovo identificatore.

Campi Contenuti

{Name} Identificatore originale di Flowgorithm

© 2023 Roberto Atzori

 140 Flowgorithm

Flags Da utilizzare quando ….

integer L’identificatore è di tipo Integer.

real L’identificatore è di tipo Real.

boolean L’identificatore è di tipo Boolean.

string L’identificatore è di tipo String.

None L’identificatore non è di alcun tipo conosciuto. Ciò accade quando, ad

esempio, si è in presenza di un identificatore non dichiarato. Suggerito come
impostazione di sintassi iniziale.

14.2.3 Tipi
La sezione ‘Types’ definisce i nomi dei tipi di dato del linguaggio di destinazione.

Esempio Java

[Types]
Integer = int
Real = double
Boolean = boolean
String = String

Questa sezione è una tabella semplice. Non ci sono né campi né flags.

Campi

Nessuno

Campi

Nessuno

© 2023 Roberto Atzori

 Paradigma di Programmazione 141

14.3 Gli elementi testuali

14.3.1 I valori stringa testuali
Diversi linguaggi di programmazione possiedono formati ben distinti per le stringhe testuali.
Molto spesso, si tratta di una serie di caratteri delimitati da virgolette. Tuttavia, questo non è
sempre vero. Alcuni linguaggi usano apice singolo, come Smalltalk e. altri, un formato ancora
più particolare.

Ogni volta che il modello deve creare una stringa testuale, utilizza questa sezione. Esistono una
serie di tasti di caratteri di sostituzione che sono utili per ignorare i delimitatori.

Esempio Java

[String Literal]
Text = "{Characters}"
Replace Char 1 ="
Replace By 1 = \"
Replace Char 2 =\
Replace By 2 = \\

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi della stringa testuale. Il campo
{characters} contiene una sequenza di caratteri dopo che la stringa originale è stata modificata
dalle varie chiavi di sostituzione.

Campi Contenuti

{characters} I caratteri della stringa letterale

Flags

Nessuno

[Link] La chiave ‘Replace’

Le stringhe testuali possono contenere fino a 3 coppie di caratteri sostitutivi. Nell'esempio
sopra, tutte le occorrenze di " saranno sostituite da \" e tutte le occorrenze di \ saranno
sostituite da \\.

Campi

© 2023 Roberto Atzori

 142 Flowgorithm

Nessuno

Flags

Nessuno

14.3.2 valori interi testuali

I valori interi testuali sono molto presenti nei linguaggi di programmazione. Questa sezione
consente di definire in modo esplicito i valori interi testuali.

Esempio Java

[Integer Literal]
Tex
= {integral}
t

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi di un numero intero.

Campi Contenuti

{integral} Le cifre che rappresentano la parte intera

(integrale) del numero

Flags

Nessuno

14.3.3 I valori reali testuali

I reali testuali sono abbastanza presenti tra la maggior parte dei linguaggi di programmazione,
ma tendono a variare da una nazione all'altra. Negli Stati Uniti, il punto ‘.’ viene utilizzato per
separare l'intera parte dalla parte frazionaria del numero. In Europa, invece, viene utilizzata la
virgola ‘,’.

Questa sezione consente di definire il formato dei numeri reali. Se viene prodotto uno
pseudocodice, non esitare a utilizzare il formato della nazione di destinazione.

© 2023 Roberto Atzori

 Paradigma di Programmazione 143

Esempio Java

[Real Literal]
Tex
= {integral}.{fractional}
t

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi di un numero reale.

Campi Contenuti

{integral} Le cifre che rappresentano la parte intera

(integrale) del numero

{fractional} Le cifre che rappresentano la parte frazionaria del

numero

Flags

Nessuno

14.3.4 I valori booleani testuali

Questa sezione è una semplice tabella

Esempio Java

[Boolean Literal]
True = true
False = false

[Link] Le chiavi ‘True’ e ‘False’

Queste chiavi definiscono le costanti per ‘True’ e ‘False’.

Campi

Nessuno

© 2023 Roberto Atzori

 144 Flowgorithm

Flags

Nessuno

14.4 Espressioni
14.4.1 Espressioni e funzioni intrinseche
[Link] Espressioni
Le espressioni nei diversi linguaggi di programmazione differiscono notevolmente nella
struttura delle precedenze. Di conseguenza, i modelli utilizzano un semplice sistema per
convertire qualsiasi espressione Flowgorithm nel formato della lingua di destinazione. Per fare
ciò, i modelli usano lo stesso sistema sia per le chiamate di funzioni intrinseche (come Cos,
ToInteger, ecc ...) che per gli operatori. Ogni funzione e/o operatore ha gli stessi campi, ovvero
{1} e {2}. Questi rappresentano i valori passati ad una funzione intrinseca o la parte a sinistra e
la parte a destra di un operatore.

Campi Contenuti

{1} L'espressione utilizzata nella parte sinistra di un operatore o il

primo argomento in una funzione intrinseca.

{2} L'espressione utilizzata nella parte destra di un operatore o il

secondo argomento in una funzione intrinseca.

Livelli di precedenza
Ogni funzione o operatore contiene anche chiavi condivise per la precedenza dell'operatore
(nel linguaggio di programmazione di destinazione) e quale precedenza è necessaria per {1} e
{2}. Maggiore è il valore numerico assegnato alla funzione o operatore, maggiore è la sua
precedenza. Ad esempio, nella maggior parte dei linguaggi di programmazione, la
moltiplicazione e la divisione vengono calcolate prima dell'addizione e della sottrazione. In
questo caso, gli operatori di moltiplicazione e divisione avranno un valore di precedenza più
elevato.

Esempio Java

[Cos]
Precedence = 100
Needed 1 =0
Text = [Link]({1})

© 2023 Roberto Atzori

 Paradigma di Programmazione 145

La sezione ‘Subexpression’
Ogni volta che il sistema deve incrementare la precedenza di {1} o {2}, si utilizzerà la sezione
[Subexpression]. Questa sezione differisce dalle altre funzioni e operatori poichè non contiene
flag e ha solo un campo {Expression}.

L'esempio di seguito è abbastanza universale per le espressioni in tutti i linguaggi di

programmazione.

Esempio Java

[Subexpression]
Precedence = 100
Text = ({Expression})

[Link] Sezioni e Flags

Sezioni
Le seguenti sezioni usano il formato 'espressione’. Esse contengono le stesse chiavi, flags e la
modalità di base.

Sezioni Operatore

[Add] [Greater Than] [Multiply] [Power]

[And] [Greater Equal Than] [Negate] [Subtract]

[Concatenate] [Less Than] [Not]

[Divide] [Less Equal Than] [Not Equals]

[Equals] [Modulus] [Or]

Sezioni Funzione Intrinseca

[Abs] [Cos] [Pi] [Sqrt] [ToInteger]

[ArcCos] [Int] [Random] [Tan] [ToReal]

[ArcSin] [Len] [Sin] [ToChar] [ToString]

© 2023 Roberto Atzori

146 Flowgorithm

[ArcTan] [Log] [Sgn] [ToCode]

[Char] [Log10] [Size] [ToFixed]

Chiavi

Campi Contenuti

Precedence Un valore numerico che indica il livello di precedenza di questa

funzione / operatore.

Type Se il tipo di dati, creato da questa funzione / operatore, differisce

da Flowgorithm, questo campo può specificare il nuovo tipo. Ad
esempio, in Java, 1/2 restituisce un intero. Flowgorithm restituisce
un real. Valori consentiti sono: Integer, Real, String e Boolean.

Needed 1 Il livello di precedenza necessario per {1}. In genere questo è uguale

o maggiore del valore specificato nella chiave Precedence.

Needed 2 Il livello di precedenza necessario per {2}. In genere questo è uguale

o maggiore del valore specificato nella chiave Precedence.

Text La sintassi della funzione / operatore.

L'esempio seguente definisce un operatore logico AND di base in Java. I valori di precedenza
necessari per {1} e {2} sono tipici degli operatori da sinistra verso destra che consentono
cambiamenti (ad esempio: X && y && z).

Esempio Java – Operatore AND

[And]
Precedence =2
Needed 1 =2
Needed 2 =3
Text = {1} && {2}

© 2023 Roberto Atzori

 Paradigma di Programmazione 147

Flags
Diversi linguaggi di programmazione utilizzano spesso operatori diversi o chiamate di librerie, in
base al tipo di dato utilizzato. A volte un operatore è incorporato direttamente in un linguaggio
di programmazione mentre, in altri casi, richiede una chiamata alla libreria. Un buon esempio di
questo è l'operatore esponente. In Flowgorithm e nella famiglia di linguaggio BASIC, il simbolo ^
viene utilizzato per indicare un esponente. I linguaggi della famiglia C (come Java) tendono a
utilizzare una chiamata di funzione di una specifica libreria, cioè verrà utilizzata la funzione
Pow().

Inoltre, i linguaggi di programmazione hanno regole diverse che definiscono quale tipo di dati
viene restituito da un calcolo. Queste varie "conversioni aritmetiche generiche" possono variare
notevolmente tra i vari linguaggi. Ad esempio, nella famiglia di linguaggi C l'espressione "1/2"
restituirà zero. Le regole stabiliscono che se entrambi gli operandi sono interi, viene utilizzato
l'intero matematico. In Flowgorithm e nella famiglia di linguaggi tipo BASIC, la virgola mobile
viene sempre utilizzata per la divisione (0,5).

Quindi, per gestire tutti questi diversi scenari, i modelli contengono un numero elevato di flag in
modo da poter selezionare la sintassi corretta.

L'esempio seguente definisce un operatore base di addizione in Java. La precedenza necessaria

per {1} e {2} è tipica degli operatori da sinistra verso destra che consentono il concatenamento
(ad esempio 1 + 2 + 3 + 4). La chiave Type è definita per seguire le "conversioni aritmetiche
generiche" di Java.

Esempio Java – Operatore ADD

[Add]
Type = integer | integer-integer
= real | ~integer-integer

Precedence =5
Needed 1 =5
Needed 2 =6
Text = {1} + {2}

I seguenti flag permettono di verificare una certa combinazione tra {1} e {2}. Spesso questi sono
usati con il prefisso di negazione ‘~’ per gestire casi speciali.

Combinazione Flag Da utilizzare quando ….

string-string {1} è una stringa, {2} è una stringa

© 2023 Roberto Atzori

148 Flowgorithm

string-integer {1} è una stringa, {2} è un valore intero

string-real {1} è una stringa, {2} è un valore reale

string-boolean {1} è una stringa, {2} è un valore booleano

integer-string {1} è un valore intero, {2} è una stringa

integer-integer {1} è un valore intero, {2} è un valore intero

integer-real {1} è un valore intero, {2} è un valore reale

integer-boolean {1} è un valore intero, {2} è un valore booleano

real-string {1} è un valore reale, {2} è una stringa

real-integer {1} è un valore reale, {2} è un valore intero

real-real {1} è un valore reale, {2} è un valore reale

real-boolean {1} è un valore reale, {2} è un valore booleano

boolean-string {1} è un valore booleano, {2} è una stringa

boolean-integer {1} è un valore booleano, {2} è una stringa

boolean-real {1} è un valore booleano, {2} è una stringa

boolean-boolean {1} è un valore booleano, {2} è una stringa

L'esempio seguente mostra in che modo Java considera le stringhe e i valori numerici in modo
diverso. Nota: la precedenza "Needed" varia notevolmente in base al confronto di una stringa
con un'altra stringa. Nell'ultima riga, quando viene usato .equals, {1} deve avere una
precedenza di 100 (max in questo modello) e {2} richiede solo 1 (dato che è racchiuso tra
parentesi).

Esempio Java

[Equals]

© 2023 Roberto Atzori

 Paradigma di Programmazione 149

Precedence =3 | ~string-string
= 100 | string-string

Needed 1 =4 | ~string-string
= 100 | string-string

Needed 2 =4 | ~string-string
=1 | string-string

Text = {1} == {2} | ~string-string

= {1}.equals({2}) | string-string

Il tipo di {1} e {2} può anche essere impostato separatamente.

Flag Da utilizzare quando ….

string-1 {1} è una stringa

integer-1 {1} è un intero

real-1 {1} è un reale

boolean-1 {1} è un booleano

string-2 {2} è una stringa

integer-2 {2} è un intero

real-2 {2} è un reale

boolean-2 {2} è un booleano

14.4.2 Accesso alla variabile

Questa sezione viene utilizzata per ottenere la sintassi corretta quando si accede a una variabile
in un'espressione.

Esempio Java

© 2023 Roberto Atzori

 150 Flowgorithm

[Variable Access]
Precedence = 100
Text = {name} | ~subscript
= {name}
| subscript
[{subscript}]

[Link] La chiave ‘Precedence’

Questa chiave definisce la precedenza dell'accesso alla variabile. Normalmente, questa
dovrebbe essere impostata sul valore massimo utilizzato nelle espressioni del modello.

[Link] La chiave ‘Text’

La chiave Text viene utilizzata per generare la sintassi per un accesso alla variabile.

Campi Contenuti

{name} Il nome della variabile

{subscript} Il simbolo pedice (indice) se si accede a un elemento dell'array.

Il primo e l'ultimo flag possono essere utilizzati se la sintassi differisce nella prima o ultima
istruzione nel blocco.

Flag Da utilizzare quando ….

integer L’espressione è un intero

real L’espressione è un reale

boolean L’espressione è un boolean

String L’espressione è una stringa

none L'espressione non ha un tipo noto, ovvero non dichiarato. Questo

è buono per una sintassi "predefinita".

subscript Un simbolo pedice (indice) viene utilizzato con la variabile

from-parameter La variabile è stata definita come un parametro

© 2023 Roberto Atzori

 Paradigma di Programmazione 151

14.4.3 Elenco Argomenti

La sezione degli argomenti viene utilizzata per generare un elenco di espressioni da utilizzare
per le chiamate di funzione e le dichiarazioni di chiamata.

Esempio Java

[Argument]
Separator = ,{space}
Text = {expression}

[Link] La chiave ‘Separator’

La chiave ‘Separator’ definisce il testo che verrà inserito tra l'elenco dei nomi degli argomenti.

Campi

Nessuno

Flags Contenuti

first L’espressione è il primo elemento della lista

last L’espressione è l’ultimo elemento della lista

[Link] La chiave ‘Text’

La chiave ‘Text’ è usata per generare la sintassi della lista degli argomenti.

Campi Contenuti

{Expression} L’espressione per l’argomento

{Parameter Name} Il nome del parametro della funzione che corrisponde all'argomento.
Questo è necessario per "argomenti nominati" usati in linguaggio come
Swift e Smalltalk.

Il primo e l'ultimo flag possono essere utilizzati se la sintassi differisce nella prima o ultima
istruzione nel blocco.

Flag Da utilizzare quando ….

© 2023 Roberto Atzori

 152 Flowgorithm

integer L’espressione è un intero

real L’espressione è un reale

boolean L’espressione è un boolean

string L’espressione è una stringa

none L'espressione non ha un tipo noto, ovvero non dichiarato.

Questo è buono per una sintassi "predefinita".

integer-parameter Il parametro relativo è un tipo Integer

real-parameter Il parametro relativo è un tipo Real

boolean-parameter Il parametro relativo è un tipo Boolean

string-parameter Il parametro relativo è un tipo String

First L'istruzione è il primo elemento nell'elenco.

last L'istruzione è l’ultimo elemento nell'elenco.

14.5 Funzioni
14.5.1 Funzione Principale
La sezione Main (funzione) segna l'inizio dell'esecuzione del programma. La sintassi esatta di
questa funzione può essere molto utile tra i linguaggi di programmazione. A volte, il blocco
delle istruzioni viene lasciato fuori dalle definizioni delle funzioni e, altre volte, i parametri della
funzione principale differiscono dal resto del programma.

Esempio Java

[Main]
= public static void main(String[] args)
Text
{{
= -->BLOCK | |1
=}

© 2023 Roberto Atzori

 Paradigma di Programmazione 153

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell'output.

Campi

Nessuno

Il primo e l'ultimo flag possono essere utilizzati se la sintassi differisce per la prima o l'ultima
istruzione nel blocco.

Flags

Nessuno (tranne che per i Flags Globali 132 )

Per inserire il blocco della struttura While, si utilizza una singola riga contenente i seguenti
codici speciali. Se si vuole vuole cambiare l’indentazione del blocco, assicurasi di specificare
l’indentazione dopo il secondo simbolo pipe ‘|’.

Valore speciale Cosa fa

-->BLOCK Inserisce il codice generato dal

blocco della funzione.

14.5.2 Parametri
La sezione Parameter è usata per generare una lista di parametri da usare nelle sezioni
[Function] e [Function Header].

Esempio Java

[Parameter]
Separator = ,{space}
Text = {type} {name} | ~array
= {type}[] {name} | array

[Link] La chiave ‘Separator’

La chiave Separator definisce il testo che verrà inserito tra l'elenco dei nomi degli argomenti.

Campi

© 2023 Roberto Atzori

 154 Flowgorithm

Nessuno

Flags

Nessuno

[Link] La chiave ‘Text’

La chiave di testo è usata per generare la sintassi della lista degli argomenti.

Campi Contenuti

{Type} Il tipo di dati del parametro.

{Name} Il nome del parametro.

Il primo e l'ultimo flag possono essere utilizzati se la sintassi differisce per la prima o l'ultima
istruzione nel blocco.

Flag Da utilizzare quando ….

integer L’espressione è un intero

real L’espressione è un reale

boolean L’espressione è un boolean

string L’espressione è una stringa

none L'espressione non ha un tipo noto, ovvero non dichiarato.

Questo è buono per una sintassi "predefinita".

First L'istruzione è il primo elemento nell'elenco.

last L'istruzione è l’ultimo elemento nell'elenco.

© 2023 Roberto Atzori

 Paradigma di Programmazione 155

14.5.3 Funzioni
I modelli contengono diverse sezioni per creare la sintassi per le funzioni. Questi includono
tutte le funzioni ad eccezione della funzione Main. A volte la funzione principale richiede un
formato molto specifico o dichiarazioni speciali (per impostare il programma). Main è definito
in un'altra sezione.

Esempio Java

[Function]
Tex
= public static {type} {name}({parameters}) {{ | return
t
= public static void {name}({parameters}) {{ | ~return
= -->BLOCK | |1
= | return |1
= return {return}; | return |1
=}

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi della dichiarazione di funzione.

Campi Contenuti

{Type} Il tipo di dato restituito dalla funzione.

{Name} Il nome della funzione.

{Parameters} Il testo creato dalla sezione [Parameter] 153

{Return} Il nome della variabile restituita

Flag Da utilizzare quando ….

declare La funzione necessita che vengano dichiarate delle variabili. Questo

è utile se il linguaggio di programmazione di destinazione richiede
una sezione 'Variable Header’ (ad esempio il linguaggio di
programmazione Pascal)

parameters La funzione ha 1 o più parametri

return La funzione restituisce un valore

© 2023 Roberto Atzori

 156 Flowgorithm

Per inserire il blocco della funzione (corpo della funzione), si usa una riga singola contenente i
seguenti codici speciali. Se si vuole cambiare l’indentazione del blocco, assicurarsi di specificare
l’indentazione dopo il secondo carattere pipe ‘|’.

Valore speciale Cosa fa

-->BLOCK Inserisce il codice generato dal blocco della funzione.

-->VARIABLES Inserisce il codice generato dalla zona Variable Headers.

14.5.4 Intestazione di Funzione

Alcuni linguaggi di programmazione richiedono che le funzioni vengano dichiarate all'inizio di
un programma. Questo è il caso dei linguaggi di programmazione Pascal e C++.

La sezione [Funcion Header] utilizza il testo generato dalla sezione [Parameter] 153 . È usata
anche nella sezione [Function] 152 .

Esempio C++

[Function Header]
Text = {type} {name}({parameters}); | return
= void {name}({parameters}); | ~return

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi della dichiarazione di funzione.

Campi Contenuti

{Type} Il tipo di dato restituito dalla funzione.

{Name} Il nome della funzione.

{Parameters} Il testo creato dalla sezione [Parameter] 153

{Return} Il nome della variabile restituita

Flag Da utilizzare quando ….

© 2023 Roberto Atzori

 Paradigma di Programmazione 157

declare La funzione necessita che vengano dichiarate delle variabili. Questo

è utile se il linguaggio di programmazione di destinazione richiede
una sezione 'Variable Header’ (ad esempio il linguaggio di
programmazione Pascal)

parameters La funzione ha 1 o più parametri

return La funzione restituisce un valore

14.5.5 Intestazione di Variabile

Alcuni linguaggi di programmazione richiedono che le variabili vengano dichiarate all'inizio della
funzione e/o del programma. In questi linguaggi esiste una chiara distinzione tra la
dichiarazione delle variabili e codice che fa uso di queste ultime. Questo è il caso, ad esempio,
del linguaggio di programmazione Pascal.

La sezione Variable Header usa lo stesso metodo utilizzato per generare un elenco di variabili.
Vengono inserite nelle funzioni usando il valore speciale ---> VARIABLES.

Esempio Pascal

[Variable Header Name]

Separator = ,{space}
Text = {name}

[Variable Header]
Text = {variables} : array of {type}; | array
= {variables} : {type}; ~array

[Link] La sezione ‘Variable Header Name’

Questa sezione viene utilizzata per generare un elenco di nomi di variabili che verranno
utilizzati, in seguito, nella sezione [Variable Header].

La chiave ‘Separator’
La chiave definisce il testo che verrà inserito tra l'elenco dei nomi delle variabili.

Campi

Nessuno

© 2023 Roberto Atzori

 158 Flowgorithm

Flags

Nessuno

La chiave ‘Text’
La chiave ‘Text’viene utilizzata per generare la sintassi di ciascun elemento nell'elenco. La
variabile {size} contiene un valore valido se l'istruzione Declare è un Array. Utilizzare il flag
'array' per una corretta sintassi.

Campi Contenuti

{Type} Il tipo di dato della variabile.

{Name} Il nome della variabile.

{Size} La dimensione dell’array.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

array Nella dichiarazione si vuole utilizzare un array

First L'istruzione è il primo elemento nell'elenco.

last L'istruzione è l’ultimo elemento nell'elenco.

[Link] La sezione ‘Declare’

La sezione ‘Declare’ viene utilizzata per creare la sintassi per la dichiarazione.

La chiave ‘Text’
La chiave ‘Text’ viene utilizzata per generare la sintassi di ciascun elemento nell'elenco. La
variabile {size} contiene un valore valido se l'istruzione Declare è un array. Utilizzare il flag
'array' per una corretta sintassi.

Campi Contenuti

© 2023 Roberto Atzori

 Paradigma di Programmazione 159

{Type} Il tipo di dato della variabile.

{Name} Il nome della variabile.

{Size} La dimensione dell’array.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

array Nella dichiarazione si vuole utilizzare un array

First L'istruzione è il primo elemento nell'elenco.

last L'istruzione è l’ultimo elemento nell'elenco.

La chiave ‘Name Mode’

La chiave ‘Name Mode’ può contenere due valori diversi:

1. Separate (predefinita)

2. Merged

Quando è impostata a Merged, tutti i nomi delle variabili saranno uniti in un'unica lista. In
questo caso, i campi {size} e {type} non hanno senso.

Campi

Nessuno

Flags

Nessuno

14.6 Istruzioni

© 2023 Roberto Atzori

 160 Flowgorithm

14.6.1 Assegnazione
I modelli utilizzano una singola sezione per definire la sintassi delle dichiarazioni di
assegnazione. La sintassi dell'espressione assegnata è definita dalle sezioni operatore /
funzione.

Esempio Java

[Assign]
Text = {Variable} = {Expression};

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi di ciascun elemento nell'elenco.

Campi Contenuti

{variable} Nome della variabile. Questa è definita nella sezione [Variable Access].

{expression} L'espressione. La sintassi è generata dalle varie sezioni di funzione o di

espressione.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

array Nella dichiarazione si vuole utilizzare un array

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

14.6.2 Chiamata
I modelli utilizzano una singola sezione per definire la sintassi delle istruzioni di chiamata.

Esempio Java

[Call]
Text = {Name}({Arguments});

© 2023 Roberto Atzori

 Paradigma di Programmazione 161

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Output.

Campi Contenuti

{Name} Nome della funzione.

{Arguments} Elenco creato utilizzando la sezione [Argument]. Vuoto se la chiamata

non contiene argomenti. Utilizza il flag Arguments per la
individuazione.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

array Nella dichiarazione si vuole utilizzare un array

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

14.6.3 Commento
I commenti hanno un ruolo essenziale nella documentazione di un programma. La sintassi dei
commenti varia notevolmente tra i linguaggi di programmazione con la presenza del commento
di riga (in liea) o la presenza del blocco commento.

I blocchi di commento possono causare problemi se il commento contiene l'elemento sintattico

che termina il blocco. Di conseguenza, i commenti dei modelli supportano anche la logica di
sostituzione dei caratteri della stringa testuale.

Esempio Java

[Comment]
Text = // {Text}

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi della stringa testuale. Il campo {text}
contiene una sequenza di caratteri dopo che la stringa originale è stata modificata dalle varie
chiavi di sostituzione.

© 2023 Roberto Atzori

 162 Flowgorithm

Campi Contenuti

{text} I caratteri del commento

Flags

Nessuno

[Link] La chiave ‘Replace’

Le stringhe testuali possono contenere fino a 3 coppie di caratteri sostitutivi. Ad esempio, in
Pascal, i commenti di blocco iniziano con un simbolo ‘{‘ e terminano con ‘}’. Nell'esempio
seguente, tutte le occorrenze di ‘}’ saranno sostituite da nulla (cioè verranno rimosse).

Esempio Pascal

[Comment]
Text = {{ {Text} }
Replace Char 1 =}
Replace By 1 =

Campi

Nessuno

Flags

Nessuno

14.6.4 Dichiarazione
Esistono due sezioni utilizzate per creare la sintassi per le istruzioni di dichiarazione. Questi
definiscono la sintassi della lista dei nomi delle variabili (dichiarati) e la sintassi della
dichiarazione stessa.

Esempio Java

[Declare Name]

© 2023 Roberto Atzori

 Paradigma di Programmazione 163

Separator = ,{space}
Text = {name} | ~array
= {name} = new {Type}[{Size}] | array
[Declare]
Text = {Type} {Variables}; | ~array
= {Type}[] {Variables}; | array

[Link] Sezione 'Declare Name'

Questa sezione viene utilizzata per generare un elenco di nomi di variabili che verranno
utilizzati, in seguito, nella sezione [Declare].

La chiave ‘Separator’

Campi

Nessuno

Flags

Nessuno

La chiave ‘Text’

Campi Contenuti

{type} Il tipo del dato della variabile

{name} Il nome della variabile

{size} La dimensione dell’array

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

array Nella dichiarazione si vuole utilizzare un array

© 2023 Roberto Atzori

 164 Flowgorithm

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

[Link] Sezione 'Declare'

La Sezione 'Declare' viene utilizzata per creare la sintassi per un'istruzione di dichiarazione.

La chiave ‘Text’
La chiave ‘Text’ viene utilizzata per generare la sintassi di ciascun elemento nell'elenco. La
variabile {size} contiene un valore valido se l'istruzione Declare è un array. Usare il flag 'array'
per una corretta sintassi.

Campi Contenuti

{variables} I nomi delle variabili generati nella sezione [Declare Name]

{type} Il nome del tipo di dato

{size} La grandezza dell’array

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

array Nella dichiarazione si vuole utilizzare un array

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

La chiave ‘Name Mode’

Questa chiave opzionale può essere impostata su singolare o combinata (impostazione
predefinita). Se impostato su 'Singolare' verrà generata una dichiarazione di dichiarazione per
ciascun nome individualmente. In questo caso, viene compilato l'attributo {Nome}, per la chiave
di testo, anziché {Variabili}.

Esempio Pascal

© 2023 Roberto Atzori

 Paradigma di Programmazione 165

[Declare]
Name Mode = Singular
Text SetLength({Name}, {Size}); |array

14.6.5 Struttura ‘Do’

I modelli usano una singola sezione per definire la sintassi per la struttura Do. Si utilizza un
codice speciale per indicare dove viene inserito il blocco per la struttura Do.

Le seguenti definizioni provengono da una versione semplificata del modello Java Programming
Language. Notare che ognuno dei sotto blocchi aumenta l’indentazione di 1.

Esempio Java

[Do]
Text = do {{
= -->BLOCK || 1
= } while({condition});

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Output.

Campi Contenuti

{condition} L'espressione condizionale. La sintassi è generata dalle varie sezioni

funzione / espressione.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

block Il valore speciale contiene uno o più elementi

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

© 2023 Roberto Atzori

 166 Flowgorithm

Per inserire il blocco della struttura Do, si utilizza una riga singola contenente i seguenti valori
speciali. Se si vuole cambiare l’indentazione del blocco, assicurarsi di specificare l’indentazione
dopo il secondo simbolo pipe ‘|’.

Valore speciale Cosa fa

-->BLOCK Inserisce il codice generato dal blocco per la struttura Do.

14.6.6 Struttura ‘For’

I modelli usano una singola sezione per definire la sintassi per la struttura For. Si utilizza un
codice speciale per indicare dove viene inserito il blocco per la struttura For.

Le seguenti definizioni provengono da una versione semplificata del modello Java Programming
Language. Notare che ognuno dei sotto blocchi aumenta l’indentazione di 1.

Esempio Java

[For]
= for ({Variable} = {Start}; {Variable} <= {End}; {Variable}++)
Text | inc, ~step
{{
= for ({Variable} = {Start}; {Variable} <= {End}; {Variable} +=
| inc, step
{step}) {{
= for ({Variable} = {Start}; {Variable} >= {End}; {Variable}--) {{ | ~inc, ~step
= for ({Variable} = {Start}; {Variable} >= {End}; {Variable} -=
| ~inc, step
{step}) {{
= -->BLOCK | |1
= end for

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Output.

Campi Contenuti

{Variable} Il nome della variabile che interviene nel ciclo

{Start} Valore iniziale del ciclo

{End} Valore finale del ciclo

{Step} Valore di incrementale del ciclo. Normalmente viene utilizzato

l’incremento pari a 1.

© 2023 Roberto Atzori

 Paradigma di Programmazione 167

Nota: non si può utilizzare un valore negativo. Usare il flag "inc" per
determinare la direzione del ciclo.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

Inc Si incrementa il ciclo (verso una direzione positiva)

step Il valore di incremento non è uguale a 1

block Il valore speciale contiene uno o più elementi

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

Per inserire il blocco della struttura For, si utilizza una riga singola contenente i seguenti valori
speciali. Se si vuole cambiare l’indentazione del blocco, assicurarsi di specificare l’indentazione
dopo il secondo simbolo pipe ‘|’.

Valore speciale Cosa fa

-->BLOCK Inserisce il codice generato dal blocco per la struttura For.

14.6.7 Struttura ‘While’

I modelli usano una singola sezione per definire la sintassi per la struttura While. Si utilizza un
codice speciale per indicare dove viene inserito il blocco per la struttura While.

Le seguenti definizioni provengono da una versione semplificata del modello Java Programming
Language. Notare che ognuno dei sotto blocchi aumenta l’indentazione di 1.

Esempio Java

[While]
Text = while({condition}) {{
= -->BLOCK | |1
=}

© 2023 Roberto Atzori

 168 Flowgorithm

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Output.

Campi Contenuti

{condition} L'espressione condizionale. La sintassi è generata dalle varie sezioni

funzione / espressione.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

Block Il valore speciale contiene uno o più elementi

First L'istruzione è il primo elemento nel blocco.

Last L'istruzione è l’ultimo elemento nel blocco.

Per inserire il blocco della struttura While, si utilizza una riga singola contenente i seguenti
valori speciali. Se si vuole cambiare l’indentazione del blocco, assicurarsi di specificare
l’indentazione dopo il secondo simbolo pipe ‘|’.

Valore speciale Cosa fa

-->BLOCK Inserisce il codice generato dal blocco per la struttura

While.

14.6.8 Struttura ‘If’

I modelli usano una singola sezione per definire la sintassi della struttura If. Usa due valori
speciali per inserire sia il blocco per il vero sia il blocco per il falso (else).

Le seguenti definizioni provengono da una versione semplificata del modello Java Programming
Language. Notare che ognuno dei sotto blocchi aumenta l’indentazione di 1.

Esempio Java

[Assign]
Text = if ({condition}) {{

© 2023 Roberto Atzori

 Paradigma di Programmazione 169

= -->TRUEBLOCK | |1
= } else {{ | else
= -->FALSEBLOCK | else |1
=}

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Output.

Campi Contenuti

{condition} L'espressione condizionale. La sintassi è generata dalle varie sezioni

funzione / espressione.

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

block Il valore speciale contiene uno o più elementi

else La struttura If ha un blocco False (Else). In altre parole, il ramo "else" del
diagramma di flusso contiene forme.

First L'istruzione è il primo elemento nel blocco.

Last L'istruzione è l’ultimo elemento nel blocco.

Per inserire il blocco della struttura If, si utilizza una riga singola contenente i seguenti valori
speciali. Se si vuole cambiare l’indentazione del blocco, assicurarsi di specificare l’indentazione
dopo il secondo simbolo pipe ‘|’.

Valore speciale Cosa fa

-->TRUEBLOCK Inserisce il codice generato dal blocco True della struttura If.

-->FALSEBLOCK Inserisce il codice generato dal blocco False (else) della

struttura If.

© 2023 Roberto Atzori

 170 Flowgorithm

14.6.9 Input
I modelli usano una singola sezione per definire la sintassi dell’istruzione Input.

Esempio Java

[Input]
Text = {Variable} = [Link](); | integer
= {Variable} = [Link](); | real
= {Variable} = [Link](); | boolean
= {Variable} = [Link](); | string
= {Variable} = [Link](); | none

[Link] La chiave ‘Text’

La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Input. I vari flag possono
essere utilizzati per selezionare diverse sintassi in base al tipo di dati letto.

Campi Contenuti

{variable} I nomi delle variabili generati nella sezione [Variable Access]

{type} Il nome del tipo di dato

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

integer La variabile è di tipo Integer.

real La variabile è di tipo Real.

boolean La variabile è di tipo Boolean.

string La variabile è di tipo String.

none La variabile non è di un tipo conosciuto. Questo è il valore predefinito.

array La variabile è un array. Alcuni linguaggi di programmazione richiedono sintassi

differenti per l’assegnazione di un elemento ad un array.

© 2023 Roberto Atzori

 Paradigma di Programmazione 171

first L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

14.6.10 Output
14.6.10.1Output
I modelli usano una singola sezione per definire la sintassi dell’istruzione Output.

Esempio Java

[Assign]
Text = [Link]({Expression}); | newline
= [Link]({Expression}); | ~newline

La chiave ‘Text’
La chiave ‘Text’ viene utilizzata per generare la sintassi dell’istruzione Output. I vari flag
possono essere utilizzati per selezionare diverse sintassi in base al tipo di dati letto.

Campi Contenuti

{expression} L'espressione. La sintassi è generata dalle varie sezioni di funzione o di

espressione.

{list} Questo testo è generato dalla sezione {Output List}

Il primo e l'ultimo Flag possono essere utilizzati se la sintassi differisce per il primo o l'ultimo
elemento nell'elenco.

Flag Da utilizzare quando ….

newline L’istruzione contempla un ritorno a capo (newline). Flag predefinito

nell’istruzione di Output

first L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

© 2023 Roberto Atzori

 172 Flowgorithm

14.6.10.2Lista Output
In molti casi, l'istruzione di output richiede un elenco di espressioni piuttosto che un lungo
elenco di termini concatenati.

Esempio C++

[Output List]
Separator = <<
Text = {expression}

Come funziona
Questa sezione crea un elenco eseguendo il ‘refactoring’ dell'espressione originale utilizzando
l'operatore di concatenazione. Vengono modificate solo le concatenazioni al livello
dell'espressione principale (l'espressione secondaria viene lasciata sola). Quindi, la seguente
espressione Flowgorithm:

"The GCD of " & NumberA & " and " & NumberB & " is " & A

verrà convertita nel seguente elenco di voci:

· "The GCD of "

· NumberA
· " and "
· NumberB
· " is "
· A

Chiave ‘Separator’
La chiave ‘ Separator’ definisce il testo che verrà inserito nell'elenco dei nomi degli argomenti.

Campi

Nessuno

Flag Da utilizzare quando ….

First L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

© 2023 Roberto Atzori

 Paradigma di Programmazione 173

Chiave ‘Text’
La chiave ‘Text’ viene utilizzata per generare la sintassi della lista.

Campi Contenuti

{expression} La sotto espressione

Flag Da utilizzare quando ….

integer La variabile è di tipo Integer.

real La variabile è di tipo Real.

boolean La variabile è di tipo Boolean.

string La variabile è di tipo String.

none La variabile non è di un tipo conosciuto. Questo è il valore predefinito.

first L'istruzione è il primo elemento nel blocco.

last L'istruzione è l’ultimo elemento nel blocco.

14.7 Esempi di Paradigma di Programmazione

14.7.1 Linguaggio di programmazione Lua
[Language]
Name = Lua
Extension = lua
Keywords = and, break , do, else, elseif, end, false, for, function, if,
= in, local, nil, not, or, repeat, return, then, true, until, while

Conflicts = index
Case Sensitive = true
Options =

; =======================================================
; Literals
; =======================================================

[Types]
Integer = number
Real = number
Boolean = boolean
String = string

[Function ID]
Convention = camel
Normal = {Name}
Conflict = func_{Name}

© 2023 Roberto Atzori

174 Flowgorithm

[Variable ID]
Convention = camel
Normal = {Name}
Conflict = var_{Name}

[String Literal]
Text = "{Characters}"
Replace Char 1 = "
Replace By 1 = \"
Replace Char 2 = \
Replace By 2 = \\

[Boolean Literal]
true = true
false = false

[Integer Literal]
Text = {Integral}

[Real Literal]
Text = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text = {Name} | ~subscript
= {Name}[{Subscript}] | subscript

; =======================================================
; Expressions
; =======================================================
; Lua precedence:
; 1. or
; 2. and
; 3. Relational ==, >, < ...
; 4. Concatenation: ..
; 5. Addition
; 6. Multiply
; 7. Unary: Not, -
; 8. ^
; 100. Atom, paranthesis

[Or]
Precedence = 1
Needed 1 = 1
Needed 2 = 2
Text = {1} or {2}

[And]
Precedence = 2
Needed 1 = 2
Needed 2 = 3
Text = {1} and {2}

[Equals]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} == {2}

[Not Equals]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} ~= {2}

[Less Than]
Precedence = 3

© 2023 Roberto Atzori

 Paradigma di Programmazione 175

Needed 1 = 4
Needed 2 = 4
Text = {1} < {2}

[Less Equal Than]

Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} <= {2}

[Greater Than]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} > {2}

[Greater Equal Than]

Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} >= {2}

[Concatenate]
Precedence = 4
Needed 1 = 4
Needed 2 = 5
Text = {1} .. {2}

[Add]
Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} + {2}

[Subtract]
Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} - {2}

[Multiply]
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} * {2}

[Divide]
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} / {2}

[Modulus]
Precedence = 1
Needed 1 = 1
Needed 2 = 1
Text = [Link]({1}, {2})

[Power]
Precedence = 8
Needed 1 = 9
Needed 2 = 8
Text = {1} ** {2}

[Not]
Precedence = 7
Needed 1 = 7
Text = not {1}

© 2023 Roberto Atzori

176 Flowgorithm

[Negate]
Precedence = 7
Needed 1 = 7
Text = -{1}

[Subexpression]
Precedence = 100
Text = ({Expression})

; =======================================================
; Intrinsic Functions
; =======================================================

[Abs]
Precedence = 100
Needed 1 = 100
Text = [Link]{1}

[ArcCos]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ArcSin]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ArcTan]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Char]
Precedence = 100
Needed 1 = 100
Needed 2 = 0
Text = [Link]({1}, index({1}), index({1})

[Cos]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Int]
Precedence = 100
Needed 1 = 100
Text = [Link]({1})

[Len]
Precedence = 100
Needed 1 = 100
Text = [Link]({1})

[Log]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Log10]
Precedence = 100
Needed 1 = 0
Text = math.log10({1})

[Pi]
Precedence = 100

© 2023 Roberto Atzori

 Paradigma di Programmazione 177

Text = [Link]

[Random]
Precedence = 100
Needed 1 = 0
Text = ([Link]({1}) - 1)

[Sin]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Sgn]
Precedence = 100
Needed 1 = 0
Text = sgn({1})

[Size]
Precedence = 100
Needed 1 = 100
Text = size({1})

[Sqrt]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Tan]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ToChar]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ToCode]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ToInteger]
Precedence = 100
Needed 1 = 0
Text = [Link](tonumber({1}))

[ToFixed]
Precedence = 100
Needed 1 = 0
Needed 2 = 0
Text = toFixed({1}, {2})

[ToReal]
Precedence = 100
Needed 1 = 0
Text = tonumber({1})

[ToString]
Precedence = 100
Needed 1 = 0
Text = tostring({1})

; =======================================================
; Function call
; =======================================================

© 2023 Roberto Atzori

178 Flowgorithm

[Function Call]
Precedence = 100
Text = {name}({arguments})

[Argument]
Separator = ,{space}
Text = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text = -- Gets the size of the array (by using the max index) | size
= function size(values) | size
= return [Link](values) + 1 | size | 1
= end | size
= | size

= -- Lua lacks a sign function. This code implements it. | sgn

= function sgn(n) | sgn
= if n == 0 then | sgn | 1
= return 0 | sgn | 2
= elseif n < 0 then | sgn | 1
= return -1 | sgn | 2
= else | sgn | 1
= return 1 | sgn | 1
= end | sgn | 1
= end | sgn |
= | sgn

= def toFixed(value, digits) | tofixed

= return [Link]("%0." .. digits .. "f", value) | tofixed | 1
= end | tofixed
= | tofixed

= -->FUNCTIONS
= -->MAIN

[Main]
Text = -- Main | functions
= [Link]([Link] ()) -- Prepare the random number generator |
random
= |
random
= -->BLOCK

; =======================================================
; Function
; =======================================================

[Function]
Text = function {name}({parameters})
= -->BLOCK | | 1
= | return | 1
= return {return} | return | 1
= end
=

[Parameter]
Separator = ,{space}
Text = {name}

; =======================================================
; Statements
; =======================================================

[Assign]
Text = {Variable} = {Expression}

© 2023 Roberto Atzori

 Paradigma di Programmazione 179

[Call]
Text = {Name} ({Arguments})

[Comment]
Text = -- {Text}

[Declare Name]
Separator = ,{space}
Text = {name} | ~array
= {Name} = {{} | array

[Declare]
Text = local {variables}

[Do]
Text = repeat
= -->BLOCK | | 1
= until not ({condition})

[For]
Text = for {Variable} = {start}, {end} do | inc, ~step
= for {Variable} = {start}, {end}, {step} do | inc, step
= for {Variable} = {start}, {end}, -{step} do | ~inc
= -->BLOCK | | 1

= end

[Input]
Text = {Variable} = tonumber([Link]()) | integer
= {Variable} = tonumber([Link]()) | real
= {Variable} = [Link]([Link]()) == "true") | boolean
= {Variable} = [Link]() | string
= {Variable} = [Link]() | none

[If]
Text = if {condition} then
= -->TRUEBLOCK | | 1
= else | else
= -->FALSEBLOCK | else | 1
= end

[Output]
Separator = ,{space}
Text = [Link]({List}, "\n") | newline
= [Link]({List}) | ~newline

[While]
Text = while {condition} do
= -->BLOCK | | 1
= end

14.7.2 Linguaggio di programmazione Java (semplificato)

[Language]
Name = Java
Extension = java
Keywords = abstract, assert, boolean, break, byte, case, catch, char, class,
const
= continue, default, double, do, else, enum, extends, false, final,
finally
= float, for, goto, if, implements, import, instanceof, int, interface,
long
= native, new, null, package, private, protected, public, return, short,
static
= strictfp, super, switch, synchronized, this, throw, throws, transient,
true, try

© 2023 Roberto Atzori

180 Flowgorithm

= void, volatile, while

Conflicts = input
Case Sensitive = true
Options =

; =======================================================
; Literals
; =======================================================

[Types]
Integer = int
Real = double
Boolean = boolean
String = String

[Function ID]
Convention = camel
Normal = {Name}
Conflict = func_{Name}

[Variable ID]
Convention = camel
Normal = {Name}
Conflict = var_{Name}

[String Literal]
Text = "{Characters}"
Replace Char 1 = "
Replace By 1 = \"
Replace Char 2 = \
Replace By 2 = \\

[Boolean Literal]
true = true
false = false

[Integer Literal]
Text = {Integral}

[Real Literal]
Text = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text = {Name} | ~subscript
= {Name}[{Subscript}] | subscript

; =======================================================
; Expressions
; =======================================================
; 1. or
; 2. and
; 3. ==
; 4. Relational >, < ...
; 5. Addition
; 6. Multiply
; 7. Cast ()
; 8. Unary: Not, !
; 100. Atom, paranthesis

[Or]
Precedence = 1
Needed 1 = 1
Needed 2 = 2
Text = {1} {pipe}{pipe} {2}

[And]

© 2023 Roberto Atzori

 Paradigma di Programmazione 181

Precedence = 2
Needed 1 = 2
Needed 2 = 3
Text = {1} && {2}

[Equals]
Precedence = 3 | ~string-string
= 100 | string-string

Needed 1 = 4 | ~string-string
= 100 | string-string

Needed 2 = 4 | ~string-string
= 1 | string-string

Text = {1} == {2} | ~string-string

= {1}.equals({2}) | string-string

[Not Equals]
Precedence = 3 | ~string-string
= 100 | string-string

Needed 1 = 4 | ~string-string
= 100 | string-string

Needed 2 = 4 | ~string-string
= 1 | string-string

Text = {1} != {2} | ~string-string

= !{1}.equals({2}) | string-string

[Less Than]
Precedence = 4

Needed 1 = 5 | ~string-string
= 100 | string-string

Needed 2 = 5 | ~string-string
= 1 | string-string

Text = {1} < {2} | ~string-string

= {1}.compareTo({2}) < 0 | string-string

[Less Equal Than]

Precedence = 4

Needed 1 = 5 | ~string-string
= 100 | string-string

Needed 2 = 5 | ~string-string
= 1 | string-string

Text = {1} <= {2} | ~string-string

= {1}.compareTo({2}) <= 0 | string-string

[Greater Than]
Precedence = 4

Needed 1 = 5 | ~string-string
= 100 | string-string

Needed 2 = 5 | ~string-string
= 1 | string-string

Text = {1} > {2} | ~string-string

= {1}.compareTo({2}) > 0 | string-string

[Greater Equal Than]

Precedence = 4

© 2023 Roberto Atzori

182 Flowgorithm

Needed 1 = 5 | ~string-string
= 100 | string-string

Needed 2 = 5 | ~string-string
= 1 | string-string

Text = {1} >= {2} | ~string-string

= {1}.compareTo({2}) >= 0 | string-string

[Concatenate]
Precedence = 5

Needed 1 = 5 | string-1
= 1 | ~string-1
Needed 2 = 6

Text = {1} + {2} | string-1

= [Link]({1}) + {2} | integer-1
= [Link]({1}) + {2} | real-1
= [Link]({1}) + {2} | boolean-1

[Add]
Type = real | ~integer-integer
= integer | integer-integer

Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} + {2}

[Subtract]
Type = real | ~integer-integer
= integer | integer-integer

Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} - {2}

[Multiply]
Type = real | ~integer-integer
= integer | integer-integer

Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} * {2}

[Divide]
Type = real
Precedence = 6
Needed 1 = 6 | ~integer-integer
= 100 | integer-integer

Needed 2 = 7
Text = {1} / {2} | ~integer-integer
= (double) {1} / {2} | integer-integer

[Modulus]
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} % {2}

[Power]
Type = real
Precedence = 100

© 2023 Roberto Atzori

 Paradigma di Programmazione 183

Needed 1 = 0
Needed 2 = 0
Text = [Link]({1}, {2})

[Not]
Type = boolean
Precedence = 7
Needed 1 = 7
Text = !{1}

[Negate]
Type = real | ~integer
= integer | integer

Precedence = 7
Needed 1 = 7
Text = -{1}

[Subexpression]
Precedence = 100
Text = ({Expression})

; =======================================================
; Intrinsic Functions
; =======================================================

[Abs]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ArcCos]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ArcSin]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ArcTan]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Char]
Precedence = 100
Needed 1 = 100
Needed 2 = 0
Text = {1}.charAt({2})

[Cos]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Int]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Len]
Precedence = 100
Needed 1 = 100
Text = {1}.length()

© 2023 Roberto Atzori

184 Flowgorithm

[Log]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Log10]
Precedence = 100
Needed 1 = 0
Text = Math.log10({1})

[Pi]
Precedence = 100
Text = [Link]

[Random]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Sin]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Sgn]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Size]
Precedence = 100
Needed 1 = 100
Text = {1}.length

[Sqrt]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[Tan]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ToChar]
Precedence = 100
Needed 1 = 100
Text = (char) {1}

[ToCode]
Precedence = 100
Needed 1 = 100
Text = (int) {1}[0]

[ToFixed]
Type = string
Precedence = 100
Needed 1 = 0
Needed 2 = 0
Text = toFixed({1},{2})

[ToInteger]
Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ToReal]

© 2023 Roberto Atzori

 Paradigma di Programmazione 185

Precedence = 100
Needed 1 = 0
Text = [Link]({1})

[ToString]
Precedence = 100
Needed 1 = 100
Text = {1}.toString()

; =======================================================
; Function call
; =======================================================

[Function Call]
Precedence = 100
Text = {name}({arguments})

[Argument]
Separator = ,{space}
Text = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text = import [Link].*;
= import [Link];
=
= public class JavaApplication {{
= private static Random random = new Random(); | random
| 1
= private static Scanner input = new Scanner([Link]); | input
| 1
= | random,
~input
= | ~random,
input
= | random,
input
= -->MAIN |
| 1
= -->FUNCTIONS |
| 1
= | tofixed
| 1
= private static String toFixed(double value, int digits) {{ | tofixed
| 1
= return [Link]("%." + digits + "f", value); | tofixed
| 2
= } | tofixed
| 1
= }

[Main]
Text = public static void main(String[] args) {{
= -->BLOCK | |
1
= }

; =======================================================
; Function
; =======================================================

[Parameter]
Separator = ,{space}
Text = {type} {name} | ~array
= {type}[] {name} | array

© 2023 Roberto Atzori

186 Flowgorithm

[Function]
Text =
= public static {type} {name}({parameters}) {{ | return
= public static void {name}({parameters}) {{ | ~return
= -->BLOCK | | 1
= | return | 1
= return {return}; | return | 1
= }

; =======================================================
; Statements
; =======================================================

[Assign]
Text = {Variable} = {Expression};

[Call]
Text = {Name}({Arguments});

[Comment]
Text = // {Text}

[Declare Name]
Separator = ,{space}
Text = {name} | ~array
= {name} = new {Type}[{Size}] | array

[Declare]
Text = {Type} {Variables}; | ~array
= {Type}[] {Variables}; | array

[Do]
Text = do {{
= -->BLOCK | | 1
= } while ({condition});

[For]
Text = for ({Variable} = {Start}; {Variable} <= {End}; {Variable}++)
{{ | inc, ~step
= for ({Variable} = {Start}; {Variable} <= {End}; {Variable} += {step})
{{ | inc, step
= for ({Variable} = {Start}; {Variable} >= {End}; {Variable}--)
{{ | ~inc, ~step
= for ({Variable} = {Start}; {Variable} >= {End}; {Variable} -= {step})
{{ | ~inc, step
= -->BLOCK
| | 1
= }

[Input]
Text = {Variable} = [Link](); | integer
= {Variable} = [Link](); | real
= {Variable} = [Link](); | boolean
= {Variable} = [Link](); | string
= {Variable} = [Link](); | none

[If]
Text = if ({condition}) {{
= -->TRUEBLOCK | | 1
= } else {{ | else
= -->FALSEBLOCK | else | 1
= }

[Output]
Text = [Link]({Expression}); | newline
= [Link]({Expression}); | ~newline

[While]
Text = while ({condition}) {{
= -->BLOCK | | 1

© 2023 Roberto Atzori

 Paradigma di Programmazione 187

= }

14.7.3 Linguaggio di programmazione Pascal

[Language]
Name = Pascal
Extension = pas

Keywords = and, array, as, asm, begin, case, class, const, constructor,
destructor
= dispinterface, div, do, downto, else, end, except, exports, file,
finalization
= finally, for, function, goto, if, implementation, in, inherited,
initialization, interface
= in, is, library, nil, not, object, of, or, out, packed
= procedure, program, property, raise, randomize, record, repeat,
resourcestring, set
= string, then, to, try, type, unit, until, uses, var, while, with

Conflicts =

Case Sensitive = false

Options =

; =======================================================
; Literals
; =======================================================

[Types]
Integer = integer
Real = real
Boolean = boolean
String = string

[Function ID]
Convention = proper
Normal = {Name}
Conflict = {Name}_function

[Variable ID]
Convention = proper
Normal = {Name}
Conflict = {Name}_variable

[String Literal]
Text = '{Characters}'
Replace Char 1 = '
Replace By 1 = ''

[Boolean Literal]
true = true
false = false

[Integer Literal]
Text = {Integral}

[Real Literal]
Text = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text = {Name} | ~subscript
= {Name}[{Subscript}] | subscript

; =======================================================
; Expressions

© 2023 Roberto Atzori

188 Flowgorithm

; =======================================================
; Pascal precedence: (ONLY FOUR)
; 1. Comparison: =, <>, <, >, <=, >=
; 2. Addition & Or: +, -, or, xor
; 3. Multiply & And: *, /, mod, and
; 4. Not: not
; 100. Atom, paranthesis

[Or]
Precedence = 3
Needed 1 = 3
Needed 2 = 4
Text = {1} or {2}

[And]
Precedence = 3
Needed 1 = 3
Needed 2 = 4
Text = {1} and {2}

[Equals]
Precedence = 1
Needed 1 = 2
Needed 2 = 2
Text = {1} = {2}

[Not Equals]
Precedence = 1
Needed 1 = 2
Needed 2 = 2
Text = {1} <> {2}

[Less Than]
Precedence = 1
Needed 1 = 2
Needed 2 = 2
Text = {1} < {2}

[Less Equal Than]

Precedence = 1
Needed 1 = 2
Needed 2 = 2
Text = {1} <= {2}

[Greater Than]
Precedence = 1
Needed 1 = 2
Needed 2 = 2
Text = {1} > {2}

[Greater Equal Than]

Precedence = 1
Needed 1 = 2
Needed 2 = 2
Text = {1} >= {2}

[Concatenate]
Precedence = 2
Needed 1 = 2 | string-1
= 1 | ~string-1

Needed 2 = 3 | string-2
= 1 | ~string-2

Text = {1} + {2} | string-1, string-2

= FloatToStr({1}) + {2} | ~string-1, string-2
= {1} + FloatToStr({2}) | string-1, ~string-2
= FloatToStr({1}) + FloatToStr({2}) | ~string-1, ~string-2

© 2023 Roberto Atzori

 Paradigma di Programmazione 189

[Add]
Precedence = 2
Needed 1 = 2
Needed 2 = 3
Text = {1} + {2}

[Subtract]
Precedence = 2
Needed 1 = 2
Needed 2 = 3
Text = {1} - {2}

[Multiply]
Precedence = 3
Needed 1 = 3
Needed 2 = 4
Text = {1} * {2}

[Divide]
Precedence = 3
Needed 1 = 3
Needed 2 = 4
Text = {1} / {2}

[Modulus]
Precedence = 3
Needed 1 = 3
Needed 2 = 4
Text = {1} mod {2}

[Power]
Precedence = 100
Needed 1 = 1
Needed 2 = 1
Text = Power({1}, {2})

[Not]
Precedence = 4
Needed 1 = 4
Text = Not {1}

[Negate]
Precedence = 4
Needed 1 = 4
Text = -{1}

[Subexpression]
Precedence = 100
Text = ({Expression})

; =======================================================
; Intrinsic Functions
; =======================================================

[Abs]
Precedence = 100
Needed 1 = 1
Text = Abs({1})

[ArcCos]
Precedence = 100
Needed 1 = 1
Text = ArcCos({1})

[ArcSin]
Precedence = 100

© 2023 Roberto Atzori

190 Flowgorithm

Needed 1 = 1
Text = ArcSin({1})

[ArcTan]
Precedence = 100
Needed 1 = 1
Text = ArcTan({1})

[Char]
Precedence = 100
Needed 1 = 100
Needed 2 = 1
Text = {1}[{2}]

[Cos]
Precedence = 100
Needed 1 = 1
Text = Cos({1})

[Int]
Precedence = 100
Needed 1 = 1
Text = Int({1})

[Len]
Precedence = 100
Needed 1 = 1
Text = Length({1})

[Log]
Precedence = 100
Needed 1 = 1
Text = Log({1})

[Log10]
Precedence = 100
Needed 1 = 1
Text = Log10({1})

[Pi]
Precedence = 100
Text = Pi

[Random]
Precedence = 100
Needed 1 = 1
Text = Random({1})

[Sin]
Precedence = 100
Needed 1 = 1
Text = Sin({1})

[Sgn]
Precedence = 100
Needed 1 = 1
Text = Sgn({1})

[Size]
Precedence = 100
Needed 1 = 1
Text = Length({1})

[Sqrt]
Precedence = 100
Needed 1 = 1
Text = Sqrt({1})

© 2023 Roberto Atzori

 Paradigma di Programmazione 191

[Tan]
Precedence = 100
Needed 1 = 1
Text = Tan({1})

[ToChar]
Precedence = 100
Needed 1 = 1
Text = Chr({1})

[ToCode]
Precedence = 100
Needed 1 = 1
Text = Ord({1})

[ToFixed]
Precedence = 100
Needed 1 = 1
Needed 2 = 1
Text = ToFixed({1}, {2})

[ToInteger]
Precedence = 100
Needed 1 = 1
Text = StrToInt({1})

[ToReal]
Precedence = 100
Needed 1 = 1
Text = StrToFloat({1})

[ToString]
Precedence = 100
Needed 1 = 1
Text = FloatToStr({1})

; =======================================================
; Function call
; =======================================================

[Function Call]
Precedence = 100
Text = {name}({arguments})

[Argument]
Separator = ,{space}
Text = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text = program MyProgram;
= uses Math, SysUtils;

= | functions
= {{ Headers } | functions
= -->HEADERS | functions

= -->FUNCTIONS
= -->MAIN

[Main]
Text = | functions
= {{ Main } | functions

© 2023 Roberto Atzori

192 Flowgorithm

= var | declare
= -->VARIABLES | declare | 1
= | declare
= begin
= randomize; {{Prepare the random number generator} | random | 1
= | random
= -->BLOCK | | 1
= end.

; =======================================================
; Function
; =======================================================

[Parameter]
Separator = ,{space}
Text = {name} : {type} | ~array
= var {name} : array of {type} | array

[Function]
Block Extra = 1 | return
= 0 | ~return

Text =
= procedure {name} ({parameters}); | ~return
= var | ~return, declare
= -->VARIABLES | ~return, declare | 1
= | ~return, declare
= begin | ~return
= -->BLOCK | ~return | 1
= end; | ~return

= function {name} ({parameters}) : {type}; | return

= var | return, declare
= -->VARIABLES | return, declare | 1
= | return, declare
= begin | return
= -->BLOCK | return | 1
= | return | 1
= {name} := {return} | return | 1
= end; | return

[Function Header]
Text = procedure {name} ({parameters}); forward; | ~return
= function {name} ({parameters}) : {type}; forward; | return

; =======================================================
; Variable Header
; =======================================================

[Variable Header Name]

Separator = ,{space}
Text = {name}

[Variable Header]
Text = {variables} : array of {type}; | array
= {variables} : {type}; | ~array

; =======================================================
; Statements
; =======================================================

[Assign]
Text = {Variable} := {Expression}; | ~last
= {Variable} := {Expression} | last

[Call]
Text = {Name} ({Arguments}); | ~last
= {Name} ({Arguments}) | last

© 2023 Roberto Atzori

 Paradigma di Programmazione 193

[Comment]
Replace Char 1 = }
Replace By 1 =
Text = {{ {Text} }

[Declare Name]
Separator = ,{space}
Text = {name}

[Declare]
Name Mode = Singular
Text = SetLength({Name}, {Size}); | array, ~last
= SetLength({Name}, {Size}) | array, last

[Do]
Text = repeat
= begin
= -->BLOCK | | 1
= end
= until not ({condition}); | ~last
= until not ({condition}) | last

[For]
Text = For {Variable} := {Start} to {End} do | ~step, inc
= For {Variable} := {Start} downto {End} do | ~step, ~inc
= begin | ~step
= -->BLOCK | ~step |
1
= end; | ~step, ~last
= end | ~step, last

= {Variable} := {Start}; | step

= while {Variable} <= {End} do | step, inc
= while {Variable} >= {End} do | step, ~inc
= begin | step
= -->BLOCK | step | 1

= | step
= {Variable} := {Variable} + {Step}; | step, inc
= {Variable} := {Variable} - {Step}; | step, ~inc
= end; | step, ~last
= end | step, last

[Input]
Text = ReadLn({Variable}); | ~last
= ReadLn({Variable}) | last
[If]
Text = if {condition} then
= begin
= -->TRUEBLOCK | | 1

= end | else
= else | else
= begin | else
= -->FALSEBLOCK | else | 1

= end; | ~last
= end | last

[Output]
Text = WriteLn({Expression}); | newline, ~last
= Write({Expression}); | ~newline, ~last

= WriteLn({Expression}) | newline, last

= Write({Expression}) | ~newline, last

[While]

© 2023 Roberto Atzori

 194 Flowgorithm

Text = while {condition} do

= begin
= -->BLOCK | | 1

= end; | ~last
= end | last

14.7.4 Linguaggio di programmazione Python

[Language]
Name = Python
Extension = py
Keywords = and, as, assert, break, class, continue, def, del, elif, else
= except, exec, finally, for, from, global, if, import, in, is
= lambda, not, or, pass, print, raise, return, try, while, with
= yield

= True, False, None

Conflicts
Case Sensitive = true
Options =

; =======================================================
; Literals
; =======================================================

[Types]
Integer = int
Real = float
Boolean = bool
String = str

[Function ID]
Convention = camel
Normal = {Name}
Conflict = func_{Name}

[Variable ID]
Convention = camel
Normal = {Name}
Conflict = var_{Name}

[String Literal]
Text = "{Characters}"
Replace Char 1 = "
Replace By 1 = \"
Replace Char 2 = \
Replace By 2 = \\

[Boolean Literal]
true = True
false = False

[Integer Literal]
Text = {Integral}

[Real Literal]
Text = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text = {Name} | ~subscript
= {Name}[{Subscript}] | subscript

; =======================================================

© 2023 Roberto Atzori

 Paradigma di Programmazione 195

; Expressions
; =======================================================
; Python precedence:
; 1. or
; 2. and
; 3. not
; 4. Relational and equality: =, >, < ...
; 5. Addition
; 6. Multiply
; 7. Unary: -
; 8. **
; 100. Atom, paranthesis

[Or]
Precedence = 1
Needed 1 = 1
Needed 2 = 2
Text = {1} or {2}

[And]
Precedence = 2
Needed 1 = 2
Needed 2 = 3
Text = {1} and {2}

[Equals]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} == {2}

[Not Equals]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} != {2}

[Less Than]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} < {2}

[Less Equal Than]

Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} <= {2}

[Greater Than]
Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} > {2}

[Greater Equal Than]

Precedence = 3
Needed 1 = 4
Needed 2 = 4
Text = {1} >= {2}

[Concatenate]
Precedence = 5

Needed 1 = 5 | string-1
= 1 | ~string-1

Needed 2 = 6 | string-2

© 2023 Roberto Atzori

196 Flowgorithm

= 1 | ~string-2

Text = {1} + {2} | string-1, string-2

= {1} + str({2}) | string-1, ~string-2
= str({1}) + {2} | ~string-1, string-2
= str({1}) + str({2}) | ~string-1, ~string-2

[Add]
Type = real | ~integer-integer
= integer | integer-integer

Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} + {2}

[Subtract]
Type = real | ~integer-integer
= integer | integer-integer

Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} - {2}

[Multiply]
Type = real | ~integer-integer
= integer | integer-integer

Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} * {2}

[Divide]
Type = real
Precedence = 6
Needed 1 = 6 | ~integer-integer
= 1 | integer-integer

Needed 2 = 7
Text = {1} / {2} | ~integer-integer
= float({1}) / {2} | integer-integer

[Modulus]
Type = integer
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} % {2}

[Power]
Type = real
Precedence = 8
Needed 1 = 9
Needed 2 = 8
Text = {1} ** {2}

[Not]
Type = boolean
Precedence = 3
Needed 1 = 3
Text = not {1}

[Negate]
Type = real | ~integer
= integer | integer

© 2023 Roberto Atzori

 Paradigma di Programmazione 197

Precedence = 7
Needed 1 = 7
Text = -{1}

[Subexpression]
Precedence = 100
Text = ({Expression})

; =======================================================
; Intrinsic Functions
; =======================================================

[Abs]
Precedence = 100
Needed 1 = 0
Text = fabs({1})

[ArcCos]
Precedence = 100
Needed 1 = 0
Text = acos({1})

[ArcSin]
Precedence = 100
Needed 1 = 0
Text = asin({1})

[ArcTan]
Precedence = 100
Needed 1 = 0
Text = atan({1})

[Char]
Precedence = 100
Needed 1 = 100
Needed 2 = 0
Text = {1}[{2}]

[Cos]
Precedence = 100
Needed 1 = 0
Text = cos({1})

[Int]
Precedence = 100
Needed 1 = 0
Text = int({1})

[Len]
Precedence = 100
Needed 1 = 0
Text = len({1})

[Log]
Precedence = 100
Needed 1 = 0
Text = log({1})

[Log10]
Precedence = 100
Needed 1 = 0
Text = log10({1})

[Pi]
Precedence = 100
Text = [Link]

© 2023 Roberto Atzori

198 Flowgorithm

[Random]
Precedence = 100
Needed 1 = 6
Text = int([Link]() * {1})

[Sin]
Precedence = 100
Needed 1 = 0
Text = sin({1})

[Sgn]
Precedence = 100
Needed 1 = 0
Text = sgn({1})

[Size]
Precedence = 100
Needed 1 = 0
Text = len({1})

[Sqrt]
Precedence = 100
Needed 1 = 0
Text = sqrt({1})

[Tan]
Precedence = 100
Needed 1 = 0
Text = tan({1})

[ToChar]
Precedence = 100
Needed 1 = 0
Text = chr({1})

[ToCode]
Precedence = 100
Needed 1 = 0
Text = ord({1})

[ToInteger]
Precedence = 100
Needed 1 = 0
Text = int({1})

[ToFixed]
Type = string
Precedence = 100
Needed 1 = 0
Needed 2 = 0
Text = toFixed({1},{2})

[ToReal]
Precedence = 100
Needed 1 = 0
Text = float({1})

[ToString]
Precedence = 100
Needed 1 = 0
Text = str({1})

; =======================================================
; Function call
; =======================================================

[Function Call]

© 2023 Roberto Atzori

 Paradigma di Programmazione 199

Precedence = 100
Text = {name}({arguments})

[Argument]
Separator = ,{space}
Text = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text = import random | random
= | random

= # Python lacks a sign function. This code implements it. | sgn

= def sgn(n): | sgn
= if n == 0: return 0 | sgn | 1
= elif n < 0: return -1 | sgn | 1
= else: return 1 | sgn | 1
= | sgn

= def toFixed(value, digits): | tofixed

= return "%.*f" % (digits, value) | tofixed | 1
= | tofixed

= -->FUNCTIONS
= -->MAIN

[Main]
Text = # Main | functions

= [Link]() #Prepare random number generator | random

= -->BLOCK

; =======================================================
; Function
; =======================================================

[Function]
Text = def {name}({parameters}):
= -->BLOCK | | 1
= pass | ~block | 1
= | return | 1
= return {return} | return | 1
=

[Parameter]

Separator = ,{space}
Text = {name}

; =======================================================
; Statements
; =======================================================

[Assign]
Text = {Variable} = {Expression}

[Call]
Text = {Name} ({Arguments})

[Comment]
Text = # {Text}

[Declare Name]
Separator = ,{space}
Text = {name}

© 2023 Roberto Atzori

 200 Flowgorithm

[Declare]
Name mode = Singular

Text = {Name} = [0] * ({Size}) | Array, integer

= {Name} = [0] * ({Size}) | Array, real
= {Name} = [""] * ({Size}) | Array, string
= {Name} = [False] * ({Size}) | Array, boolean
= {Name} = [] * ({Size}) | Array, none
[Do]
Text = while True: #This simulates a Do Loop
= -->BLOCK || 1
= if not({condition}): break #Exit loop || 1

[For]
Text = for {Variable} in range({start}, {end} + {step}, {step}): | inc
= for {Variable} in range({start}, {end} - {step}, -{step}): | ~inc
= -->BLOCK | | 1

= pass | ~block | 1

[Input]
Text = {Variable} = int(input()) | integer
= {Variable} = float(input()) | real
= {Variable} = (input().lower == 'true') | boolean
= {Variable} = input() | string
= {Variable} = input() | none

[If]
Text = if {condition}:
= -->TRUEBLOCK | | 1
= pass | ~block | 1
= else: | else
= -->FALSEBLOCK | else | 1

[Output]
Text = print({Expression}) | newline
= print({Expression}, end='', flush=True) | ~newline

[While]
Text = while {condition}:
= -->BLOCK | | 1
= pass | ~block | 1

14.7.5 Linguaggio di programmazione Visual Basic .NET

[Language]
Name = Visual Basic .NET
Extension = vb

Keywords = AddHandler, AddressOf, Alias, And, AndAlso, As, Boolean, ByRef, Byte,
ByVal
= Call, Case, Catch, CBool, CByte, CChar, CDate, CDec, CDbl, Char
= CInt, Class, CLng, CObj, Const, Continue, CSByte, CShort, CSng, CStr
= CType, CUInt, CULng, CUShort, Date, Decimal, Declare, Default,
Delegate, Dim
= DirectCast, Do, Double, Each, Else, ElseIf, End, EndIf, Enum, Erase
= Error, Event, Exit, False, Finally, For, Friend, Function, Get,
GetType
= Global, GoSub, GoTo, Handles, If, Implements, Imports, In, Inherits,
Integer
= Interface, Is, IsNot, Let, Lib, Like, Long, Loop, Me, Mod
= Module, MustInherit, MustOverride, MyBase, MyClass, Namespace,
Narrowing, New, Next
= Not, Nothing, NotInheritable, NotOverridable, Object, Of, On,
Operator, Option, Optional

© 2023 Roberto Atzori

 Paradigma di Programmazione 201

= Or, OrElse, Overloads, Overridable, Overrides, ParamArray, Partial,

Private, Property, Protected
= Public, RaiseEvent, ReadOnly, ReDim, REM, RemoveHandler, Resume,
Return, SByte, Select
= Set, Shadows, Shared, Short, Single, Static, Step, Stop, String,
Structure
= Sub, SyncLock, Then, Throw, To, True, Try, TryCast, TypeOf, Variant
= Wend, UInteger, ULong, UShort, Using, When, While, Widening, With,
WithEvents
= WriteOnly, Xor

Conflicts = inputText, inputValue, output

Case Sensitive = false

Options =

; =======================================================
; Literals
; =======================================================

[Types]
Integer = Integer
Real = Double
Boolean = Boolean
String = String

[Function ID]
Convention = proper
Normal = {Name}
Conflict = [{Name}]

[Variable ID]
Convention = camel
Normal = {Name}
Conflict = [{Name}]

[String Literal]
Text = "{Characters}"
Replace Char 1 = "
Replace By 1 = ""

[Boolean Literal]
true = True
false = False

[Integer Literal]
Text = {Integral}

[Real Literal]
Text = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text = {Name} | ~subscript
= {Name}({Subscript}) | subscript

; =======================================================
; Expressions
; =======================================================
; VB .NET precedence:
; 1. or
; 2. and
; 3. not
; 4. Relational and equality: =, >, < ...
; 5. Addition
; 6. Multiply
; 7. Unary: -
; 8. ^

© 2023 Roberto Atzori

202 Flowgorithm

; 100. Atom, paranthesis

[Or]
Precedence = 1
Needed 1 = 1
Needed 2 = 2
Text = {1} Or {2}

[And]
Precedence = 2
Needed 1 = 2
Needed 2 = 3
Text = {1} And {2}

;=== NOT is precedence 3

[Equals]
Precedence = 4
Needed 1 = 5
Needed 2 = 5
Text = {1} = {2}

[Not Equals]
Precedence = 4
Needed 1 = 5
Needed 2 = 5
Text = {1} <> {2}

[Less Than]
Precedence = 4
Needed 1 = 5
Needed 2 = 5
Text = {1} < {2}

[Less Equal Than]

Precedence = 4
Needed 1 = 5
Needed 2 = 5
Text = {1} <= {2}

[Greater Than]
Precedence = 4
Needed 1 = 5
Needed 2 = 5
Text = {1} > {2}

[Greater Equal Than]

Precedence = 4
Needed 1 = 5
Needed 2 = 5
Text = {1} >= {2}

[Concatenate]
Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} & {2}

[Add]
Precedence = 5
Needed 1 = 5
Needed 2 = 6
Text = {1} + {2}

[Subtract]
Precedence = 5
Needed 1 = 5
Needed 2 = 6

© 2023 Roberto Atzori

 Paradigma di Programmazione 203

Text = {1} - {2}

[Multiply]
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} * {2}

[Divide]
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} / {2}

[Modulus]
Precedence = 6
Needed 1 = 6
Needed 2 = 7
Text = {1} Mod {2}

[Power]
Precedence = 8
Needed 1 = 9
Needed 2 = 8
Text = {1} ^ {2}

[Not]
Precedence = 3
Needed 1 = 3
Text = Not {1}

[Negate]
Precedence = 7
Needed 1 = 7
Text = -{1}

[Subexpression]
Precedence = 100
Text = ({Expression})

; =======================================================
; Intrinsic Functions
; =======================================================

[Abs]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[ArcCos]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[ArcSin]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[ArcTan]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Char]
Precedence = 100
Needed 1 = 100

© 2023 Roberto Atzori

204 Flowgorithm

Needed 2 = 1
Text = {1}.CharAt({2})

[Cos]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Int]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Len]
Precedence = 100
Needed 1 = 100
Text = {1}.Length

[Log]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Log10]
Precedence = 100
Needed 1 = 1
Text = Math.Log10({1})

[Pi]
Precedence = 100
Text = [Link]

[Random]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Sin]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Sgn]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Size]
Precedence = 100
Needed 1 = 100
Text = {1}.Length

[Sqrt]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[Tan]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[ToChar]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

© 2023 Roberto Atzori

 Paradigma di Programmazione 205

[ToCode]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[ToFixed]
Precedence = 100
Needed 1 = 1
Needed 2 = 1
Text = ToFixed({1}, {2})

[ToInteger]
Precedence = 100
Needed 1 = 1
Text = Convert.ToInt32({1})

[ToReal]
Precedence = 100
Needed 1 = 1
Text = [Link]({1})

[ToString]
Precedence = 100
Needed 1 = 100
Text = {1}.ToString()

; =======================================================
; Function call
; =======================================================

[Function Call]
Precedence = 100
Text = {name}({arguments})

[Argument]
Separator = ,{space}
Text = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text = Imports System
=
= Public Module MyProgram
= Private random as new Random() | Random | 1
= | Random | 1

= -->MAIN | | 1
= -->FUNCTIONS | | 1

= |
tofixed | 1
= Function ToFixed(value As Double, digits As Integer) As String |
tofixed | 1
= Return [Link]("f" & digits) |
tofixed | 2
= End Function |
tofixed | 1

= |
input | 1
= ' .NET can only read single characters or entire lines from the console. |
input | 1
= ' The following functions are designed to help input specific data types. |
input | 1
= Private Function inputValue() As Double | input | 1

© 2023 Roberto Atzori

206 Flowgorithm

= Dim result As Double | input | 2

= While Not [Link]([Link](), result) | input | 2
= ' No code in the loop | input | 3
= End While | input | 2
= Return result | input | 2
= End Function | input | 1
= | input | 1
= Private Function inputText() As String | input | 1
= return [Link]() | input | 2
= End Function | input | 1

= | output | 1
= Private Sub output(text As String) | output | 1
= [Link](text) | output |
2
= End Sub | output | 1

= End Module

[Main]
Text = Sub Main | |
= -->BLOCK | | 1
= End Sub | |

; =======================================================
; Function
; =======================================================

[Parameter]
Separator = ,{space}
Text = {name} As {type} | ~array
= ByRef {name}() As {type} | array

[Function]
Text =
= Private Sub {name} ({parameters}) | ~return
= -->BLOCK | ~return | 1
= End Sub | ~return

= Private Function {name} ({parameters}) | return

= -->BLOCK | return | 1
= | return | 1
= Return {return } | return | 1
= End Function | return

; =======================================================
; Statements
; =======================================================

[Assign]
Text = {Variable} = {Expression}

[Call]
Text = {Name}({Arguments})

[Comment]
Text = ' {Text}

[Declare Name]
Separator = ,{space}
Text = {name} As {Type} | ~array
= {name}({Size}) As {Type} | array

[Declare]
Text = Dim {Variables}

[Do]

© 2023 Roberto Atzori

 Paradigma di Programmazione 207

Text = Do
= -->BLOCK | | 1
= Loop While {condition}

[For]
Text = For {Variable} = {Start} To {End} | ~step
= For {Variable} = {Start} To {End} Step {step} | step
= -->BLOCK | | 1

= Next

[Input]
Text = {Variable} = inputText() | ~string
= {Variable} = inputValue() | String

[If]
Text = If {condition} Then
= -->TRUEBLOCK | | 1
= Else | else
= -->FALSEBLOCK | else | 1
= End If

[Output]
Text = output({Expression})

[While]
Text = Do While {condition}
= -->BLOCK | | 1
= Loop

© 2023 Roberto Atzori

Capitolo XV
 Versioni precedenti 209

15 Versioni precedenti
15.1 Versioni 32 bit
[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

© 2023 Roberto Atzori

210 Flowgorithm

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

© 2023 Roberto Atzori

 Versioni precedenti 211

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

© 2023 Roberto Atzori

 212 Flowgorithm

15.2 Versioni 64 bit

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

© 2023 Roberto Atzori

 Versioni precedenti 213

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

© 2023 Roberto Atzori

Capitolo XVI
 Altro 215

16 Altro

Contatto
e-mail: Flowgorithm [Link].

Informazioni
Origine del Nome
Il nome è la fusione dei termini “flowchart" e "algorithm".

Scritto in
Flowgorithm è implementato utilizzando Microsoft C#.

Autore

Devin Cook

Licenza
Download in PDF

Ulteriori Informazioni
Older Revisions

© 2023 Roberto Atzori

Capitolo XVII
 Esercizi 217

17 Esercizi
17.1 Esercizi - parte 1

Vai a Esercizi - parte 2 231

Vai all'eBook

Tipologia esercizio
Grafica Tartaruga
File
Elaborazioni Generiche / Matematiche
Elaborazioni con utilizzo di Stringhe
Elaborazioni con utilizzo di Array
Elaborazioni con utilizzo di Funzioni / Procedure
Elaborazioni Ricorsive

© 2023 Roberto Atzori

218 Flowgorithm

Esercizi
Dat
Nu a
Tipolo
me Descrizione mo Note
gia dific
ro
a
Somma di due numeri (v1 - usando una terza
1
variabile)
Somma di due numeri (v2 - senza usare una terza
2
variabile)
Scambiare due numeri (v1 - usando una terza
3
variabile)
Scambiare due numeri (v2 - senza usare una terza
4
variabile)
5 Data la base e l’altezza di un triangolo, scrivere l’area
6 Conversione angolare (gradi <--> radianti)
Addizionare due numeri usando la chiamata per valore
7
e la chiamata per riferimento

8 Simulazione sportello ATM

9 Verificare se un punto P è all'interno di un triangolo

Data la base e l’altezza di un rettangolo scrivere l’area
10
e il perimetro
Calcolare l’area e il perimetro di un rettangolo
11 conoscendo la base e l’altezza (con controllo misure
positive)
12 Calcolo area e circonferenza di un cerchio

Verificare se una retta è tangente, secante o è

13
esterna ad un cerchio

Verificare se un determinato cerchio risiede nella

14
corona di un altro cerchio (o due cerchi concentrici)

15 Figure Geometriche Piane

16 Conversione gradi centigradi in Fahrenheit

17 Convertire una stringa nei corrispettivi valori ASCII

© 2023 Roberto Atzori

 Esercizi 219

Tabella dei valori ASCII (come usare le funzioni

18
Flowgorithm ToString, ToChar e ToCode)
Somma delle cifre di un numero fino ad ottenere una
19
sola cifra
20 Inverso di un numero
21 Calcolo di una serie

22 Serie di potenze

23 Progressione aritmetica

24 Progressione geometrica

25 Progressione geometrica con funzione

26 Progressione geometrica con funzione (ricorsiva)
27 Somma di una progressione geometrica infinita
Calcolo del resto nella divisione tra interi in N (naturali
28
positivi) – MOD
Calcolo del resto nella divisione tra interi in Z (numeri
29
relativi) - funzione MOD
Calcolo del resto nella divisione tra interi in Z (numeri
30
relativi) – senza funzione MOD
Controlla se un numero è divisibile per un altro –
31
senza funzione MOD
Dati due numeri calcolare il loro quoziente se il
32 divisore è <> 0, ritornare “impossibile” se il divisore =
0

33 Calcolo della Media Pesata

34 Calcolo del Coefficiente di Correlazione

35 Calcolo di e^x (serie di Taylor)

Divisione di due numeri senza usare l’operatore di
36
divisione “/”
Inserire n numeri <> 0 (0 per finire), contare quanti
37
sono i numeri inseriti
Data una sequenza di n numeri interi, calcolare la
38
somma (S = a1+ a2 +…+ an)
39 Dati n numeri scrivere il loro prodotto
Moltiplicazione di due numeri senza usare l’operatore
40
di moltiplicazione “*”
41 Moltiplicazione di due numeri (algoritmo russo)
Moltiplicazione di due numeri senza usare l’operatore
42
di moltiplicazione “*” (ricorsivo)
Dato un numero determinare se è positivo, negativo o
43
nullo

© 2023 Roberto Atzori

220 Flowgorithm

Dati tre numeri reali dire che tipo di triangolo essi

44
formano (classificazione dei triangoli in base ai lati)
Data una sequenza di n numeri interi, calcolare la
45
somma dei pari ed il prodotto dei dispari
Dati due numeri, determinare il maggiore (verificare
46
anche se sono uguali)
47 Calcolare il massimo tra 2 numeri
48 Calcolare il massimo tra 4 numeri con due cicli diversi
Data una sequenza di numeri visualizzare il numero
49
minimo

50 Massimo Comune Divisore (M.C.D.) tra due numeri

Massimo Comune Divisore (M.C.D.) tra due numeri

51
(algoritmo di Euclide)

52 Distributore di bevande

53 Cambia monete

Converte un certo numero giorni in anni, settimane,

54
giorni

55 Ascensore (automa a stati finiti)

Funzioni Ceil, Floor, Frac, Truncate, Round, Mod

56
(anche per numeri negativi)

57 Numeri sconnessi

© 2023 Roberto Atzori

 Esercizi 221

58 Controllare se un numero è pronico

Massimo Comune Divisore (M.C.D.) tra due numeri

59
(algoritmo di Euclide ricorsivo)
60 M.C.D. ricorsivo tra due numeri interi
61 Minimo comune multiplo (m.c.m.) tra due numeri
Minimo comune multiplo (m.c.m.) tra due numeri
62
ricorsivo
Massimo Comune Divisore (M.C.D.) e Minimo
63
Comune Multiplo (m.c.m.) tra n numeri
Dato un numero scrivere se è multiplo di 10 con e
64
senza MOD

Dati due interi 'a' e 'm', trovare il moltiplicativo

65
modulare inverso di 'a' sotto modulo 'm'.

Dati due interi n e k entrambi maggiori di 0,

66
visualizzare i primi n multipli di k
Trovare il più grande multiplo di un numero in una lista
67
di numeri casuali
Dati due interi N e K, entrambi maggiori di 0,
68 stampare il risultato della sommatoria k +k2 +k3 +...
+kn.
Letto N > 0 intero, stampa i primi N numeri della
69

Rappresentazione di un numero come somma di

70 numeri non adiacenti di Fibonacci (Teorema di
Zeckendorf)
71 Calcolo dei numeri N-bonacci
Calcolo dei numeri N-bonacci (metodo finestra
72
scorrevole)
La funzione toziente di Eulero per tutti i numeri più
73
piccoli o uguale a n

Ennesimo elemento di Cantor nell’insieme dei numeri

74
razionali

Stampa i primi N numeri della successione di

75
Fibonacci (ricorsivo)
76 Somma valori positivi e negativi
Letto un numero intero positivo n stampare il
77
fattoriale: n! = 1 · 2 · 3 · . . . ·n.
78 Numero forte

© 2023 Roberto Atzori

222 Flowgorithm

79 Fattoriale inverso
80 Calcolo del fattoriale (visione di tutte le cifre)
Calcolo del fattoriale utilizzando la formula di Stirling
81
per i grandi numeri
82 Calcolo delle disposizioni semplici

83 Calcolo delle disposizioni con ripetizione

84 Calcolo delle permutazioni

85 Calcolo delle permutazioni con ripetizione singola

86 Calcolo delle permutazioni con più ripetizioni

87 Calcolo delle combinazioni semplici

88 Calcolo delle combinazioni con ripetizioni

Campionamento Reservoir: scegliere k gruppi da una
89
lista di n elementi
Distribuire M elementi in un cerchio di grandezza N
90
partendo dalla k-esima posizione
91 Calcolare se un anno è bisestile o meno.
92 Controllo validità data
Dato un numero N intero contare quanti sono i suoi
93
divisori
94 Calcolo del valore seno e del coseno di un angolo
95 Dato un numero N intero trovare tutti i suoi divisori
Dati un numero b (base) ed un numero e (esponente)
96
calcolare la potenza p = b^e
Calcolo di una potenza senza usare moltiplicazione o
97
divisione
98 Calcolo di una potenza per grandi numeri
Visualizza tutte le coppie di numeri la cui somma sia
99
uguale a N
100 Calcolo di una potenza utilizzando la ricorsione
101 Dati n numeri reali calcolarne la media aritmetica
102 Calcolo della media di un flusso di numeri
103 Conta i numeri che non contengono la cifra 3
104 Contare quanti numeri possiedono ‘0’ come cifra
105 Numero di Harshad
Intero come somma di numeri naturali unici all’ n-
106
esima potenza

© 2023 Roberto Atzori

 Esercizi 223

Trovare l’altra coordinata di un punto di una linea

107 sapendo le coordinate di un punto e del punto
intermedio

108 Conversione binario decimale

109 Numeri di Armstrong

110 Numeri di Catalan

111 Percorso Dyck

Date due monete di taglio "X" e "Y", trovare la più

112 grande quantità che non può essere ottenuta
utilizzando queste due monete (Frobenius coin)

Dato un numero N intero (N > 0) verificare se è un

113
numero perfetto.

Dati due numeri interi N e M (N > 0 e M > 0) verificare

114
sono amicabili (o amici).

Dati N valori diversi da zero, calcolare la media

115 aritmetica dei medesimi e la percentuale dei positivi
sul totale.
116 Calcolo della radice quadrata di un numero
117 Calcolo della radice n-esima di un numero
Calcolo della radice di un numero con una data
118
precisione usando la ricerca binaria
119 Dato un intero N trovare tutti i suoi fattori primi
120 Scomposizione grafica in fattori primi
121 Visualizzare i primi N numeri primi
122 Numeri primi in un intervallo
123 Numeri primi intrecciati
Dato un numero X (>5) visualizzare i tre numeri primi
124
(anche uguali) la cui somma è pari ad X.

© 2023 Roberto Atzori

224 Flowgorithm

Dato un numero segreto tra 0 e 100, visualizzare in

125
quanti tentativi N l’utente ha indovinato.
Dato un numero segreto visualizzare in quanti tentativi
126
N l’utente ha indovinato (con livelli di difficoltà).

127 Il gioco della Morra Cinese

128 Il gioco del NIM

129 Risoluzione equazione di I grado

130 Risoluzione equazione di II grado.
131 Trovare x e y che soddisfino l’equazione ax + by = c
132 Risoluzione in Z dell’equazione ax + by = c

Soluzione di una equazione algebrica trascendente

133
(metodo Newton Raphson)

Soluzione di una equazione algebrica trascendente

134
(metodo della bisezione)

135 Calcolo del giorno di Pasqua

Generatore Numeri reali Pseudo Casuali maggiori di 0
136
e minori di 1
Generare numeri casuali da 1 a N con uguale
137
probabilità
138 Generazione di numeri pseudo-casuali 1
139 Generazione di numeri pseudo-casuali 2
Generazione di numeri pseudo-casuali (metodo di
140
Lehmer)

© 2023 Roberto Atzori

 Esercizi 225

Metodo di Runge-Kutta del 4°ordine per il calcolo di

141
una equazione differenziale

Metodo di Eulero per il calcolo di una equazione

142
differenziale

Calcolare il valore di pi greco usando il metodo di

143
Montecarlo (circle problem approximation)
144 Fattoriale di un numero con ricorsione
145 Funzione pari o dispari mutuamente ricorsiva
Funzione ricorsiva annidata per calcolare la funzione di
146
Ackerman
147 Torre di Hanoi
Visualizzazione carattere per carattere di una stringa
148
in input
Funzione STRING del Visual Basic - utilizzo con
149
funzione
Visualizza tutte le combinazioni di punteggi per
150
raggiungere il risultato finale
151 Generare figura contornata e riempita da simboli
152 Generare piramide invertita angolata a destra
153 Generare piramide angolata a sinistra
154 Generare piramide angolata a destra
155 Funzione MID del Visual Basic
156 Funzione MID del Visual Basic - utilizzo con funzione

157 Distanza di Hamming tra due stringhe

158 Crittografia – Cifratura di Cesare (cifratura traslata)

© 2023 Roberto Atzori

226 Flowgorithm

Data una stringa di caratteri contare gli spazi in essa

159
contenuti
160 Confronta due stringhe con o senza Case Sensitive
Conta numero di parole, cifre, vocali e caratteri
161
speciali
Data una stringa di caratteri dire quante volte è
162
contenuta in essa una data sottostringa
Data una stringa di caratteri inserire un carattere
163
dopo una data lettera
Data una stringa di caratteri inserire un carattere
164
prima di una data lettera
Data una stringa di caratteri inserire un carattere
165
prima e dopo una data lettera

166 Triangolo di Floyd con numeri

167 Triangolo di Floyd con caratteri

168 Triangolo di Tartaglia

169 Alfabeto Farfallino

Data una stringa di caratteri inserire uno o più

170
caratteri dopo una data sottostringa
Data una stringa di caratteri inserire uno o più
171
caratteri prima di una data sottostringa
Data una stringa di caratteri inserire uno o più
172
caratteri prima e dopo una data sottostringa
Funzione UCASE del Visual Basic - utilizzo con
173
funzione
Funzione LCASE del Visual Basic - utilizzo con
174
funzione
175 Controlla se il carattere inserito è in forma maiuscola
176 Funzione LEFT del Visual Basic - utilizzo con funzione
Funzione RIGHT del Visual Basic - utilizzo con
177
funzione

© 2023 Roberto Atzori

 Esercizi 227

178 Funzione INSTR del Visual Basic - utilizzo con funzione

Funzione LTRIM del Visual Basic - utilizzo con
179
funzione
Funzione RTRIM del Visual Basic - utilizzo con
180
funzione
181 Rimuovere tutti gli spazi non necessari in una stringa
182 Funzione TRIM del Visual Basic - utilizzo con funzione
Funzione REPLACE del Visual Basic - utilizzo con
183
funzione
184 Differenza tra due orari
Verificare che data una stringa in input essa sia
185
palindroma o simmetrica

186 Trovare i numeri “factorion”

Verificare che data una stringa in input essa sia

187
palindroma o simmetrica - ricorsivo
188 Verificare se un numero è palindromo
189 Ricerca un numero palindromo in un intervallo
Trasformazione angoli in gradi sessagesimali (angolo
190
goniometrico)
Trasformazione numero reale o periodico (semplice o
191
misto) in frazione con semplificazione
192 Lettura e scrittura di elementi in un vettore
Data una sequenza di numeri visualizzare il numero
193
massimo e quello minimo
194 Come definire una struttura
195 Calcolo di un integrale definito (metodo trapezoidale)
196 Calcolo di un integrale definito (metodo Simpson)
197 Calcolo di un integrale definito (metodo Villarceau)
198 Ricerca sequenziale di un elemento in un vettore
Ricerca sequenziale di un elemento in un vettore
199
(ricorsiva)
200 Ricerca per interpolazione su array
Copiare tutti gli elementi di un vettore in un altro
201
vettore
202 Inserire un elemento in un vettore
203 Cancellare un elemento in un vettore
204 Inversione degli elementi di un vettore
205 Inversione degli elementi di un vettore (con funzione)
206 Cancellare gli elementi duplicati di un vettore
207 Riempire un vettore con i quadrati dei numeri
208 Inserire delle coordinate in un array
209 Conversione di un numero intero in numero romano

© 2023 Roberto Atzori

228 Flowgorithm

Letti in input due array di interi con lo stesso numero

N di elementi, costruire un terzo array di numeri con la
210 somma degli elementi corrispondenti nei primi due

l’array C. (vettori paralleli)

Letti in input tre array di interi con lo stesso numero N
di elementi, costruire un quarto array di numeri con la
211 media aritmetica degli elementi corrispondenti nei
primi tre (es.: Di = (Ai +Bi + Ci )/3, per i = 0, 1, . . . ,n

Trovare un numero con un numero massimo di fattori

212
primi
213 Conversione di un numero romano in intero
214 Convertire le cifre di un numero intero in inglese
Acquisire N numeri naturali e visualizzare il minimo
215
comune multiplo dei numeri acquisiti (con array).
216 Calcolo del giorno della settimana di una data
217 Calcolare la somma degli elementi di un vettore
218 Conversione decimale --> binario
219 Conversione decimale --> ottale
220 Conversione decimale --> esadecimale
221 Ricercare l’elemento minore in un vettore
222 Ricercare l’elemento maggiore di un vettore
Visualizza gli elementi del secondo vettore comuni a
223
quelli del primo vettore
Schedulazione Processi – Primo Arrivato Primo
224
Servito
225 Schedulazione Processi – Lavoro più breve
226 Schedulazione Processi – Priorità
227 Schedulazione Processi – Round Robin

228 Schedulazione Processi – Next Fit

229 Scrivere una frase al contrario

Converte una stringa nella equivalente sequenza

230
numerica del tastierino del telefono

© 2023 Roberto Atzori

 Esercizi 229

Ricercare l’elemento maggiore di un vettore (con

231
funzioni)
Ricercare l’elemento minore di un vettore e
232 scambiarlo con l’elemento nella prima posizione (con
funzioni)
233 Numeri primi con il Crivello di Eratostene
234 Numeri fortunati
235 Problema dello zaino con il metodo greedy
Massimizzare l’acquisto di giocattoli da comprare
236
avendo una certa somma da spendere
237 Mescola array di interi
Mescola array di stringhe casuali di grandezza fissa o
238
variabile
239 Acronimo

240 Il gioco dell’impiccato

241 Anagramma di una stringa

242 Conversione numero decimale --> binario
Conversione da numero decimale a numero in base
243
tra 2 e 16
Conversione da numero in qualsiasi base in numero
244
decimale e viceversa
Conversione da numero in qualsiasi base in numero
245
decimale e viceversa ver. 2
Conversione da numero in qualsiasi base in numero
246
decimale e viceversa tramite funzione
Operazioni aritmetiche tra due numeri in qualsiasi
247
base (da 2 a 36)
Cancellare le occorrenze di un carattere da una
248
stringa
249 Cancellare le occorrenze vocali da una stringa

250 Cancellare le occorrenze cifre da una stringa

Cancellare le occorrenze caratteri di una prima stringa
251
da una seconda stringa
Controllare se due stringhe sono una l’anagramma
252
dell’altra
253 Conversione dal colore HTML al colore RGB

© 2023 Roberto Atzori

230 Flowgorithm

254 Il gioco del Master Mind

Disporre gli elementi pari di un vettore nelle posizioni

255
iniziali e gli elementi dispari nelle posizioni finali
256 Ricerca Naive

257 Ricerca Naive ottimizzata

258 Ricerca Rabin-Karp

259 Problema delle 8 regine

260 Codifica con Fibonacci

261 Inserire in un array gli elementi di un insieme

Spostamento a destra dei bit di un numero intero per

262
un numero di posizioni specificato
Spostamento a sinistra dei bit di un numero intero per
263
un numero di posizioni specificato

264 Operatori a livello del bit (AND, OR, XOR) con interi

265 Problema delle 8 regine (con back tracking)

266 Ricerca binaria ricorsiva su array

267 Ordinamento per selezione
268 Ordinamento per inserzione
269 Ordinamento a bolle
270 Ordinamento Cocktail
271 Ordinamento Comb
272 Ordinamento Gnome
273 Ordinamento Jump
274 Ordinamento Shaker

© 2023 Roberto Atzori

 Esercizi 231

275 Ordinamento Pari-Dispari

276 Ordinamento Stooge (ricorsivo)
277 Ordinamento Shell Sort
278 Ordinamento Heap Sort
Trovare il primo numero più frequente in una vettore
279
(con Heap Sort)
280 Ordinamento Quick Sort (ricorsivo)

281 Ordinamento Randomize Quick Sort (ricorsivo)

282 Ordinamento Merge Sort (ricorsivo)

283 Stack con array
284 Coda circolare con array
Letta in input una stringa che rappresenta
un’espressione aritmetica, verificare che le parentesi
285
siano collocate correttamente. Bilanciamento
parentesi.
286 Fusione tra due vettori di interi ordinati

Scomposizione di un polinomio con grado maggiore 1

287
con Ruffini

Calcolare le radici complesse di un polinomio f(x) col

288
metodo di Bairstow
289 Fusione ricorsiva tra due vettori di interi ordinati
Trasformazione array bidimensionale (Matrice) in
290
array monodimensionale (Vettore)
291 Numero palindromo
292 Divisori palindromi di un numero
293 Divisori palindromi in un intervallo numerico
294 Ricerca ricorsiva dei fattori di un numero
295 Simulazione funzione ‘memset’ del linguaggio C

17.2 Esercizi - parte 2

Vai a Esercizi - parte 1 217

Tipologia esercizio
Grafica Tartaruga
File
Elaborazioni Generiche / Matematiche
Elaborazioni con utilizzo di Stringhe

© 2023 Roberto Atzori

232 Flowgorithm

Elaborazioni con utilizzo di Array

Elaborazioni con utilizzo di Funzioni / Procedure
Elaborazioni Ricorsive

Esercizi
Nu Data
Tipolo
mer Descrizione mod Note
o gia ifica

1 Crittografia – Cifratura di Vigenere

2 Disegno floreale
3 Poligoni regolari
4 Disegnare una stella
5 Disegnare scale
Autore: Petr
6 Disegno di funzione
Vanecek
7 Lettura da file
8 Scrittura su file: numeri di Fibonacci
9 Scrittura su file: elevamento al quadrato di numeri
(vedere esercizio n.
10 Giorno della settimana ver 2 216 in 'Esercizi -
parte 1')
11 Calcolare il numero di occorrenze di un numero
Calcolare il numero di occorrenze delle parole
12
inserite
Vedere
13 Conversione data giuliana -> gregoriana
approfondimento
Autore: Shafiqur
14 Separatore di parole
Bhuiyan
15 Visualizzare i sottomultipli di N (col calcolo del resto)

16 Il gioco del Tris

Autore: Shafiqur
Bhuiyan

© 2023 Roberto Atzori

 Esercizi 233

17 Ordinamento ascendente e discendente alternato

18 Simulazione genetica Autore: ???
19 Simulazione matrice
Autore: Wichart
20 Pig Latin
Manachaimongkol
Controllare se un vettore è monotonico ascendente o
21
monotonico discendente
Trovare la capacità equivalente di un circuito di
22
condensatori in parallelo
Trovare la capacità equivalente di un circuito di
23
condensatori in serie
Trovare la resistenza equivalente di un circuito di
24
resistenze in parallelo
Trovare la resistenza equivalente di un circuito di
25
resistenze in serie
26 Distanza tra due punti nel piano cartesiano
Distanza tra due punti nel piano cartesiano (con
27
funzione)

28 Hilbert (frattale)

29 Albero (frattale)

30 Stella

31 Stella (frattale)

Files - Ricerca di stringa all'interno di ogni riga in un

32
file di testo

33 Ottagono

© 2023 Roberto Atzori

234 Flowgorithm

34 Spirale

35 Quadrati

36 Fiocco di neve di Kock (frattale)

37 Quadrati (frattale)

38 Triangoli (frattale)

39 Curve (frattale)

40 Incroci (frattale)

41 La mia città

42 Generatore di istogrammi

43 Stella marina

44 Fiore

© 2023 Roberto Atzori

 Esercizi 235

45 Mandala

46 Spirale

47 Movimento casuale

48 Conchiglia

49 Addobbo

50 Felce

51 Sierpinski

52 Disegnare un arco o un cerchio

53 Assi cartesiani

54 Stelle casuali

55 Naifeh Saida

56 Naifeh Saida inverso

© 2023 Roberto Atzori

236 Flowgorithm

57 Rosa dei venti

58 Orologio (solo lancetta secondi)

59 Cronometro inverso

60 Cronometro da cucina

© 2023 Roberto Atzori